signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
@cli.command()<EOL>@click.pass_obj<EOL>def distance(globs): | globs.locations.distance()<EOL> | Calculate distance between locations. | f12207:m4 |
@cli.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.pass_obj<EOL>def final_bearing(globs, string): | globs.locations.bearing('<STR_LIT>', string)<EOL> | Calculate final bearing between locations. | f12207:m5 |
@cli.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=<NUM_LIT:0>, type=float,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Choice(['<STR_LIT:h>', '<STR_LIT:m>', '<STR_LIT:s>']),<EOL>help='<STR_LIT>')<EOL>@click.pass_obj<EOL>def flight_plan(globs, speed, time): | globs.locations.flight_plan(speed, time)<EOL> | Calculate flight plan for locations. | f12207:m6 |
@cli.command()<EOL>@click.argument('<STR_LIT>', type=float)<EOL>@click.pass_obj<EOL>def range(globs, distance): | globs.locations.range(distance)<EOL> | Check locations are within a given range. | f12207:m7 |
@cli.command()<EOL>@click.pass_obj<EOL>def sunrise(globs): | globs.locations.sun_events('<STR_LIT>')<EOL> | Calculate the sunrise time for locations. | f12207:m8 |
@cli.command()<EOL>@click.pass_obj<EOL>def sunset(globs): | globs.locations.sun_events('<STR_LIT>')<EOL> | Calculate the sunset time for locations. | f12207:m9 |
def read_locations(filename): | data = ConfigParser()<EOL>if filename == '<STR_LIT:->':<EOL><INDENT>data.read_file(sys.stdin)<EOL><DEDENT>else:<EOL><INDENT>data.read(filename)<EOL><DEDENT>if not data.sections():<EOL><INDENT>logging.debug('<STR_LIT>')<EOL><DEDENT>locations = {}<EOL>for name in data.sections():<EOL><INDENT>if data.has_option(name, '<STR_LIT>'):<EOL><INDENT>latitude, longitude = utils.from_grid_locator(data.get(name,<EOL>'<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>latitude = data.getfloat(name, '<STR_LIT>')<EOL>longitude = data.getfloat(name, '<STR_LIT>')<EOL><DEDENT>locations[name] = (latitude, longitude)<EOL><DEDENT>return locations<EOL> | Pull locations from a user's config file.
Args:
filename (str): Config file to parse
Returns:
dict: List of locations from config file | f12207:m10 |
def read_csv(filename): | field_names = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:name>')<EOL>data = utils.prepare_csv_read(filename, field_names, skipinitialspace=True)<EOL>locations = {}<EOL>args = []<EOL>for index, row in enumerate(data, <NUM_LIT:1>):<EOL><INDENT>name = '<STR_LIT>' % (index, row['<STR_LIT:name>'])<EOL>locations[name] = (row['<STR_LIT>'], row['<STR_LIT>'])<EOL>args.append(name)<EOL><DEDENT>return locations, args<EOL> | Pull locations from a user's CSV file.
Read gpsbabel_'s CSV output format
.. _gpsbabel: http://www.gpsbabel.org/
Args:
filename (str): CSV file to parse
Returns:
tuple of dict and list: List of locations as ``str`` objects | f12207:m11 |
def main(): | logging.basicConfig(format='<STR_LIT>')<EOL>try:<EOL><INDENT>cli()<EOL>return <NUM_LIT:0><EOL><DEDENT>except LocationsError as error:<EOL><INDENT>print(error)<EOL>return <NUM_LIT:2><EOL><DEDENT>except RuntimeError as error:<EOL><INDENT>print(error)<EOL>return <NUM_LIT:255><EOL><DEDENT>except OSError as error:<EOL><INDENT>return error.errno<EOL><DEDENT> | Main script handler.
Returns:
int: 0 for success, >1 error code | f12207:m12 |
def __init__(self, function=None, data=None): | super(LocationsError, self).__init__()<EOL>self.function = function<EOL>self.data = data<EOL> | Initialise a new ``LocationsError`` object.
Args:
function (str): Function where error is raised
data (tuple): Location number and data | f12207:c0:m0 |
def __str__(self): | if self.function:<EOL><INDENT>return '<STR_LIT>' % self.function<EOL><DEDENT>elif self.data:<EOL><INDENT>return '<STR_LIT>' % self.data<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT> | Pretty printed error string.
Returns:
str: Human readable error string | f12207:c0:m1 |
def __init__(self, latitude, longitude, name, units='<STR_LIT>'): | super(NumberedPoint, self).__init__(latitude, longitude, units)<EOL>self.name = name<EOL> | Initialise a new ``NumberedPoint`` object.
Args:
latitude (float): Location's latitude
longitude (float): Location's longitude
name (str): Location's name or command line position
units (str): Unit type to be used for distances | f12207:c1:m0 |
def __format__(self, format_spec='<STR_LIT>'): | return super(NumberedPoint, self).__format__('<STR_LIT>')<EOL> | Extended pretty printing for location strings.
Args:
format_spec (str): Coordinate formatting system to use
Returns:
str: Human readable string representation of ``NumberedPoint``
object
Raises:
ValueError: Unknown value for ``format_spec`` | f12207:c1:m1 |
def __init__(self, locations=None, format='<STR_LIT>', verbose=True,<EOL>config_locations=None, units='<STR_LIT>'): | super(NumberedPoints, self).__init__()<EOL>self.format = format<EOL>self.verbose = verbose<EOL>self._config_locations = config_locations<EOL>self.units = units<EOL>if locations:<EOL><INDENT>self.import_locations(locations, config_locations)<EOL><DEDENT> | Initialise a new ``NumberedPoints`` object.
Args:
locations (list of str): Location identifiers
format (str): Coordinate formatting system to use
verbose (bool): Whether to generate verbose output
config_locations (dict): Locations imported from user's config
file
units (str): Unit type to be used for distances | f12207:c2:m0 |
def __repr__(self): | return utils.repr_assist(self, {'<STR_LIT>': self[:]})<EOL> | Self-documenting string representation.
Returns:
str: String to recreate ``NumberedPoints`` object | f12207:c2:m1 |
def import_locations(self, locations, config_locations): | for number, location in enumerate(locations):<EOL><INDENT>if config_locations and location in config_locations:<EOL><INDENT>latitude, longitude = config_locations[location]<EOL>self.append(NumberedPoint(latitude, longitude, location,<EOL>self.units))<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>data = utils.parse_location(location)<EOL>if data:<EOL><INDENT>latitude, longitude = data<EOL><DEDENT>else:<EOL><INDENT>latitude, longitude = utils.from_grid_locator(location)<EOL><DEDENT>self.append(NumberedPoint(latitude, longitude, number + <NUM_LIT:1>,<EOL>self.units))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise LocationsError(data=(number, location))<EOL><DEDENT><DEDENT><DEDENT> | Import locations from arguments.
Args:
locations (list of str): Location identifiers
config_locations (dict): Locations imported from user's config
file | f12207:c2:m2 |
def display(self, locator): | for location in self:<EOL><INDENT>if locator:<EOL><INDENT>output = location.to_grid_locator(locator)<EOL><DEDENT>else:<EOL><INDENT>output = format(location, self.format)<EOL><DEDENT>if self.verbose:<EOL><INDENT>click.echo('<STR_LIT>' % (location.name, output))<EOL><DEDENT>else:<EOL><INDENT>click.echo(output)<EOL><DEDENT><DEDENT> | Pretty print locations.
Args:
locator (str): Accuracy of Maidenhead locator output | f12207:c2:m3 |
def distance(self): | distances = list(super(NumberedPoints, self).distance())<EOL>leg_msg = ['<STR_LIT>', ]<EOL>total_msg = ['<STR_LIT>', ]<EOL>if self.units == '<STR_LIT>':<EOL><INDENT>leg_msg.append('<STR_LIT>')<EOL>total_msg.append('<STR_LIT>')<EOL><DEDENT>elif self.units == '<STR_LIT>':<EOL><INDENT>leg_msg.append('<STR_LIT>')<EOL>total_msg.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>leg_msg.append('<STR_LIT>')<EOL>total_msg.append('<STR_LIT>')<EOL><DEDENT>if self.verbose:<EOL><INDENT>for number, distance in enumerate(distances):<EOL><INDENT>click.echo('<STR_LIT:U+0020>'.join(leg_msg)<EOL>% (self[number].name, self[number + <NUM_LIT:1>].name,<EOL>distance))<EOL><DEDENT>if len(distances) > <NUM_LIT:1>:<EOL><INDENT>click.echo('<STR_LIT:U+0020>'.join(total_msg) % sum(distances))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>click.echo(sum(distances))<EOL><DEDENT> | Calculate distances between locations. | f12207:c2:m4 |
def bearing(self, mode, string): | bearings = getattr(super(NumberedPoints, self), mode)()<EOL>if string:<EOL><INDENT>bearings = map(utils.angle_to_name, bearings)<EOL><DEDENT>else:<EOL><INDENT>bearings = ['<STR_LIT>' % bearing for bearing in bearings]<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>verbose_fmt = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>verbose_fmt = '<STR_LIT>'<EOL><DEDENT>for number, bearing in enumerate(bearings):<EOL><INDENT>if self.verbose:<EOL><INDENT>click.echo(verbose_fmt % (self[number].name,<EOL>self[number + <NUM_LIT:1>].name,<EOL>bearing))<EOL><DEDENT>else:<EOL><INDENT>click.echo(bearing)<EOL><DEDENT><DEDENT> | Calculate bearing/final bearing between locations.
Args:
mode (str): Type of bearing to calculate
string (bool): Use named directions | f12207:c2:m5 |
def range(self, distance): | test_location = self[<NUM_LIT:0>]<EOL>for location in self[<NUM_LIT:1>:]:<EOL><INDENT>in_range = test_location.__eq__(location, distance)<EOL>if self.verbose:<EOL><INDENT>text = ['<STR_LIT>', ]<EOL>if not in_range:<EOL><INDENT>text.append('<STR_LIT>')<EOL><DEDENT>text.append('<STR_LIT>')<EOL>if self.units == '<STR_LIT>':<EOL><INDENT>text.append('<STR_LIT>')<EOL><DEDENT>elif self.units == '<STR_LIT>':<EOL><INDENT>text.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>text.append('<STR_LIT>')<EOL><DEDENT>text.append('<STR_LIT>')<EOL>click.echo('<STR_LIT:U+0020>'.join(text) % (location.name, distance,<EOL>self[<NUM_LIT:0>].name))<EOL><DEDENT>else:<EOL><INDENT>click.echo(in_range)<EOL><DEDENT><DEDENT> | Test whether locations are within a given range of the first.
Args:
distance (float): Distance to test location is within | f12207:c2:m6 |
def destination(self, distance, bearing, locator): | destinations = super(NumberedPoints, self).destination(bearing,<EOL>distance)<EOL>for location, destination in zip(self, destinations):<EOL><INDENT>if locator:<EOL><INDENT>output = destination.to_grid_locator(locator)<EOL><DEDENT>else:<EOL><INDENT>output = format(location, self.format)<EOL><DEDENT>if self.verbose:<EOL><INDENT>click.echo('<STR_LIT>'<EOL>% (location.name, output))<EOL><DEDENT>else:<EOL><INDENT>click.echo(output)<EOL><DEDENT><DEDENT> | Calculate destination locations for given distance and bearings.
Args:
distance (float): Distance to travel
bearing (float): Direction of travel
locator (str): Accuracy of Maidenhead locator output | f12207:c2:m7 |
def sun_events(self, mode): | mode_str = mode.capitalize()<EOL>times = getattr(super(NumberedPoints, self), mode)()<EOL>for location, time in zip(self, times):<EOL><INDENT>if self.verbose:<EOL><INDENT>if time:<EOL><INDENT>click.echo('<STR_LIT>'<EOL>% (mode_str, time, location.name))<EOL><DEDENT>else:<EOL><INDENT>click.echo("<STR_LIT>"<EOL>% (mode_str[<NUM_LIT:3>:], location.name))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>click.echo(time)<EOL><DEDENT><DEDENT> | Calculate sunrise/sunset times for locations.
Args:
mode (str): Sun event to display | f12207:c2:m8 |
def flight_plan(self, speed, time): | if len(self) == <NUM_LIT:1>:<EOL><INDENT>raise LocationsError('<STR_LIT>')<EOL><DEDENT>if self.verbose:<EOL><INDENT>click.echo('<STR_LIT>'<EOL>'<STR_LIT>' % (self.units, time))<EOL><DEDENT>legs = [(<NUM_LIT:0>, <NUM_LIT:0>), ] + list(self.inverse())<EOL>for leg, loc in zip(legs, self):<EOL><INDENT>if leg == (<NUM_LIT:0>, <NUM_LIT:0>):<EOL><INDENT>click.echo('<STR_LIT>' % (loc.name, loc.latitude,<EOL>loc.longitude))<EOL><DEDENT>else:<EOL><INDENT>leg_speed = '<STR_LIT>' % (leg[<NUM_LIT:1>] / speed) if speed != <NUM_LIT:0> else '<STR_LIT>'<EOL>click.echo('<STR_LIT>'<EOL>% (loc.name, leg[<NUM_LIT:0>], leg[<NUM_LIT:1>], leg_speed,<EOL>loc.latitude, loc.longitude))<EOL><DEDENT><DEDENT>if self.verbose:<EOL><INDENT>overall_distance = sum(map(itemgetter(<NUM_LIT:1>), legs))<EOL>direct_distance = self[<NUM_LIT:0>].distance(self[-<NUM_LIT:1>])<EOL>if speed == <NUM_LIT:0>:<EOL><INDENT>speed_marker = '<STR_LIT:#>'<EOL>overall_speed = '<STR_LIT>'<EOL>direct_speed = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>speed_marker = '<STR_LIT>'<EOL>overall_speed = '<STR_LIT>' % (overall_distance / speed)<EOL>direct_speed = '<STR_LIT>' % (direct_distance / speed)<EOL><DEDENT>click.echo('<STR_LIT>'<EOL>% (speed_marker, overall_distance, overall_speed))<EOL>click.echo('<STR_LIT>'<EOL>% (speed_marker, self[<NUM_LIT:0>].bearing(self[-<NUM_LIT:1>]),<EOL>direct_distance, direct_speed))<EOL><DEDENT> | Output the flight plan corresponding to the given locations.
.. todo:: Description
Args:
speed (float): Speed to use for elapsed time calculation
time (str): Time unit to use for output | f12207:c2:m9 |
def _gen_header(self, sequence, payloadtype): | protocol = bytearray.fromhex("<STR_LIT>")<EOL>source = bytearray.fromhex("<STR_LIT>")<EOL>target = bytearray.fromhex("<STR_LIT>")<EOL>reserved1 = bytearray.fromhex("<STR_LIT>")<EOL>sequence = pack("<STR_LIT>", sequence)<EOL>ack = pack("<STR_LIT>", <NUM_LIT:3>)<EOL>reserved2 = bytearray.fromhex("<STR_LIT>")<EOL>packet_type = pack("<STR_LIT>", payloadtype)<EOL>reserved3 = bytearray.fromhex("<STR_LIT>")<EOL>header = bytearray(protocol)<EOL>header.extend(source)<EOL>header.extend(target)<EOL>header.extend(reserved1)<EOL>header.extend(ack)<EOL>header.extend(sequence)<EOL>header.extend(reserved2)<EOL>header.extend(packet_type)<EOL>header.extend(reserved3)<EOL>return header<EOL> | Create packet header. | f12209:c2:m1 |
def _gen_packet(self, sequence, payloadtype, payload=None): | contents = self._gen_header(sequence, payloadtype)<EOL>if payload:<EOL><INDENT>contents.extend(payload)<EOL><DEDENT>size = pack("<STR_LIT>", len(contents) + <NUM_LIT:2>)<EOL>packet = bytearray(size)<EOL>packet.extend(contents)<EOL>return packet<EOL> | Generate packet header. | f12209:c2:m2 |
def _gen_packet_setcolor(self, sequence, hue, sat, bri, kel, fade): | hue = min(max(hue, HUE_MIN), HUE_MAX)<EOL>sat = min(max(sat, SATURATION_MIN), SATURATION_MAX)<EOL>bri = min(max(bri, BRIGHTNESS_MIN), BRIGHTNESS_MAX)<EOL>kel = min(max(kel, TEMP_MIN), TEMP_MAX)<EOL>reserved1 = pack("<STR_LIT>", <NUM_LIT:0>)<EOL>hue = pack("<STR_LIT>", hue)<EOL>saturation = pack("<STR_LIT>", sat)<EOL>brightness = pack("<STR_LIT>", bri)<EOL>kelvin = pack("<STR_LIT>", kel)<EOL>duration = pack("<STR_LIT>", fade)<EOL>payload = bytearray(reserved1)<EOL>payload.extend(hue)<EOL>payload.extend(saturation)<EOL>payload.extend(brightness)<EOL>payload.extend(kelvin)<EOL>payload.extend(duration)<EOL>return self._gen_packet(sequence, PayloadType.SETCOLOR, payload)<EOL> | Generate "setcolor" packet payload. | f12209:c2:m3 |
def _gen_packet_get(self, sequence): | <EOL>return self._gen_packet(sequence, PayloadType.GET)<EOL> | Generate "get" packet payload. | f12209:c2:m4 |
def _gen_packet_setpower(self, sequence, power, fade): | level = pack("<STR_LIT>", Power.BULB_OFF if power == <NUM_LIT:0> else Power.BULB_ON)<EOL>duration = pack("<STR_LIT>", fade)<EOL>payload = bytearray(level)<EOL>payload.extend(duration)<EOL>return self._gen_packet(sequence, PayloadType.SETPOWER2, payload)<EOL> | Generate "setpower" packet payload. | f12209:c2:m5 |
def _packet_ack(self, packet, sequence): | if packet["<STR_LIT>"] == sequence:<EOL><INDENT>if packet["<STR_LIT>"] == PayloadType.SETCOLOR:<EOL><INDENT>self._color_callback(packet["<STR_LIT:target>"],<EOL>packet["<STR_LIT>"],<EOL>packet["<STR_LIT>"],<EOL>packet["<STR_LIT>"],<EOL>packet["<STR_LIT>"])<EOL><DEDENT>elif packet["<STR_LIT>"] == PayloadType.SETPOWER2:<EOL><INDENT>self._power_callback(packet["<STR_LIT:target>"],<EOL>packet["<STR_LIT>"])<EOL><DEDENT>return False<EOL><DEDENT>return True<EOL> | Check packet for ack. | f12209:c2:m6 |
def _process_packet(self, sequence): | if self._packets:<EOL><INDENT>with self._packet_lock:<EOL><INDENT>self._packets[:] = [packet for packet in self._packets<EOL>if self._packet_ack(packet, sequence)]<EOL><DEDENT><DEDENT> | Check packet list for acks. | f12209:c2:m7 |
def _packet_timeout(self, packet, now): | if now >= packet["<STR_LIT>"]:<EOL><INDENT>return False<EOL><DEDENT>if now >= packet["<STR_LIT>"]:<EOL><INDENT>self._send_command(packet)<EOL>return False<EOL><DEDENT>return True<EOL> | Check packet for timeout. | f12209:c2:m8 |
def _packet_manager(self): | while True:<EOL><INDENT>if self._packets:<EOL><INDENT>with self._packet_lock:<EOL><INDENT>now = time.time()<EOL>self._packets[:] =[packet for packet in self._packets<EOL>if self._packet_timeout(packet, now)]<EOL><DEDENT><DEDENT>time.sleep(ACK_RESEND / <NUM_LIT:2>)<EOL><DEDENT> | Watch packet list for timeouts. | f12209:c2:m9 |
def _packet_listener(self): | while True:<EOL><INDENT>datastream, source = self._sock.recvfrom(BUFFERSIZE)<EOL>ipaddr, port = source<EOL>try:<EOL><INDENT>sio = io.BytesIO(datastream)<EOL>dummy1, sec_part = struct.unpack("<STR_LIT>",<EOL>sio.read(<NUM_LIT:4>))<EOL>protocol = sec_part % <NUM_LIT><EOL>if protocol == <NUM_LIT>:<EOL><INDENT>source, dummy1, dummy2, dummy3, sequence, dummy4,payloadtype, dummy5 = struct.unpack("<STR_LIT>",<EOL>sio.read(<NUM_LIT:32>))<EOL>if ipaddr == self._server_addr:<EOL><INDENT>pass<EOL><DEDENT>elif payloadtype == PayloadType.ACKNOWLEDGEMENT:<EOL><INDENT>self._process_packet(sequence)<EOL><DEDENT>elif payloadtype == PayloadType.STATE:<EOL><INDENT>hue, sat, bri, kel, dummy1, power, label, dummy2 =struct.unpack("<STR_LIT>",<EOL>sio.read(<NUM_LIT>))<EOL>name = label.decode('<STR_LIT:ascii>')<EOL>name = name.replace('<STR_LIT:\x00>', '<STR_LIT>')<EOL>self._device_callback(ipaddr, name, power, hue,<EOL>sat, bri, kel)<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT> | Packet listener. | f12209:c2:m10 |
def _send_command(self, cmd): | self._queue.put(cmd)<EOL> | Add to command queue. | f12209:c2:m11 |
def _command_sender(self): | sequence = -<NUM_LIT:1><EOL>while True:<EOL><INDENT>cmd = self._queue.get()<EOL>ipaddr = cmd["<STR_LIT:target>"]<EOL>payloadtype = cmd["<STR_LIT>"]<EOL>if "<STR_LIT>" not in cmd:<EOL><INDENT>sequence = (sequence + <NUM_LIT:1>) % SEQUENCE_COUNT<EOL>cmd["<STR_LIT>"] = sequence + SEQUENCE_BASE<EOL><DEDENT>packet = None<EOL>if payloadtype == PayloadType.SETCOLOR:<EOL><INDENT>packet = self._gen_packet_setcolor(cmd["<STR_LIT>"],<EOL>cmd["<STR_LIT>"],<EOL>cmd["<STR_LIT>"],<EOL>cmd["<STR_LIT>"],<EOL>cmd["<STR_LIT>"],<EOL>cmd["<STR_LIT>"])<EOL><DEDENT>elif payloadtype == PayloadType.SETPOWER2:<EOL><INDENT>packet = self._gen_packet_setpower(cmd["<STR_LIT>"],<EOL>cmd["<STR_LIT>"],<EOL>cmd["<STR_LIT>"])<EOL><DEDENT>elif payloadtype == PayloadType.GET:<EOL><INDENT>packet = self._gen_packet_get(cmd["<STR_LIT>"])<EOL><DEDENT>if packet is not None:<EOL><INDENT>try:<EOL><INDENT>self._sock.sendto(packet, (ipaddr, UDP_PORT))<EOL>now = time.time()<EOL>if "<STR_LIT>" not in cmd:<EOL><INDENT>cmd["<STR_LIT>"] = now + ACK_TIMEOUT<EOL><DEDENT>cmd["<STR_LIT>"] = now + ACK_RESEND<EOL>with self._packet_lock:<EOL><INDENT>self._packets.append(cmd)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT> | Command sender. | f12209:c2:m12 |
def probe(self, ipaddr=None): | if ipaddr is None:<EOL><INDENT>ipaddr = self._broadcast_addr<EOL><DEDENT>cmd = {"<STR_LIT>": PayloadType.GET,<EOL>"<STR_LIT:target>": ipaddr}<EOL>self._send_command(cmd)<EOL> | Probe given address for bulb. | f12209:c2:m13 |
def set_power(self, ipaddr, power, fade): | cmd = {"<STR_LIT>": PayloadType.SETPOWER2,<EOL>"<STR_LIT:target>": ipaddr,<EOL>"<STR_LIT>": power,<EOL>"<STR_LIT>": fade}<EOL>self._send_command(cmd)<EOL> | Send SETPOWER message. | f12209:c2:m14 |
def set_color(self, ipaddr, hue, sat, bri, kel, fade): | cmd = {"<STR_LIT>": PayloadType.SETCOLOR,<EOL>"<STR_LIT:target>": ipaddr,<EOL>"<STR_LIT>": hue,<EOL>"<STR_LIT>": sat,<EOL>"<STR_LIT>": bri,<EOL>"<STR_LIT>": kel,<EOL>"<STR_LIT>": fade}<EOL>self._send_command(cmd)<EOL> | Send SETCOLOR message. | f12209:c2:m15 |
def __int__(self): | return self.value<EOL> | Enum | f12213:c1:m0 |
def __init__(self): | '''<STR_LIT>'''<EOL>self.ErrorID = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.ErrorMsg = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL> | Constructor | f12215:c0:m0 |
def __init__(self): | '''<STR_LIT>'''<EOL>self.OrderID = "<STR_LIT>"<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.InstrumentID = "<STR_LIT>"<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.Direction = DirectType.Buy<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.Offset = OffsetType.Open<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.LimitPrice = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.AvgPrice = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.InsertTime = "<STR_LIT>"<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.TradeTime = "<STR_LIT>"<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.TradeVolume = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.Volume = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.VolumeLeft = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.Status = OrderStatus.Normal<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.StatusMsg = "<STR_LIT>"<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.IsLocal = False<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.Custom = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.SysID = "<STR_LIT>"<EOL>'''<STR_LIT>'''<EOL> | initionalize | f12215:c1:m0 |
def __init__(self): | '''<STR_LIT>'''<EOL>self.TradeID = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>self.InstrumentID = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>self.ExchangeID = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>self.Direction = DirectType.Buy<EOL>'''<STR_LIT>'''<EOL>self.Offset = OffsetType.Open<EOL>'''<STR_LIT>'''<EOL>self.Price = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.Volume = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>self.TradeTime = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>self.TradingDay = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>self.OrderID = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>self.SysID = '<STR_LIT>'<EOL> | Constructor | f12215:c2:m0 |
def __init__(self): | '''<STR_LIT>'''<EOL>self.InstrumentID = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.ProductID = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.ExchangeID = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.VolumeMultiple = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.PriceTick = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.MaxOrderVolume = <NUM_LIT><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.ProductType = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL> | Constructor | f12215:c3:m0 |
def __init__(self): | '''<STR_LIT>'''<EOL>self.PreBalance = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.PositionProfit = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.CloseProfit = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.Commission = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.CurrMargin = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.FrozenCash = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.Available = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.Fund = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.Risk = <NUM_LIT:0.0><EOL> | Constructor | f12215:c4:m0 |
def __init__(self): | '''<STR_LIT>'''<EOL>self.InstrumentID = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>self.Direction = DirectType.Buy<EOL>'''<STR_LIT>'''<EOL>self.Price = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.Position = <NUM_LIT:1><EOL>'''<STR_LIT>'''<EOL>self.YdPosition = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>self.TdPosition = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>self.CloseProfit = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.PositionProfit = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.Commission = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>self.Margin = <NUM_LIT:0.0><EOL> | Constructor | f12215:c5:m0 |
def __init__(self): | '''<STR_LIT>'''<EOL>self.Instrument = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.LastPrice = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.AskPrice = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.BidPrice = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.AskVolume = <NUM_LIT:1><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.BidVolume = <NUM_LIT:1><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.UpdateTime = '<STR_LIT>'<EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.UpdateMillisec = <NUM_LIT:0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.Volume = <NUM_LIT:1><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.OpenInterest = <NUM_LIT:1.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.AveragePrice = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.UpperLimitPrice = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.LowerLimitPrice = <NUM_LIT:0.0><EOL>'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>self.PreOpenInterest = <NUM_LIT:0.0><EOL> | 初始化 | f12215:c7:m0 |
def ReqConnect(self, pAddress: str): | self.q.CreateApi()<EOL>spi = self.q.CreateSpi()<EOL>self.q.RegisterSpi(spi)<EOL>self.q.OnFrontConnected = self._OnFrontConnected<EOL>self.q.OnFrontDisconnected = self._OnFrontDisConnected<EOL>self.q.OnRspUserLogin = self._OnRspUserLogin<EOL>self.q.OnRtnDepthMarketData = self._OnRtnDepthMarketData<EOL>self.q.OnRspSubMarketData = self._OnRspSubMarketData<EOL>self.q.RegCB()<EOL>self.q.RegisterFront(pAddress)<EOL>self.q.Init()<EOL> | 连接行情前置
:param pAddress: | f12216:c0:m1 |
def ReqUserLogin(self, user: str, pwd: str, broker: str): | self.q.ReqUserLogin(BrokerID=broker, UserID=user, Password=pwd)<EOL> | 登录
:param user:
:param pwd:
:param broker: | f12216:c0:m2 |
def ReqSubscribeMarketData(self, pInstrument: str): | self.q.SubscribeMarketData(pInstrument)<EOL> | 订阅合约行情
:param pInstrument: | f12216:c0:m3 |
def ReqUserLogout(self): | self.q.Release()<EOL>self.inst_tick.clear()<EOL>self.logined = False<EOL>threading.Thread(target=self.OnDisConnected, args=(self, <NUM_LIT:0>)).start()<EOL> | 退出接口(正常退出,不会触发OnFrontDisconnected) | f12216:c0:m4 |
def _qry(self): | <EOL>ord_cnt = <NUM_LIT:0><EOL>trd_cnt = <NUM_LIT:0><EOL>while True:<EOL><INDENT>time.sleep(<NUM_LIT:0.5>)<EOL>if len(self.orders) == ord_cnt and len(self.trades) == trd_cnt:<EOL><INDENT>break<EOL><DEDENT>ord_cnt = len(self.orders)<EOL>trd_cnt = len(self.trades)<EOL><DEDENT>self.t.ReqQryInstrument()<EOL>time.sleep(<NUM_LIT>)<EOL>self.t.ReqQryInvestorPosition(self.broker, self.investor)<EOL>time.sleep(<NUM_LIT>)<EOL>self.t.ReqQryTradingAccount(self.broker, self.investor)<EOL>time.sleep(<NUM_LIT>)<EOL>self.logined = True<EOL>info = InfoField()<EOL>info.ErrorID = <NUM_LIT:0><EOL>info.ErrorMsg = '<STR_LIT>'<EOL>threading.Thread(target=self.OnUserLogin, args=(self, info)).start()<EOL>while self.logined:<EOL><INDENT>"""<STR_LIT>"""<EOL>self.t.ReqQryInvestorPosition(self.broker, self.investor)<EOL>time.sleep(<NUM_LIT>)<EOL>if not self.logined:<EOL><INDENT>return<EOL><DEDENT>self.t.ReqQryTradingAccount(self.broker, self.investor)<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT> | 查询帐号相关信息 | f12217:c0:m7 |
def _OnRspQryPositionDetail(self, pInvestorPositionDetail: CThostFtdcInvestorPositionDetailField, pRspInfo: CThostFtdcRspInfoField, nRequestID: int, bIsLast: bool): | if pInvestorPositionDetail.getInstrumentID() == '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>detail = PositionDetail()<EOL>detail.Instrument = pInvestorPositionDetail.getInstrumentID()<EOL>detail.CloseProfit = pInvestorPositionDetail.getCloseProfitByTrade()<EOL>detail.Direction = DirectType.Buy if pInvestorPositionDetail.getDirection() == TThostFtdcDirectionType.THOST_FTDC_D_Buy else DirectType.Sell<EOL>detail.HedgeFlag = HedgeType(list(TThostFtdcHedgeFlagType).index(pInvestorPositionDetail.getHedgeFlag()))<EOL>detail.OpenDate = pInvestorPositionDetail.getOpenDate()<EOL>detail.PositionProfit = pInvestorPositionDetail.getPositionProfitByTrade()<EOL>detail.OpenPrice = pInvestorPositionDetail.getOpenPrice()<EOL>detail.TradeType = TradeTypeType(list(TThostFtdcTradeTypeType).index(pInvestorPositionDetail.getTradeType()))<EOL>detail.Volume = pInvestorPositionDetail.getVolume()<EOL>self.position_details[pInvestorPositionDetail.getTradeID()] = detail<EOL> | 持仓明细 | f12217:c0:m11 |
def _OnRtnNotice(self, pTradingNoticeInfo: CThostFtdcTradingNoticeInfoField): | msg = pTradingNoticeInfo.getFieldContent()<EOL>if len(msg) > <NUM_LIT:0>:<EOL><INDENT>threading.Thread(target=self.OnRtnNotice, args=(self, pTradingNoticeInfo.getSendTime(), msg)).start()<EOL><DEDENT> | 交易提醒 | f12217:c0:m19 |
def ReqConnect(self, front: str): | self.t.CreateApi()<EOL>spi = self.t.CreateSpi()<EOL>self.t.RegisterSpi(spi)<EOL>self.t.OnFrontConnected = self._OnFrontConnected<EOL>self.t.OnRspUserLogin = self._OnRspUserLogin<EOL>self.t.OnFrontDisconnected = self._OnFrontDisconnected<EOL>self.t.OnRspSettlementInfoConfirm = self._OnRspSettlementInfoConfirm<EOL>self.t.OnRtnOrder = self._OnRtnOrder<EOL>self.t.OnRtnTrade = self._OnRtnTrade<EOL>self.t.OnRspOrderInsert = self._OnRspOrder<EOL>self.t.OnErrRtnOrderInsert = self._OnErrOrder<EOL>self.t.OnRspOrderAction = self._OnRspOrderAction<EOL>self.t.OnRtnInstrumentStatus = self._OnRtnInstrumentStatus<EOL>self.t.OnRspQryInstrument = self._OnRspQryInstrument<EOL>self.t.OnRspQryTradingAccount = self._OnRspQryAccount<EOL>self.t.OnRspQryInvestorPosition = self._OnRspQryPosition<EOL>self.t.OnRspQryInvestorPositionDetail = self._OnRspQryPositionDetail<EOL>self.t.OnRtnTradingNotice = self._OnRtnNotice<EOL>self.t.OnRtnQuote = self._OnRtnQuote<EOL>self.t.OnErrRtnQuoteInsert = self._OnErrRtnQuote<EOL>self.t.OnErrRtnForQuoteInsert = self._OnErrForQuoteInsert<EOL>self.front_address = front<EOL>self.t.RegCB()<EOL>self.t.RegisterFront(front)<EOL>self.t.SubscribePrivateTopic(<NUM_LIT:0>) <EOL>self.t.SubscribePublicTopic(<NUM_LIT:0>)<EOL>self.t.Init()<EOL> | 连接交易前置
:param front: | f12217:c0:m23 |
def ReqUserLogin(self, user: str, pwd: str, broker: str): | self.broker = broker<EOL>self.investor = user<EOL>self.password = pwd<EOL>self.t.ReqUserLogin(BrokerID=broker, UserID=user, Password=pwd)<EOL> | 登录
:param user:
:param pwd:
:param broker: | f12217:c0:m24 |
def ReqOrderInsert(self, pInstrument: str, pDirection: DirectType, pOffset: OffsetType, pPrice: float = <NUM_LIT:0.0>, pVolume: int = <NUM_LIT:1>, pType: OrderType = OrderType.Limit, pCustom: int = <NUM_LIT:0>): | OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_AnyPrice<EOL>TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC<EOL>LimitPrice = <NUM_LIT:0.0><EOL>VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_AV<EOL>if pType == OrderType.Market: <EOL><INDENT>OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_AnyPrice<EOL>TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC<EOL>LimitPrice = <NUM_LIT:0.0><EOL>VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_AV<EOL><DEDENT>elif pType == OrderType.Limit: <EOL><INDENT>OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice<EOL>TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_GFD<EOL>LimitPrice = pPrice<EOL>VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_AV<EOL><DEDENT>elif pType == OrderType.FAK: <EOL><INDENT>OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice<EOL>TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC<EOL>LimitPrice = pPrice<EOL>VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_AV<EOL><DEDENT>elif pType == OrderType.FOK: <EOL><INDENT>OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice<EOL>TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC<EOL>LimitPrice = pPrice<EOL>VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_CV <EOL><DEDENT>self._req += <NUM_LIT:1><EOL>self.t.ReqOrderInsert(<EOL>BrokerID=self.broker,<EOL>InvestorID=self.investor,<EOL>InstrumentID=pInstrument,<EOL>OrderRef="<STR_LIT>" % (self._req, pCustom % <NUM_LIT>),<EOL>UserID=self.investor,<EOL>Direction=TThostFtdcDirectionType.THOST_FTDC_D_Buy if pDirection == DirectType.Buy else TThostFtdcDirectionType.THOST_FTDC_D_Sell,<EOL>CombOffsetFlag=chr(TThostFtdcOffsetFlagType.THOST_FTDC_OF_Open.value if pOffset == OffsetType.Open else TThostFtdcOffsetFlagType.THOST_FTDC_OF_CloseToday.value if pOffset == OffsetType.CloseToday else TThostFtdcOffsetFlagType.THOST_FTDC_OF_Close.value),<EOL>CombHedgeFlag=chr(TThostFtdcHedgeFlagType.THOST_FTDC_HF_Speculation.value),<EOL>IsAutoSuspend=<NUM_LIT:0>,<EOL>ForceCloseReason=TThostFtdcForceCloseReasonType.THOST_FTDC_FCC_NotForceClose,<EOL>IsSwapOrder=<NUM_LIT:0>,<EOL>ContingentCondition=TThostFtdcContingentConditionType.THOST_FTDC_CC_Immediately,<EOL>VolumeCondition=VolumeCondition,<EOL>MinVolume=<NUM_LIT:1>,<EOL>VolumeTotalOriginal=pVolume,<EOL>OrderPriceType=OrderPriceType,<EOL>TimeCondition=TimeCondition,<EOL>LimitPrice=LimitPrice,<EOL>)<EOL> | 委托
:param pInstrument:
:param pDirection:
:param pOffset:
:param pPrice:
:param pVolume:
:param pType:
:param pCustom:
:return: | f12217:c0:m25 |
def ReqOrderAction(self, OrderID: str): | of = self.orders[OrderID]<EOL>if not of:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pOrderId = of.OrderID<EOL>return self.t.ReqOrderAction(<EOL>self.broker,<EOL>self.investor,<EOL>OrderRef=pOrderId.split('<STR_LIT:|>')[<NUM_LIT:2>],<EOL>FrontID=int(pOrderId.split('<STR_LIT:|>')[<NUM_LIT:1>]),<EOL>SessionID=int(pOrderId.split('<STR_LIT:|>')[<NUM_LIT:0>]),<EOL>InstrumentID=of.InstrumentID,<EOL>ActionFlag=TThostFtdcActionFlagType.THOST_FTDC_AF_Delete)<EOL><DEDENT> | 撤单
:param OrderID: | f12217:c0:m26 |
def ReqUserLogout(self): | self.logined = False<EOL>time.sleep(<NUM_LIT:3>)<EOL>self.t.ReqUserLogout(BrokerID=self.broker, UserID=self.investor)<EOL>self.t.RegisterSpi(None)<EOL>self.t.Release()<EOL>threading.Thread(target=self.OnDisConnected, args=(self, <NUM_LIT:0>)).start()<EOL> | 退出接口 | f12217:c0:m27 |
def OnConnected(self, obj): | print('<STR_LIT>'.format('<STR_LIT>'))<EOL> | 接口连接
:param obj: | f12217:c0:m28 |
def OnDisConnected(self, obj, reason: int): | print('<STR_LIT>'.format(reason))<EOL> | 接口断开
:param obj:
:param reason: | f12217:c0:m29 |
def OnUserLogin(self, obj, info: InfoField): | print('<STR_LIT>'.format(info))<EOL> | 登录响应
:param obj:
:param info: | f12217:c0:m30 |
def OnOrder(self, obj, f: OrderField): | print('<STR_LIT>'.format(f.__dict__))<EOL> | 委托响应
:param obj:
:param f: | f12217:c0:m31 |
def OnTrade(self, obj, f: TradeField): | print('<STR_LIT>'.format(f.__dict__))<EOL> | 成交响应
:param obj:
:param f: | f12217:c0:m32 |
def OnCancel(self, obj, f: OrderField): | print('<STR_LIT>'.format(f.__dict__))<EOL> | 撤单响应
:param self:
:param obj:
:param f:OrderField: | f12217:c0:m33 |
def OnErrCancel(self, obj, f: OrderField, info: InfoField): | print('<STR_LIT>'.format(f.__dict__))<EOL>print(info)<EOL> | 撤单失败
:param self:
:param obj:
:param f:OrderField:
:param info:InfoField: | f12217:c0:m34 |
def OnErrOrder(self, obj, f: OrderField, info: InfoField): | print('<STR_LIT>'.format(f.__dict__))<EOL>print(info)<EOL> | 委托错误
:param self:
:param obj:
:param f:OrderField:
:param info:InfoField: | f12217:c0:m35 |
def OnInstrumentStatus(self, obj, inst: str, status: InstrumentStatus): | print('<STR_LIT>'.format(inst, str(status).strip().split('<STR_LIT:.>')[-<NUM_LIT:1>]))<EOL> | 交易状态
:param self:
:param obj:
:param inst:str:
:param status:InstrumentStatus: | f12217:c0:m36 |
def OnRtnNotice(self, obj, time: str, msg: str): | print(f'<STR_LIT>')<EOL> | 交易提醒
:param obj:
:param time:
:param msg:
:return: | f12217:c0:m37 |
def OnRtnQuote(self, obj, quote: CThostFtdcQuoteField): | print('<STR_LIT>'.format(quote.__dict__))<EOL> | 报价通知
:param obj:
:param quote:
:return: | f12217:c0:m38 |
def OnErrRtnQuote(self, obj, quote: CThostFtdcInputQuoteField, info: InfoField): | print('<STR_LIT>'.format(quote.__dict__))<EOL>print(info)<EOL> | :param obj:
:param quote:
:return: | f12217:c0:m39 |
def OnErrRtnForQuoteInsert(self, obj, quote: CThostFtdcInputQuoteField, info: InfoField): | print('<STR_LIT>'.format(quote.__dict__))<EOL>print(info)<EOL> | 询价录入错误回报
:param obj:
:param quote:
:return: | f12217:c0:m40 |
def process_line(self, idx, line): | if '<STR_LIT>' in line: <EOL><INDENT>py_line = '<STR_LIT:#>' + line[<NUM_LIT:3>:]<EOL>if py_line.find('<STR_LIT>') > <NUM_LIT:0>:<EOL><INDENT>self.enum_comment[py_line[py_line.find('<STR_LIT>'):py_line.find('<STR_LIT>')]] = '<STR_LIT>' % py_line[py_line.find('<STR_LIT>') + <NUM_LIT:3>:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>self.tmp_comment = '<STR_LIT>'.format(line[<NUM_LIT:3>:-<NUM_LIT:1>]) <EOL><DEDENT><DEDENT>elif '<STR_LIT>' in line: <EOL><INDENT>content = line.split('<STR_LIT:U+0020>')<EOL>constant = content[<NUM_LIT:1>]<EOL>if len(content) > <NUM_LIT:2>:<EOL><INDENT>value = content[-<NUM_LIT:1>][:-<NUM_LIT:1>] <EOL>py_line = '<STR_LIT>' % (constant, value)<EOL><DEDENT>else:<EOL><INDENT>py_line = '<STR_LIT>'<EOL><DEDENT>if py_line: <EOL><INDENT>if len(value) > <NUM_LIT:3>: <EOL><INDENT>self.define.append("<STR_LIT>".format(constant, value[<NUM_LIT:1>:-<NUM_LIT:1>], self.tmp_comment))<EOL><DEDENT>else:<EOL><INDENT>self.define.append("<STR_LIT>".format(constant, value, self.tmp_comment))<EOL><DEDENT><DEDENT><DEDENT>elif '<STR_LIT>' in line: <EOL><INDENT>py_line = self.process_typedef(line)<EOL>if line.find('<STR_LIT>') > <NUM_LIT:0> and line.find('<STR_LIT:[>') < <NUM_LIT:0>:<EOL><INDENT>key = line.split('<STR_LIT:U+0020>')[<NUM_LIT:2>][<NUM_LIT:6>:-<NUM_LIT:2>] <EOL>enum_line = self.enum_comment[key]<EOL>enum_line += '<STR_LIT>' % key<EOL>for l in self.define:<EOL><INDENT>enum_line += '<STR_LIT>' % l<EOL><DEDENT>enum_line += '<STR_LIT>'<EOL>if enum_line.find("<STR_LIT>") < <NUM_LIT:0>:<EOL><INDENT>enum_line = enum_line.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>self.fenum.write(enum_line)<EOL><DEDENT>self.define.clear()<EOL><DEDENT>elif line == '<STR_LIT:\n>': <EOL><INDENT>py_line = line<EOL><DEDENT>else:<EOL><INDENT>py_line = '<STR_LIT>'<EOL><DEDENT>return py_line<EOL> | 处理每行 | f12219:c0:m1 |
def process_typedef(self, line): | content = line.split('<STR_LIT:U+0020>')<EOL>type_ = self.type_dict[content[<NUM_LIT:1>]]<EOL>if type_ == '<STR_LIT>' and '<STR_LIT:[>' in line:<EOL><INDENT>type_ = '<STR_LIT>' % (type_, line[line.index('<STR_LIT:[>') + <NUM_LIT:1>:line.index('<STR_LIT:]>')])<EOL><DEDENT>keyword = content[<NUM_LIT:2>]<EOL>if '<STR_LIT:[>' in keyword:<EOL><INDENT>i = keyword.index('<STR_LIT:[>')<EOL>keyword = keyword[:i]<EOL><DEDENT>else:<EOL><INDENT>keyword = keyword.replace('<STR_LIT>', '<STR_LIT>') <EOL><DEDENT>py_line = '<STR_LIT>' % (keyword, type_)<EOL>return py_line<EOL> | 处理类型申明 | f12219:c0:m2 |
def run(self): | <EOL>self.fenum.write('<STR_LIT:\n>')<EOL>self.fcpp = open(os.path.join(os.path.abspath(self.ctp_dir), '<STR_LIT>'), '<STR_LIT:r>')<EOL>for idx, line in enumerate(self.fcpp):<EOL><INDENT>l = self.process_line(idx, line)<EOL>self.f_data_type.write(l)<EOL><DEDENT>self.fcpp.close()<EOL>self.f_data_type.close()<EOL>self.fenum.close()<EOL>print('<STR_LIT>')<EOL> | 主函数 | f12219:c0:m3 |
def run(self): | fcpp = open(os.path.join(os.path.abspath(self.ctp_dir), '<STR_LIT>'), '<STR_LIT:r>')<EOL>fpy = open(os.path.join(self.out_path, '<STR_LIT>'), '<STR_LIT:w>', encoding='<STR_LIT:utf-8>')<EOL>fpy.write('<STR_LIT:\n>')<EOL>fpy.write('<STR_LIT>')<EOL>fpy.write('<STR_LIT:\n>')<EOL>py_str = '<STR_LIT>'<EOL>py_str_idx = <NUM_LIT:0><EOL>py_str_format = '<STR_LIT>'<EOL>for no, line in enumerate(fcpp):<EOL><INDENT>if '<STR_LIT>' in line and '<STR_LIT:\t>' not in line:<EOL><INDENT>remark = line[<NUM_LIT:3>:-<NUM_LIT:1>]<EOL>continue<EOL><DEDENT>elif '<STR_LIT>' in line:<EOL><INDENT>remark = line[<NUM_LIT:4>:-<NUM_LIT:1>]<EOL>continue<EOL><DEDENT>elif '<STR_LIT>' in line:<EOL><INDENT>content = line.split('<STR_LIT:U+0020>')<EOL>name = content[<NUM_LIT:1>].replace('<STR_LIT:\n>', '<STR_LIT>')<EOL>py_line = """<STR_LIT>"""<EOL><DEDENT><DEDENT>ummary><EOL>}<EOL>summary>"""<STR_LIT>"""<EOL>lAs(UnmanagedType.ByValTStr, SizeConst={<NUM_LIT:1>})]<EOL>string {<NUM_LIT:0>}; | 主函数 | f12220:c0:m1 |
def read(*paths): | basedir = os.path.dirname(__file__)<EOL>fullpath = os.path.join(basedir, *paths)<EOL>contents = io.open(fullpath, encoding='<STR_LIT:utf-8>').read().strip()<EOL>return contents<EOL> | Read a text file. | f12231:m0 |
@cli.command()<EOL>@click.argument('<STR_LIT>', default='<STR_LIT>')<EOL>def init(arg): | answers = {'<STR_LIT:a>': <NUM_LIT:1>}<EOL>if arg == '<STR_LIT>':<EOL><INDENT>input("""<STR_LIT>""")<EOL><DEDENT>elif arg == '<STR_LIT>':<EOL><INDENT>raise NotImplementedError()<EOL><DEDENT>else:<EOL><INDENT>url = arg<EOL>answers = dict(<EOL>input='<STR_LIT>',<EOL>title=os.path.basename(url),<EOL>input_url=url,<EOL>processing=[],<EOL>output='<STR_LIT>'<EOL>)<EOL>extract_format(answers, url)<EOL><DEDENT>questions = [<EOL>inquirer.List('<STR_LIT>',<EOL>message='<STR_LIT>',<EOL>choices=INPUTS.keys(),<EOL>ignore=lambda ctx: ctx.get('<STR_LIT:input>') is not None,<EOL>validate=convert_input),<EOL>inquirer.Text('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>ignore=fany(lambda ctx: ctx.get('<STR_LIT:input>') != '<STR_LIT:file>',<EOL>lambda ctx: ctx.get('<STR_LIT>') is not None),<EOL>validate=fall(not_empty, extract_format)),<EOL>inquirer.List('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>choices=FORMATS[:-<NUM_LIT:1>],<EOL>ignore=fany(lambda ctx: ctx.get('<STR_LIT:input>') != '<STR_LIT:file>',<EOL>lambda ctx: ctx.get('<STR_LIT>') in FORMATS)),<EOL>inquirer.Text('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>ignore=fany(lambda ctx: ctx.get('<STR_LIT:input>') != '<STR_LIT>',<EOL>lambda ctx: ctx.get('<STR_LIT>') is not None),<EOL>validate=fall(extract_format, not_empty, valid_url)),<EOL>inquirer.List('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>choices=FORMATS,<EOL>ignore=fany(lambda ctx: ctx['<STR_LIT:input>'] != '<STR_LIT>',<EOL>lambda ctx: ctx.get('<STR_LIT>') in FORMATS)<EOL>),<EOL>inquirer.Text('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>validate=not_empty,<EOL>ignore=lambda ctx: ctx.get('<STR_LIT>') not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'),<EOL>),<EOL>inquirer.Text('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>validate=not_empty,<EOL>ignore=fany(lambda ctx: ctx['<STR_LIT:input>'] != '<STR_LIT>',<EOL>lambda ctx: ctx.get('<STR_LIT>') is not None),<EOL>),<EOL>inquirer.Text('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>validate=not_empty,<EOL>ignore=fany(lambda ctx: ctx['<STR_LIT:input>'] != '<STR_LIT>',<EOL>lambda ctx: ctx.get('<STR_LIT>') is not None),<EOL>),<EOL>inquirer.Text('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>ignore=fany(lambda ctx: ctx['<STR_LIT:input>'] != '<STR_LIT>',<EOL>lambda ctx: ctx.get('<STR_LIT>') is not None),<EOL>),<EOL>inquirer.Checkbox('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>choices=PROCESSING.keys(),<EOL>ignore=lambda ctx: ctx.get('<STR_LIT>') is not None,<EOL>validate=convert_processing),<EOL>inquirer.List('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>choices=OUTPUTS.keys(),<EOL>ignore=lambda ctx: ctx.get('<STR_LIT>') is not None,<EOL>validate=convert_output),<EOL>inquirer.Text('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>validate=not_empty,<EOL>ignore=fany(lambda ctx: ctx['<STR_LIT>'] != '<STR_LIT>',<EOL>lambda ctx: ctx.get('<STR_LIT>') is not None),<EOL>),<EOL>inquirer.Text('<STR_LIT>',<EOL>message="<STR_LIT>",<EOL>validate=not_empty,<EOL>ignore=fany(lambda ctx: ctx['<STR_LIT>'] != '<STR_LIT>',<EOL>lambda ctx: ctx.get('<STR_LIT>') is not None),<EOL>),<EOL>inquirer.Text('<STR_LIT:title>',<EOL>message="<STR_LIT>",<EOL>ignore=lambda ctx: ctx.get('<STR_LIT:title>') is not None,<EOL>validate=not_empty),<EOL>]<EOL>answers = inquirer.prompt(questions, answers=answers, theme=themes.GreenPassion())<EOL>if answers is None:<EOL><INDENT>return<EOL><DEDENT>answers['<STR_LIT>'] = slugify.slugify(answers['<STR_LIT:title>'], separator='<STR_LIT:_>')<EOL>filename = '<STR_LIT>'.format(**answers)<EOL>with open(filename, '<STR_LIT:w>') as out:<EOL><INDENT>print('<STR_LIT>'.format(filename))<EOL>out.write(render(answers))<EOL><DEDENT>try:<EOL><INDENT>print('<STR_LIT>'.format(filename))<EOL>ret = subprocess.check_output('<STR_LIT>'+filename,<EOL>stderr=subprocess.PIPE, universal_newlines=True, shell=True)<EOL>print(ret)<EOL>print('<STR_LIT>')<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>print("<STR_LIT>")<EOL>print(e.stderr)<EOL>answers = inquirer.prompt([<EOL>inquirer.Confirm('<STR_LIT>',<EOL>message='<STR_LIT>'.format(filename),<EOL>default=False)<EOL>])<EOL>if answers['<STR_LIT>']:<EOL><INDENT>click.edit(filename=filename)<EOL><DEDENT><DEDENT> | Bootstrap a processing pipeline script.
ARG is either a path or a URL for some data to read from, 'hello-world' for a full working code example,
or leave empty for an interactive walkthrough. | f12240:m10 |
@classmethod<EOL><INDENT>def from_block(cls, block):<DEDENT> | rseqs = cma.realign_seqs(block)<EOL>records = (SeqRecord(Seq(rseq, extended_protein),<EOL>id=bseq['<STR_LIT:id>'],<EOL>description=bseq['<STR_LIT:description>'],<EOL>dbxrefs=bseq['<STR_LIT>'].values(), <EOL>annotations=dict(<EOL>index=bseq['<STR_LIT:index>'],<EOL>length=bseq['<STR_LIT>'],<EOL>dbxrefs=bseq['<STR_LIT>'],<EOL>phylum=bseq['<STR_LIT>'],<EOL>taxchar=bseq['<STR_LIT>'],<EOL>head_seq=bseq['<STR_LIT>'],<EOL>tail_seq=bseq['<STR_LIT>'],<EOL>head_len=bseq['<STR_LIT>'],<EOL>tail_len=bseq['<STR_LIT>'], <EOL>),<EOL>)<EOL>for bseq, rseq in zip(block['<STR_LIT>'], rseqs))<EOL>return cls(records,<EOL>block['<STR_LIT>'],<EOL>block['<STR_LIT:name>'],<EOL>block['<STR_LIT>'],<EOL>block['<STR_LIT>'],<EOL>block['<STR_LIT>'],<EOL>)<EOL> | Instantiate this class given a raw block (see parse_raw). | f12279:c0:m1 |
def find_seq_rec(block, name, case_sensitive=True): | if case_sensitive:<EOL><INDENT>def test(name, rec):<EOL><INDENT>return name in rec['<STR_LIT:id>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def test(name, rec):<EOL><INDENT>return name.upper() in rec['<STR_LIT:id>'].upper()<EOL><DEDENT><DEDENT>for rec in block['<STR_LIT>']:<EOL><INDENT>if test(name, rec):<EOL><INDENT>return rec<EOL><DEDENT><DEDENT>raise ValueError("<STR_LIT>" % repr(name))<EOL> | Given part of a sequence ID, find the first matching record. | f12280:m0 |
def find_seq_id(block, name, case_sensitive=True): | <EOL>rec = find_seq_rec(block, name, case_sensitive)<EOL>return rec['<STR_LIT:id>']<EOL> | Given part of a sequence ID, find the first actual ID that contains it.
Example::
>>> find_seq_id(block, '2QG5')
'gi|158430190|pdb|2QG5|A'
Raise a ValueError if no matching key is found. | f12280:m1 |
def get_consensus(block): | from collections import Counter<EOL>columns = zip(*[[c for c in row['<STR_LIT>'] if not c.islower()]<EOL>for row in block['<STR_LIT>']])<EOL>cons_chars = [Counter(col).most_common()[<NUM_LIT:0>][<NUM_LIT:0>] for col in columns]<EOL>cons_chars = [c if c != '<STR_LIT:->' else '<STR_LIT:X>' for c in cons_chars]<EOL>assert len(cons_chars) == block['<STR_LIT>']<EOL>cons_sequence = {<EOL>'<STR_LIT:index>': <NUM_LIT:1>,<EOL>'<STR_LIT:id>': '<STR_LIT>',<EOL>'<STR_LIT:description>': '<STR_LIT>',<EOL>'<STR_LIT>': {},<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': block['<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT>'.join(cons_chars),<EOL>}<EOL>return cons_sequence<EOL> | Calculate a simple consensus sequence for the block. | f12280:m2 |
def get_conservation(block): | consensus = block['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>assert all(c.isupper() for c in consensus),"<STR_LIT>"<EOL>cleaned = [[c for c in s['<STR_LIT>'] if not c.islower()]<EOL>for s in block['<STR_LIT>'][<NUM_LIT:1>:]]<EOL>height = float(len(cleaned))<EOL>for row in cleaned:<EOL><INDENT>if len(row) != len(consensus):<EOL><INDENT>raise ValueError("<STR_LIT>"<EOL>"<STR_LIT>"<EOL>% (len(row), len(consensus)))<EOL><DEDENT><DEDENT>columns = zip(*cleaned)<EOL>return dict((idx + <NUM_LIT:1>, columns[idx].count(cons_char) / height)<EOL>for idx, cons_char in enumerate(consensus))<EOL> | Calculate conservation levels at each consensus position.
Return a dict of {position: float conservation} | f12280:m3 |
def get_equivalent_positions(block): | consensus = block['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>rest = block['<STR_LIT>'][<NUM_LIT:1>:]<EOL>if '<STR_LIT:->' in consensus or '<STR_LIT:.>' in consensus:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>seen = set()<EOL>dupes = set()<EOL>for rec in rest:<EOL><INDENT>if rec['<STR_LIT:id>'] in seen:<EOL><INDENT>dupes.add(rec['<STR_LIT:id>'])<EOL><DEDENT>else:<EOL><INDENT>seen.add(rec['<STR_LIT:id>'])<EOL><DEDENT><DEDENT>if dupes:<EOL><INDENT>raise ValueError("<STR_LIT>" + '<STR_LIT:\n>'.join(dupes))<EOL><DEDENT>curr_shift = {}<EOL>curr_resn = {}<EOL>for rec in rest:<EOL><INDENT>curr_shift[rec['<STR_LIT:id>']] = <NUM_LIT:0><EOL>curr_resn[rec['<STR_LIT:id>']] = rec['<STR_LIT>']<EOL><DEDENT>equivalencies = dict((i+<NUM_LIT:1>, {}) for i in xrange(len(consensus)))<EOL>for i, char in enumerate(consensus):<EOL><INDENT>assert char.isupper()<EOL>for rec in rest:<EOL><INDENT>rid = rec['<STR_LIT:id>']<EOL>strposn = i + curr_shift[rid]<EOL>if rec['<STR_LIT>'][strposn].isupper():<EOL><INDENT>curr_resn[rid] += <NUM_LIT:1><EOL><DEDENT>elif rec['<STR_LIT>'][strposn].islower():<EOL><INDENT>while rec['<STR_LIT>'][strposn].islower():<EOL><INDENT>curr_shift[rid] += <NUM_LIT:1><EOL>curr_resn[rid] += <NUM_LIT:1><EOL>strposn += <NUM_LIT:1><EOL><DEDENT>curr_resn[rid] += <NUM_LIT:1> <EOL><DEDENT>else:<EOL><INDENT>assert rec['<STR_LIT>'][strposn] in '<STR_LIT>'<EOL>continue<EOL><DEDENT>equivalencies[i+<NUM_LIT:1>][rid] = curr_resn[rid]<EOL><DEDENT><DEDENT>return equivalencies<EOL> | Create a mapping of equivalent residue positions to consensus.
Build a dict-of-dicts::
{consensus-posn: {id: equiv-posn, id: equiv-posn, ...}, ...}
The first sequence in the alignment is assumed to be the (gapless) consensus
sequence. | f12280:m4 |
def get_inserts(block): | def find_inserts(seq, head_len):<EOL><INDENT>"""<STR_LIT>"""<EOL>in_insert = False<EOL>curr_start = None<EOL>deletions = <NUM_LIT:0><EOL>for idx, is_lower in enumerate(map(str.islower, seq)):<EOL><INDENT>if is_lower:<EOL><INDENT>if not in_insert:<EOL><INDENT>curr_start = head_len + idx + <NUM_LIT:1> - deletions<EOL>in_insert = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if in_insert:<EOL><INDENT>yield (curr_start, head_len + idx - deletions)<EOL>in_insert = False<EOL><DEDENT>if seq[idx] == '<STR_LIT:->':<EOL><INDENT>deletions += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return dict((record['<STR_LIT:id>'],<EOL>list(find_inserts(record['<STR_LIT>'], record['<STR_LIT>'])))<EOL>for record in block['<STR_LIT>'])<EOL> | Identify the inserts in sequence in a block.
Inserts are relative to the consensus (theoretically), and identified by
lowercase letters in the sequence. The returned integer pairs represent the
insert start and end positions in the full-length sequence, using one-based
numbering.
The first sequence of the CMA block is included, though it may just be the
consensus sequence, which shouldn't have any inserts.
Output:
{id1: [(start, end), (start, end), ...], id2: ..., ...} | f12280:m5 |
def number_letters(block_or_record, key=None): | if key:<EOL><INDENT>logging.warn("<STR_LIT>")<EOL>assert '<STR_LIT>' in block_or_record, "<STR_LIT>"<EOL>record = find_seq_rec(block_or_record, key)<EOL><DEDENT>else:<EOL><INDENT>assert '<STR_LIT:id>' in block_or_record, "<STR_LIT>"<EOL>record = block_or_record<EOL><DEDENT>seq = record['<STR_LIT>'].replace('<STR_LIT:->', '<STR_LIT>').replace('<STR_LIT:.>', '<STR_LIT>')<EOL>shift = record['<STR_LIT>'] + <NUM_LIT:1><EOL>return dict((idx + shift, letter)<EOL>for idx, letter in enumerate(seq))<EOL> | Return a dict of {posn: restype} for each letter in the sequence. | f12280:m6 |
def _parse_blocks(instream): | ilines = sugar.unblank(instream)<EOL>for line in ilines:<EOL><INDENT>if line.startswith('<STR_LIT:[>'):<EOL><INDENT>level, one, name, seqcount, params = _parse_block_header(line)<EOL>qlen, qchars = _parse_block_postheader(next(ilines))<EOL>sequences = list(_parse_sequences(ilines, qlen))<EOL>if not len(sequences) == seqcount:<EOL><INDENT>logging.warn("<STR_LIT>",<EOL>seqcount, name, len(sequences))<EOL><DEDENT>yield {'<STR_LIT>': level,<EOL>'<STR_LIT>': one,<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': params,<EOL>'<STR_LIT>': qlen,<EOL>'<STR_LIT>': qchars,<EOL>'<STR_LIT>': sequences,<EOL>}<EOL><DEDENT><DEDENT> | Parse an alignment block from the given file handle.
Block looks like:
[0_(1)=fa2cma(8){go=10000,gx=2000,pn=1000.0,lf=0,rf=0}:
(209)***********************************************...
... sequences, numbered 1-8 ...
_0]. | f12281:m1 |
def _parse_sequences(ilines, expect_qlen): | while True:<EOL><INDENT>first = next(ilines)<EOL>if first.startswith('<STR_LIT:_>') and first.endswith('<STR_LIT>'):<EOL><INDENT>break<EOL><DEDENT>try:<EOL><INDENT>index, this_len, query_len = _parse_seq_preheader(first)<EOL><DEDENT>except ValueError:<EOL><INDENT>logging.warn('<STR_LIT>', first)<EOL>continue<EOL><DEDENT>(rec_id, dbxrefs, headlen, taillen, phylum, taxchar, description<EOL>) = _parse_seq_header(next(ilines))<EOL>try:<EOL><INDENT>headseq, molseq, tailseq = _parse_seq_body(next(ilines))<EOL><DEDENT>except ValueError:<EOL><INDENT>logging.warn('<STR_LIT>', rec_id)<EOL>continue<EOL><DEDENT>if expect_qlen != query_len:<EOL><INDENT>logging.warn("<STR_LIT>",<EOL>rec_id, query_len, expect_qlen)<EOL><DEDENT>if not headseq and not headlen:<EOL><INDENT>headlen = <NUM_LIT:0><EOL><DEDENT>if not tailseq and not taillen:<EOL><INDENT>taillen = <NUM_LIT:0><EOL><DEDENT>if headseq:<EOL><INDENT>if headlen is None:<EOL><INDENT>headlen = len(headseq)<EOL><DEDENT>elif headlen != len(headseq):<EOL><INDENT>logging.warn("<STR_LIT>",<EOL>rec_id, headlen, len(headseq))<EOL><DEDENT><DEDENT>if tailseq:<EOL><INDENT>if taillen is None:<EOL><INDENT>taillen = len(tailseq)<EOL><DEDENT>elif taillen != len(tailseq):<EOL><INDENT>logging.warn("<STR_LIT>",<EOL>rec_id, taillen, len(tailseq))<EOL><DEDENT><DEDENT>yield {'<STR_LIT:index>': index,<EOL>'<STR_LIT:id>': rec_id,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': dbxrefs,<EOL>'<STR_LIT>': phylum,<EOL>'<STR_LIT>': taxchar,<EOL>'<STR_LIT>': headlen,<EOL>'<STR_LIT>': taillen,<EOL>'<STR_LIT>': headseq,<EOL>'<STR_LIT>': tailseq,<EOL>'<STR_LIT>': this_len,<EOL>'<STR_LIT>': molseq,<EOL>}<EOL><DEDENT> | Parse the sequences in the current block.
Sequence looks like:
$3=227(209):
>gi|15606894|ref|NP_214275.1| {|2(244)|<Aquificae(B)>}DNA polymerase III gamma subunit [Aquifex aeolicus VF5] >gi|2984127|gb|AAC07663.1| DNA polymerase III gamma subunit [Aquifex aeolicus VF5] >gi|75
{()YVPFARKYRPKFFREVIGQEAPVRILKNAIKNDRVAHaYLFAGPRGVGKTTIARILAKALNcknpskgepcgecencreiDRGVFPDLIEMDAASNRGIDDVRA-LKEAVNYKPIKG-KYKVYIIDEAHMLTKEAFNALLKTLEEPPPRTVFVLCTTEYDKILPTILSRCQRIIFSKVRKEKVIEYLKKICEKEGIECEEGALEVLAHASEGCMRDAASLLDQASVYGE()}* | f12281:m2 |
def _parse_block_header(line): | level = line[<NUM_LIT:1>]<EOL>one, _rest = line[<NUM_LIT:4>:].split('<STR_LIT>', <NUM_LIT:1>)<EOL>name, _rest = _rest.split('<STR_LIT:(>', <NUM_LIT:1>)<EOL>seqcount, _rest = _rest.split('<STR_LIT:)>', <NUM_LIT:1>)<EOL>params = _rest.strip('<STR_LIT>')<EOL>return int(level), int(one), name, int(seqcount), params<EOL> | [0_(1)=fa2cma(8){go=10000,gx=2000,pn=1000.0,lf=0,rf=0}: | f12281:m3 |
def _parse_block_postheader(line): | parts = line[<NUM_LIT:1>:].split('<STR_LIT:)>', <NUM_LIT:1>)<EOL>qlen = int(parts[<NUM_LIT:0>])<EOL>if not len(parts[<NUM_LIT:1>]) == qlen:<EOL><INDENT>logging.warn("<STR_LIT>",<EOL>qlen, len(parts[<NUM_LIT:1>]))<EOL><DEDENT>return qlen, parts[<NUM_LIT:1>]<EOL> | (209)**************!*****************!!*************... | f12281:m4 |
def _parse_seq_preheader(line): | match = re.match(r"<STR_LIT>", line, re.VERBOSE)<EOL>if not match:<EOL><INDENT>raise ValueError("<STR_LIT>" + line)<EOL><DEDENT>index, this_len, query_len = match.groups()<EOL>return list(map(int, (index, this_len, query_len)))<EOL> | $3=227(209): | f12281:m5 |
def _parse_seq_header(line): | <EOL>_parts = line[<NUM_LIT:1>:].split(None, <NUM_LIT:1>)<EOL>rec_id = _parts[<NUM_LIT:0>]<EOL>descr = _parts[<NUM_LIT:1>] if _parts[<NUM_LIT:1>:] else '<STR_LIT>'<EOL>dbxrefs = {}<EOL>if '<STR_LIT:|>' in rec_id:<EOL><INDENT>id_gen = iter(rec_id.rstrip('<STR_LIT:|>').split('<STR_LIT:|>'))<EOL>for key in id_gen:<EOL><INDENT>try:<EOL><INDENT>dbxrefs[key] = next(id_gen)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>headlen = taillen = None<EOL>phylum = taxchar = '<STR_LIT>'<EOL>if descr.startswith('<STR_LIT:{>'):<EOL><INDENT>_deets, description = descr[<NUM_LIT:1>:].split('<STR_LIT:}>', <NUM_LIT:1>)<EOL>match = re.search(r"""<STR_LIT>""", _deets, re.VERBOSE)<EOL>if match:<EOL><INDENT>headlen, taillen, phylum, taxchar = match.groups()<EOL>if headlen is not None:<EOL><INDENT>headlen = int(headlen)<EOL><DEDENT>if taillen is not None:<EOL><INDENT>taillen = int(taillen)<EOL><DEDENT>if phylum is None:<EOL><INDENT>phylum = '<STR_LIT>'<EOL><DEDENT>if taxchar is None:<EOL><INDENT>taxchar = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logging.warn("<STR_LIT>", _deets)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>description = descr<EOL><DEDENT>return rec_id, dbxrefs, headlen, taillen, phylum, taxchar, description<EOL> | Unique ID, head/tail lengths and taxonomy info from a sequence header.
The description is the part of the FASTA/CMA sequence header starting after
the first space (i.e. excluding ID), to the end of the line.
This function looks inside the first '{...}' pair to extract info.
Ex:
>consensus seq
>gi|15606894|ref|NP_214275.1| {|2(244)|<Aquificae(B)>}DNA polymerase III gamma subunit [Aquifex aeolicus VF5] >gi|2984127|gb|AAC07663.1| DNA polymerase III gamma subunit [Aquifex aeolicus VF5] >gi|75
>gi|3212262|pdb|1A2K|C {<Chordata(M)>}Chain C, Gdpran-Ntf2 Complex >gi|3212263|pdb|1A2K|D Chain D, Gdpran-Ntf2 Complex >gi|3212264|pdb|1A2K|E Chain E, Gdpran-Ntf2 Complex >gi|5542273|pdb|1IBR|A C | f12281:m6 |
def _parse_seq_body(line): | line = line.rstrip('<STR_LIT:*>')<EOL>if '<STR_LIT>' in line:<EOL><INDENT>head, _rest = line.split('<STR_LIT>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>_rest = line.split('<STR_LIT>', <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>head, _rest = _rest.split('<STR_LIT:)>', <NUM_LIT:1>)<EOL><DEDENT>if '<STR_LIT>' in _rest:<EOL><INDENT>molseq, tail = _rest.split('<STR_LIT>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>molseq, _rest = _rest.split('<STR_LIT:(>', <NUM_LIT:1>)<EOL>tail = _rest.split('<STR_LIT>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>return (head, molseq, tail)<EOL> | Ex:
{()YVPFARKYRPKFFREVIGQEAPVRILKALNcknpskgepcgereiDRGVFPDVRA-LKLLDQASVYGE()}*
MENINNI{()----------FKLILVGDGKFFSSSGEIIFNIWDTKFGGLRDGYYRLTYKNEDDM()}*
Or:
{(HY)ELPWVEKYR...
The sequence fragments in parentheses represent N- or C-terminal flanking
regions that are not part of the alignment block (I think). Most tools don't
include them, but some do, apparently. | f12281:m7 |
def realign_seqs(block, gap_char='<STR_LIT:.>', align_indels=False): | <EOL>all_chars = [list(sq['<STR_LIT>']) for sq in block['<STR_LIT>']]<EOL>nrows = len(all_chars)<EOL>i = <NUM_LIT:0><EOL>while i < len(all_chars[<NUM_LIT:0>]):<EOL><INDENT>rows_need_gaps = [r for r in all_chars if not r[i].islower()]<EOL>if len(rows_need_gaps) != nrows:<EOL><INDENT>for row in rows_need_gaps:<EOL><INDENT>row.insert(i, gap_char)<EOL><DEDENT><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>return ['<STR_LIT>'.join(row) for row in all_chars]<EOL> | Add gaps to a block so all residues in a column are equivalent.
Given a block, containing a list of "sequences" (dicts) each containing a
"seq" (actual string sequence, where upper=match, lower=insert, dash=gap),
insert gaps (- or .) into the sequences s.t.
1. columns line up properly, and
2. all resulting sequences have the same length
The reason this needs to be done is that the query/consensus sequence is not
assigned gaps to account for inserts in the other sequences. We need to add
the gaps back to obtain a normal alignment.
`return`: a list of realigned sequence strings. | f12281:m11 |
def consensus2block(record, level=<NUM_LIT:0>, name=None): | cons_ungap = str(record.seq).replace('<STR_LIT:->', '<STR_LIT>').replace('<STR_LIT:.>', '<STR_LIT>').upper()<EOL>record.seq = cons_ungap<EOL>return dict(<EOL>level=level, <EOL>one=<NUM_LIT:1>,<EOL>name=name or record.id,<EOL>params='<STR_LIT>',<EOL>query_length=len(cons_ungap),<EOL>query_chars='<STR_LIT:*>'*len(cons_ungap),<EOL>sequences=[seqrecord2sequence(record, len(cons_ungap), <NUM_LIT:1>)]<EOL>)<EOL> | Convert a Biopython SeqRecord to a esbglib.cma block.
Ungapping is handled here. | f12281:m12 |
def seqrecord2sequence(record, qlen, index): | <EOL>description = (record.description.split('<STR_LIT:U+0020>', <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>if '<STR_LIT:U+0020>' in record.description<EOL>else '<STR_LIT:U+0020>')<EOL>return dict(index=index,<EOL>id=record.id,<EOL>description=description,<EOL>dbxrefs={},<EOL>phylum='<STR_LIT>',<EOL>taxchar='<STR_LIT>',<EOL>head_len=None,<EOL>tail_len=None,<EOL>head_seq='<STR_LIT>',<EOL>tail_seq='<STR_LIT>',<EOL>length=len(record.seq) - record.seq.count('<STR_LIT:->'),<EOL>seq=str(record.seq),<EOL>)<EOL> | Convert a Biopython SeqRecord to a esbglib.cma block.
Indels (gaps, casing) must have already been handled in the record. | f12281:m13 |
def collapse_to_consensus(seqrecords, strict=False, do_iron=True): | level = <NUM_LIT:0><EOL>name = seqrecords[<NUM_LIT:0>].id<EOL>if hasattr(seqrecords, '<STR_LIT>'):<EOL><INDENT>if hasattr(seqrecords, '<STR_LIT>'):<EOL><INDENT>level = seqrecords.level<EOL><DEDENT>if hasattr(seqrecords, '<STR_LIT:name>'):<EOL><INDENT>name = seqrecords.name<EOL><DEDENT>seqrecords = seqrecords._records<EOL><DEDENT>consensus = seqrecords.pop(<NUM_LIT:0>)<EOL>cons_length = len(consensus)<EOL>for i, s in enumerate(seqrecords):<EOL><INDENT>if len(s) != cons_length:<EOL><INDENT>raise ValueError(<EOL>"<STR_LIT>"<EOL>% (i+<NUM_LIT:2>, len(s), cons_length))<EOL><DEDENT><DEDENT>if '<STR_LIT:.>' in str(consensus.seq):<EOL><INDENT>if '<STR_LIT:->' in str(consensus.seq):<EOL><INDENT>if strict:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>logging.warn("<STR_LIT>"<EOL>"<STR_LIT>")<EOL>aligned_cols = [(c not in '<STR_LIT>') for c in str(consensus.seq)]<EOL><DEDENT>else:<EOL><INDENT>aligned_cols = [c != '<STR_LIT:.>' for c in str(consensus.seq)]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>aligned_cols = [c != '<STR_LIT:->' for c in str(consensus.seq)]<EOL><DEDENT>consensus.seq = replace_asterisks(consensus.seq, '<STR_LIT>')<EOL>block = consensus2block(consensus, level=level, name=name)<EOL>qlen = block['<STR_LIT>']<EOL>for index, rec in zip(range(<NUM_LIT:2>, len(seqrecords)+<NUM_LIT:2>), seqrecords):<EOL><INDENT>new_mol_seq = []<EOL>is_beginning = True<EOL>for aligned_col, char in zip(aligned_cols,<EOL>replace_asterisks(rec.seq, index)):<EOL><INDENT>if aligned_col:<EOL><INDENT>is_beginning = False<EOL>if char in '<STR_LIT>':<EOL><INDENT>new_mol_seq.append('<STR_LIT:->')<EOL><DEDENT>else:<EOL><INDENT>new_mol_seq.append(char.upper())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if char not in '<STR_LIT>' and not is_beginning:<EOL><INDENT>new_mol_seq.append(char.lower())<EOL><DEDENT><DEDENT><DEDENT>rec.seq = '<STR_LIT>'.join(new_mol_seq)<EOL>if do_iron:<EOL><INDENT>rec.seq = iron(rec.seq)<EOL><DEDENT>block['<STR_LIT>'].append(seqrecord2sequence(rec, qlen, index))<EOL><DEDENT>return block<EOL> | Opposite of realign_seqs.
Input sequences should all be the same length.
The first record must be the consensus. | f12281:m15 |
def iron(sequence): | r_indel = re.compile(r'<STR_LIT>')<EOL>orig_sequence = sequence<EOL>while r_indel.search(sequence):<EOL><INDENT>in_insert = False<EOL>in_gap = False<EOL>seen_gaps = <NUM_LIT:0><EOL>inserts = []<EOL>outchars = []<EOL>for char in sequence:<EOL><INDENT>if in_insert:<EOL><INDENT>if char.islower():<EOL><INDENT>inserts.append(char)<EOL><DEDENT>elif char.isupper():<EOL><INDENT>in_insert = False<EOL>outchars.extend(inserts)<EOL>inserts = []<EOL>outchars.append('<STR_LIT:->' * seen_gaps)<EOL>seen_gaps = <NUM_LIT:0><EOL>outchars.append(char)<EOL><DEDENT>else:<EOL><INDENT>assert char == '<STR_LIT:->'<EOL>if not inserts:<EOL><INDENT>in_insert = False<EOL>in_gap = True<EOL>seen_gaps += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>outchars.append(inserts.pop(<NUM_LIT:0>).upper())<EOL>if not inserts:<EOL><INDENT>in_insert = False<EOL>in_gap = True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif in_gap:<EOL><INDENT>if char.islower():<EOL><INDENT>in_insert = True<EOL>in_gap = False<EOL>if inserts:<EOL><INDENT>outchars.extend(inserts)<EOL>outchars.append('<STR_LIT:->' * seen_gaps)<EOL>seen_gaps = <NUM_LIT:0><EOL><DEDENT>inserts = [char]<EOL><DEDENT>elif char.isupper():<EOL><INDENT>in_gap = False<EOL>if inserts:<EOL><INDENT>outchars.extend(inserts)<EOL>inserts = []<EOL><DEDENT>outchars.append('<STR_LIT:->' * seen_gaps)<EOL>seen_gaps = <NUM_LIT:0><EOL>outchars.append(char)<EOL><DEDENT>else:<EOL><INDENT>assert char == '<STR_LIT:->'<EOL>seen_gaps += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert not inserts and not seen_gaps, (<EOL>"<STR_LIT>"<EOL>% (inserts, seen_gaps, sequence, in_insert, in_gap))<EOL>if char.isupper():<EOL><INDENT>outchars.append(char)<EOL><DEDENT>elif char.islower():<EOL><INDENT>inserts.append(char)<EOL>in_insert = True<EOL><DEDENT>else:<EOL><INDENT>assert char == '<STR_LIT:->'<EOL>seen_gaps += <NUM_LIT:1><EOL>in_gap = True<EOL><DEDENT><DEDENT><DEDENT>if inserts:<EOL><INDENT>outchars.extend(inserts)<EOL><DEDENT>if seen_gaps:<EOL><INDENT>outchars.append('<STR_LIT:->' * seen_gaps)<EOL><DEDENT>sequence = '<STR_LIT>'.join(outchars)<EOL>assert (sequence.replace('<STR_LIT:->', '<STR_LIT>').upper()<EOL>==<EOL>orig_sequence.replace('<STR_LIT:->', '<STR_LIT>').upper()),'<STR_LIT>' + orig_sequence +'<STR_LIT>' + sequence<EOL><DEDENT>return sequence<EOL> | Iron out' indel regions in the aligned sequence.
Any inserts next to deletions are converted to matches (uppercase).
Given a CMA string like:
AAAAbc--de-f--gAAA
Result:
AAAABCDEFgAAA | f12281:m16 |
@contextlib.contextmanager<EOL>def maybe_open(infile, mode='<STR_LIT:r>'): | <EOL>if isinstance(infile, basestring):<EOL><INDENT>handle = open(infile, mode)<EOL>do_close = True<EOL><DEDENT>else:<EOL><INDENT>handle = infile<EOL>do_close = False<EOL><DEDENT>yield handle<EOL>if do_close:<EOL><INDENT>handle.close()<EOL><DEDENT> | Take a file name or a handle, and return a handle.
Simplifies creating functions that automagically accept either a file name
or an already opened file handle. | f12282:m1 |
def unblank(stream): | return itertools.ifilter(None, (line.strip() for line in stream))<EOL> | Remove blank lines from a file being read iteratively. | f12282:m2 |
@task(name='<STR_LIT>')<EOL>def purge_old_logs(delete_before_days=<NUM_LIT:7>): | delete_before_date = timezone.now() - timedelta(days=delete_before_days)<EOL>logs_deleted = Log.objects.filter(<EOL>created_on__lte=delete_before_date).delete()<EOL>return logs_deleted<EOL> | Purges old logs from the database table | f12291:m0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.