Instruction:
Can you tell what is the following Python 3 function doing
def round_geom(geom, precision=None):
    if geom['type'] == 'Point':
        x, y = geom['coordinates']
        xp, yp = [x], [y]
        if precision is not None:
            xp = [round(v, precision) for v in xp]
            yp = [round(v, precision) for v in yp]
        new_coords = tuple(zip(xp, yp))[0]
    if geom['type'] in ['LineString', 'MultiPoint']:
        xp, yp = zip(*geom['coordinates'])
        if precision is not None:
            xp = [round(v, precision) for v in xp]
            yp = [round(v, precision) for v in yp]
        new_coords = tuple(zip(xp, yp))
    elif geom['type'] in ['Polygon', 'MultiLineString']:
        new_coords = []
        for piece in geom['coordinates']:
            xp, yp = zip(*piece)
            if precision is not None:
                xp = [round(v, precision) for v in xp]
                yp = [round(v, precision) for v in yp]
            new_coords.append(tuple(zip(xp, yp)))
    elif geom['type'] == 'MultiPolygon':
        parts = geom['coordinates']
        new_coords = []
        for part in parts:
            inner_coords = []
            for ring in part:
                xp, yp = zip(*ring)
                if precision is not None:
                    xp = [round(v, precision) for v in xp]
                    yp = [round(v, precision) for v in yp]
                inner_coords.append(tuple(zip(xp, yp)))
            new_coords.append(inner_coords)
    return {'type': geom['type'], 'coordinates': new_coords}

Response: Round coordinates of a geometric object to given precision.


Instruction:
Given the following Python 3 function, write the documentation
def flatten_multi_dim(sequence):
    for x in sequence:
        if (isinstance(x, collections.Iterable)
                and not isinstance(x, six.string_types)):
            for y in flatten_multi_dim(x):
                yield y
        else:
            yield x

Response: Flatten a multi - dimensional array - like to a single dimensional sequence - like.


Instruction:
Can you write a function in Python 3 where it
converts text read from the first positional argument stdin or a file to GeoJSON and write to stdout.

Response:
def cli(input, verbose, quiet, output_format, precision, indent):
    """Convert text read from the first positional argument, stdin, or
    a file to GeoJSON and write to stdout."""

    verbosity = verbose - quiet
    configure_logging(verbosity)
    logger = logging.getLogger('geomet')

    # Handle the case of file, stream, or string input.
    try:
        src = click.open_file(input).readlines()
    except IOError:
        src = [input]

    stdout = click.get_text_stream('stdout')

    # Read-write loop.
    try:
        for line in src:
            text = line.strip()
            logger.debug("Input: %r", text)
            output = translate(
                text,
                output_format=output_format,
                indent=indent,
                precision=precision
            )
            logger.debug("Output: %r", output)
            stdout.write(output)
            stdout.write('\n')
        sys.exit(0)
    except Exception:
        logger.exception("Failed. Exception caught")
        sys.exit(1)


Instruction:
Here you have a function in Python 3, explain what it does
def _get_geom_type(type_bytes):
    # slice off the high byte, which may contain the SRID flag
    high_byte = type_bytes[0]
    if six.PY3:
        high_byte = bytes([high_byte])
    has_srid = high_byte == b'\x20'
    if has_srid:
        # replace the high byte with a null byte
        type_bytes = as_bin_str(b'\x00' + type_bytes[1:])
    else:
        type_bytes = as_bin_str(type_bytes)

    # look up the geometry type
    geom_type = _BINARY_TO_GEOM_TYPE.get(type_bytes)
    return geom_type, type_bytes, has_srid

Response: Get the GeoJSON geometry type label from a WKB type byte string.


Instruction:
Write a Python 3 script for
dumping a GeoJSON - like dict to a WKB string.

Response:
def dumps(obj, big_endian=True):
    """
    Dump a GeoJSON-like `dict` to a WKB string.

    .. note::
        The dimensions of the generated WKB will be inferred from the first
        vertex in the GeoJSON `coordinates`. It will be assumed that all
        vertices are uniform. There are 4 types:

        - 2D (X, Y): 2-dimensional geometry
        - Z (X, Y, Z): 3-dimensional geometry
        - M (X, Y, M): 2-dimensional geometry with a "Measure"
        - ZM (X, Y, Z, M): 3-dimensional geometry with a "Measure"

        If the first vertex contains 2 values, we assume a 2D geometry.
        If the first vertex contains 3 values, this is slightly ambiguous and
        so the most common case is chosen: Z.
        If the first vertex contains 4 values, we assume a ZM geometry.

        The WKT/WKB standards provide a way of differentiating normal (2D), Z,
        M, and ZM geometries (http://en.wikipedia.org/wiki/Well-known_text),
        but the GeoJSON spec does not. Therefore, for the sake of interface
        simplicity, we assume that geometry that looks 3D contains XYZ
        components, instead of XYM.

        If the coordinates list has no coordinate values (this includes nested
        lists, for example, `[[[[],[]], []]]`, the geometry is considered to be
        empty. Geometries, with the exception of points, have a reasonable
        "empty" representation in WKB; however, without knowing the number of
        coordinate values per vertex, the type is ambigious, and thus we don't
        know if the geometry type is 2D, Z, M, or ZM. Therefore in this case
        we expect a `ValueError` to be raised.

    :param dict obj:
        GeoJson-like `dict` object.
    :param bool big_endian:
        Defaults to `True`. If `True`, data values in the generated WKB will
        be represented using big endian byte order. Else, little endian.

    TODO: remove this

    :param str dims:
        Indicates to WKB representation desired from converting the given
        GeoJSON `dict` ``obj``. The accepted values are:

        * '2D': 2-dimensional geometry (X, Y)
        * 'Z': 3-dimensional geometry (X, Y, Z)
        * 'M': 3-dimensional geometry (X, Y, M)
        * 'ZM': 4-dimensional geometry (X, Y, Z, M)

    :returns:
        A WKB binary string representing of the ``obj``.
    """
    geom_type = obj['type']
    meta = obj.get('meta', {})

    exporter = _dumps_registry.get(geom_type)
    if exporter is None:
        _unsupported_geom_type(geom_type)

    # Check for empty geometries. GeometryCollections have a slightly different
    # JSON/dict structure, but that's handled.
    coords_or_geoms = obj.get('coordinates', obj.get('geometries'))
    if len(list(flatten_multi_dim(coords_or_geoms))) == 0:
        raise ValueError(
            'Empty geometries cannot be represented in WKB. Reason: The '
            'dimensionality of the WKB would be ambiguous.'
        )

    return exporter(obj, big_endian, meta)


Instruction:
Can you write a function in Python 3 where it
takes a WKB string and returns a GeoJSON dict.

Response:
def loads(string):
    """
    Construct a GeoJSON `dict` from WKB (`string`).

    The resulting GeoJSON `dict` will include the SRID as an integer in the
    `meta` object. This was an arbitrary decision made by `geomet, the
    discussion of which took place here:
    https://github.com/geomet/geomet/issues/28.

    In order to be consistent with other libraries [1] and (deprecated)
    specifications [2], also include the same information in a `crs`
    object. This isn't ideal, but the `crs` member is no longer part of
    the GeoJSON standard, according to RFC7946 [3]. However, it's still
    useful to include this information in GeoJSON payloads because it
    supports conversion to EWKT/EWKB (which are canonical formats used by
    PostGIS and the like).

    Example:

        {'type': 'Point',
         'coordinates': [0.0, 1.0],
         'meta': {'srid': 4326},
         'crs': {'type': 'name', 'properties': {'name': 'EPSG4326'}}}

    NOTE(larsbutler): I'm not sure if it's valid to just prefix EPSG
    (European Petroluem Survey Group) to an SRID like this, but we'll
    stick with it for now until it becomes a problem.

    NOTE(larsbutler): Ideally, we should use URNs instead of this
    notation, according to the new GeoJSON spec [4]. However, in
    order to be consistent with [1], we'll stick with this approach
    for now.

    References:

    [1] - https://github.com/bryanjos/geo/issues/76
    [2] - http://geojson.org/geojson-spec.html#coordinate-reference-system-objects
    [3] - https://tools.ietf.org/html/rfc7946#appendix-B.1
    [4] - https://tools.ietf.org/html/rfc7946#section-4
    """  # noqa
    string = iter(string)
    # endianness = string[0:1]
    endianness = as_bin_str(take(1, string))
    if endianness == BIG_ENDIAN:
        big_endian = True
    elif endianness == LITTLE_ENDIAN:
        big_endian = False
    else:
        raise ValueError("Invalid endian byte: '0x%s'. Expected 0x00 or 0x01"
                         % binascii.hexlify(endianness.encode()).decode())

    endian_token = '>' if big_endian else '<'
    # type_bytes = string[1:5]
    type_bytes = as_bin_str(take(4, string))
    if not big_endian:
        # To identify the type, order the type bytes in big endian:
        type_bytes = type_bytes[::-1]

    geom_type, type_bytes, has_srid = _get_geom_type(type_bytes)
    srid = None
    if has_srid:
        srid_field = as_bin_str(take(4, string))
        [srid] = struct.unpack('%si' % endian_token, srid_field)

    # data_bytes = string[5:]  # FIXME: This won't work for GeometryCollections
    data_bytes = string

    importer = _loads_registry.get(geom_type)

    if importer is None:
        _unsupported_geom_type(geom_type)

    data_bytes = iter(data_bytes)
    result = importer(big_endian, type_bytes, data_bytes)
    if has_srid:
        # As mentioned in the docstring above, include both approaches to
        # indicating the SRID.
        result['meta'] = {'srid': int(srid)}
        result['crs'] = {
            'type': 'name',
            'properties': {'name': 'EPSG%s' % srid},
        }
    return result


Instruction:
Given the following Python 3 function, write the documentation
def _header_bytefmt_byteorder(geom_type, num_dims, big_endian, meta=None):
    dim = _INT_TO_DIM_LABEL.get(num_dims)
    if dim is None:
        pass  # TODO: raise

    type_byte_str = _WKB[dim][geom_type]
    srid = meta.get('srid')
    if srid is not None:
        # Add the srid flag
        type_byte_str = SRID_FLAG + type_byte_str[1:]

    if big_endian:
        header = BIG_ENDIAN
        byte_fmt = b'>'
        byte_order = '>'
    else:
        header = LITTLE_ENDIAN
        byte_fmt = b'<'
        byte_order = '<'
        # reverse the byte ordering for little endian
        type_byte_str = type_byte_str[::-1]

    header += type_byte_str
    if srid is not None:
        srid = int(srid)

        if big_endian:
            srid_header = struct.pack('>i', srid)
        else:
            srid_header = struct.pack('<i', srid)
        header += srid_header
    byte_fmt += b'd' * num_dims

    return header, byte_fmt, byte_order

Response: Utility function to get the header byte format string and byte order string.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _dump_point(obj, big_endian, meta):
    coords = obj['coordinates']
    num_dims = len(coords)

    wkb_string, byte_fmt, _ = _header_bytefmt_byteorder(
        'Point', num_dims, big_endian, meta
    )

    wkb_string += struct.pack(byte_fmt, *coords)
    return wkb_string

Response: Dump a GeoJSON - like dict to a point WKB string.


Instruction:
Implement a Python 3 function for
dumping a GeoJSON - like dict to a linestring WKB string.

Response:
def _dump_linestring(obj, big_endian, meta):
    """
    Dump a GeoJSON-like `dict` to a linestring WKB string.

    Input parameters and output are similar to :func:`_dump_point`.
    """
    coords = obj['coordinates']
    vertex = coords[0]
    # Infer the number of dimensions from the first vertex
    num_dims = len(vertex)

    wkb_string, byte_fmt, byte_order = _header_bytefmt_byteorder(
        'LineString', num_dims, big_endian, meta
    )
    # append number of vertices in linestring
    wkb_string += struct.pack('%sl' % byte_order, len(coords))

    for vertex in coords:
        wkb_string += struct.pack(byte_fmt, *vertex)

    return wkb_string


Instruction:
Can you implement a function in Python 3 that
dumps a GeoJSON - like dict to a multipoint WKB string.

Response:
def _dump_multipoint(obj, big_endian, meta):
    """
    Dump a GeoJSON-like `dict` to a multipoint WKB string.

    Input parameters and output are similar to :funct:`_dump_point`.
    """
    coords = obj['coordinates']
    vertex = coords[0]
    num_dims = len(vertex)

    wkb_string, byte_fmt, byte_order = _header_bytefmt_byteorder(
        'MultiPoint', num_dims, big_endian, meta
    )

    point_type = _WKB[_INT_TO_DIM_LABEL.get(num_dims)]['Point']
    if big_endian:
        point_type = BIG_ENDIAN + point_type
    else:
        point_type = LITTLE_ENDIAN + point_type[::-1]

    wkb_string += struct.pack('%sl' % byte_order, len(coords))
    for vertex in coords:
        # POINT type strings
        wkb_string += point_type
        wkb_string += struct.pack(byte_fmt, *vertex)

    return wkb_string


Instruction:
Can you write a function in Python 3 where it
dumps a GeoJSON - like dict to a multilinestring WKB string.

Response:
def _dump_multilinestring(obj, big_endian, meta):
    """
    Dump a GeoJSON-like `dict` to a multilinestring WKB string.

    Input parameters and output are similar to :funct:`_dump_point`.
    """
    coords = obj['coordinates']
    vertex = coords[0][0]
    num_dims = len(vertex)

    wkb_string, byte_fmt, byte_order = _header_bytefmt_byteorder(
        'MultiLineString', num_dims, big_endian, meta
    )

    ls_type = _WKB[_INT_TO_DIM_LABEL.get(num_dims)]['LineString']
    if big_endian:
        ls_type = BIG_ENDIAN + ls_type
    else:
        ls_type = LITTLE_ENDIAN + ls_type[::-1]

    # append the number of linestrings
    wkb_string += struct.pack('%sl' % byte_order, len(coords))

    for linestring in coords:
        wkb_string += ls_type
        # append the number of vertices in each linestring
        wkb_string += struct.pack('%sl' % byte_order, len(linestring))
        for vertex in linestring:
            wkb_string += struct.pack(byte_fmt, *vertex)

    return wkb_string


Instruction:
Can you write a function in Python 3 where it
dumps a GeoJSON - like dict to a multipolygon WKB string.

Response:
def _dump_multipolygon(obj, big_endian, meta):
    """
    Dump a GeoJSON-like `dict` to a multipolygon WKB string.

    Input parameters and output are similar to :funct:`_dump_point`.
    """
    coords = obj['coordinates']
    vertex = coords[0][0][0]
    num_dims = len(vertex)

    wkb_string, byte_fmt, byte_order = _header_bytefmt_byteorder(
        'MultiPolygon', num_dims, big_endian, meta
    )

    poly_type = _WKB[_INT_TO_DIM_LABEL.get(num_dims)]['Polygon']
    if big_endian:
        poly_type = BIG_ENDIAN + poly_type
    else:
        poly_type = LITTLE_ENDIAN + poly_type[::-1]

    # apped the number of polygons
    wkb_string += struct.pack('%sl' % byte_order, len(coords))

    for polygon in coords:
        # append polygon header
        wkb_string += poly_type
        # append the number of rings in this polygon
        wkb_string += struct.pack('%sl' % byte_order, len(polygon))
        for ring in polygon:
            # append the number of vertices in this ring
            wkb_string += struct.pack('%sl' % byte_order, len(ring))
            for vertex in ring:
                wkb_string += struct.pack(byte_fmt, *vertex)

    return wkb_string


Instruction:
Explain what the following Python 3 code does
def _load_point(big_endian, type_bytes, data_bytes):
    endian_token = '>' if big_endian else '<'

    if type_bytes == WKB_2D['Point']:
        coords = struct.unpack('%sdd' % endian_token,
                               as_bin_str(take(16, data_bytes)))
    elif type_bytes == WKB_Z['Point']:
        coords = struct.unpack('%sddd' % endian_token,
                               as_bin_str(take(24, data_bytes)))
    elif type_bytes == WKB_M['Point']:
        # NOTE: The use of XYM types geometries is quite rare. In the interest
        # of removing ambiguity, we will treat all XYM geometries as XYZM when
        # generate the GeoJSON. A default Z value of `0.0` will be given in
        # this case.
        coords = list(struct.unpack('%sddd' % endian_token,
                                    as_bin_str(take(24, data_bytes))))
        coords.insert(2, 0.0)
    elif type_bytes == WKB_ZM['Point']:
        coords = struct.unpack('%sdddd' % endian_token,
                               as_bin_str(take(32, data_bytes)))

    return dict(type='Point', coordinates=list(coords))

Response: Convert byte data for a Point into a GeoJSON dict.


Instruction:
Can you create a Python 3 function that
dumps a GeoJSON - like dict to a WKT string.

Response:
def dumps(obj, decimals=16):
    """
    Dump a GeoJSON-like `dict` to a WKT string.
    """
    try:
        geom_type = obj['type']
        exporter = _dumps_registry.get(geom_type)

        if exporter is None:
            _unsupported_geom_type(geom_type)

        # Check for empty cases
        if geom_type == 'GeometryCollection':
            if len(obj['geometries']) == 0:
                return 'GEOMETRYCOLLECTION EMPTY'
        else:
            # Geom has no coordinate values at all, and must be empty.
            if len(list(util.flatten_multi_dim(obj['coordinates']))) == 0:
                return '%s EMPTY' % geom_type.upper()
    except KeyError:
        raise geomet.InvalidGeoJSONException('Invalid GeoJSON: %s' % obj)

    result = exporter(obj, decimals)
    # Try to get the SRID from `meta.srid`
    meta_srid = obj.get('meta', {}).get('srid')
    # Also try to get it from `crs.properties.name`:
    crs_srid = obj.get('crs', {}).get('properties', {}).get('name')
    if crs_srid is not None:
        # Shave off the EPSG prefix to give us the SRID:
        crs_srid = crs_srid.replace('EPSG', '')

    if (meta_srid is not None and
            crs_srid is not None and
            str(meta_srid) != str(crs_srid)):
        raise ValueError(
            'Ambiguous CRS/SRID values: %s and %s' % (meta_srid, crs_srid)
        )
    srid = meta_srid or crs_srid

    # TODO: add tests for CRS input
    if srid is not None:
        # Prepend the SRID
        result = 'SRID=%s;%s' % (srid, result)
    return result


Instruction:
Can you generate the documentation for the following Python 3 function
def loads(string):
    sio = StringIO.StringIO(string)
    # NOTE: This is not the intended purpose of `tokenize`, but it works.
    tokens = (x[1] for x in tokenize.generate_tokens(sio.readline))
    tokens = _tokenize_wkt(tokens)
    geom_type_or_srid = next(tokens)
    srid = None
    geom_type = geom_type_or_srid
    if geom_type_or_srid == 'SRID':
        # The geometry WKT contains an SRID header.
        _assert_next_token(tokens, '=')
        srid = int(next(tokens))
        _assert_next_token(tokens, ';')
        # We expected the geometry type to be next:
        geom_type = next(tokens)
    else:
        geom_type = geom_type_or_srid

    importer = _loads_registry.get(geom_type)

    if importer is None:
        _unsupported_geom_type(geom_type)

    peek = six.advance_iterator(tokens)
    if peek == 'EMPTY':
        if geom_type == 'GEOMETRYCOLLECTION':
            return dict(type='GeometryCollection', geometries=[])
        else:
            return dict(type=_type_map_caps_to_mixed[geom_type],
                        coordinates=[])

    # Put the peeked element back on the head of the token generator
    tokens = itertools.chain([peek], tokens)
    result = importer(tokens, string)
    if srid is not None:
        result['meta'] = dict(srid=srid)
    return result

Response: Construct a GeoJSON dict from a WKT string.


Instruction:
Can you tell what is the following Python 3 function doing
def _tokenize_wkt(tokens):
    negative = False
    for t in tokens:
        if t == '-':
            negative = True
            continue
        else:
            if negative:
                yield '-%s' % t
            else:
                yield t
            negative = False

Response: Yields a list of tokens from the WKT.


Instruction:
How would you code a function in Python 3 to
round the input value to decimals places and pad with 0 s

Response:
def _round_and_pad(value, decimals):
    """
    Round the input value to `decimals` places, and pad with 0's
    if the resulting value is less than `decimals`.

    :param value:
        The value to round
    :param decimals:
        Number of decimals places which should be displayed after the rounding.
    :return:
        str of the rounded value
    """
    if isinstance(value, int) and decimals != 0:
        # if we get an int coordinate and we have a non-zero value for
        # `decimals`, we want to create a float to pad out.
        value = float(value)

    elif decimals == 0:
        # if get a `decimals` value of 0, we want to return an int.
        return repr(int(round(value, decimals)))

    rounded = repr(round(value, decimals))
    rounded += '0' * (decimals - len(rounded.split('.')[1]))
    return rounded


Instruction:
Can you generate the documentation for the following Python 3 function
def _dump_point(obj, decimals):
    coords = obj['coordinates']
    pt = 'POINT (%s)' % ' '.join(_round_and_pad(c, decimals)
                                 for c in coords)
    return pt

Response: Dump a GeoJSON - like Point object to WKT.


Instruction:
Can you tell what is the following Python 3 function doing
def _dump_linestring(obj, decimals):
    coords = obj['coordinates']
    ls = 'LINESTRING (%s)'
    ls %= ', '.join(' '.join(_round_and_pad(c, decimals)
                             for c in pt) for pt in coords)
    return ls

Response: Dump a GeoJSON - like LineString object to WKT.


Instruction:
Implement a Python 3 function for
dumping a GeoJSON - like Polygon object to WKT.

Response:
def _dump_polygon(obj, decimals):
    """
    Dump a GeoJSON-like Polygon object to WKT.

    Input parameters and return value are the POLYGON equivalent to
    :func:`_dump_point`.
    """
    coords = obj['coordinates']
    poly = 'POLYGON (%s)'
    rings = (', '.join(' '.join(_round_and_pad(c, decimals)
                                for c in pt) for pt in ring)
             for ring in coords)
    rings = ('(%s)' % r for r in rings)
    poly %= ', '.join(rings)
    return poly


Instruction:
Write a Python 3 function that can
dump a GeoJSON - like MultiPoint object to WKT.

Response:
def _dump_multipoint(obj, decimals):
    """
    Dump a GeoJSON-like MultiPoint object to WKT.

    Input parameters and return value are the MULTIPOINT equivalent to
    :func:`_dump_point`.
    """
    coords = obj['coordinates']
    mp = 'MULTIPOINT (%s)'
    points = (' '.join(_round_and_pad(c, decimals)
                       for c in pt) for pt in coords)
    # Add parens around each point.
    points = ('(%s)' % pt for pt in points)
    mp %= ', '.join(points)
    return mp


Instruction:
Can you generate the documentation for the following Python 3 function
def _dump_multilinestring(obj, decimals):
    coords = obj['coordinates']
    mlls = 'MULTILINESTRING (%s)'
    linestrs = ('(%s)' % ', '.join(' '.join(_round_and_pad(c, decimals)
                for c in pt) for pt in linestr) for linestr in coords)
    mlls %= ', '.join(ls for ls in linestrs)
    return mlls

Response: Dump a GeoJSON - like MultiLineString object to WKT.


Instruction:
Can you create a Python 3 function that
dumps a GeoJSON - like MultiPolygon object to WKT.

Response:
def _dump_multipolygon(obj, decimals):
    """
    Dump a GeoJSON-like MultiPolygon object to WKT.

    Input parameters and return value are the MULTIPOLYGON equivalent to
    :func:`_dump_point`.
    """
    coords = obj['coordinates']
    mp = 'MULTIPOLYGON (%s)'

    polys = (
        # join the polygons in the multipolygon
        ', '.join(
            # join the rings in a polygon,
            # and wrap in parens
            '(%s)' % ', '.join(
                # join the points in a ring,
                # and wrap in parens
                '(%s)' % ', '.join(
                    # join coordinate values of a vertex
                    ' '.join(_round_and_pad(c, decimals) for c in pt)
                    for pt in ring)
                for ring in poly)
            for poly in coords)
    )
    mp %= polys
    return mp


Instruction:
Write a Python 3 function for
dumping a GeoJSON - like GeometryCollection object to WKT.

Response:
def _dump_geometrycollection(obj, decimals):
    """
    Dump a GeoJSON-like GeometryCollection object to WKT.

    Input parameters and return value are the GEOMETRYCOLLECTION equivalent to
    :func:`_dump_point`.

    The WKT conversions for each geometry in the collection are delegated to
    their respective functions.
    """
    gc = 'GEOMETRYCOLLECTION (%s)'
    geoms = obj['geometries']
    geoms_wkt = []
    for geom in geoms:
        geom_type = geom['type']
        geoms_wkt.append(_dumps_registry.get(geom_type)(geom, decimals))
    gc %= ','.join(geoms_wkt)
    return gc


Instruction:
How would you explain what the following Python 3 function does
def _load_point(tokens, string):
    if not next(tokens) == '(':
        raise ValueError(INVALID_WKT_FMT % string)

    coords = []
    try:
        for t in tokens:
            if t == ')':
                break
            else:
                coords.append(float(t))
    except tokenize.TokenError:
        raise ValueError(INVALID_WKT_FMT % string)

    return dict(type='Point', coordinates=coords)

Response: Load a point from a WKT string.


Instruction:
Explain what the following Python 3 code does
def _load_linestring(tokens, string):
    if not next(tokens) == '(':
        raise ValueError(INVALID_WKT_FMT % string)

    # a list of lists
    # each member list represents a point
    coords = []
    try:
        pt = []
        for t in tokens:
            if t == ')':
                coords.append(pt)
                break
            elif t == ',':
                # it's the end of the point
                coords.append(pt)
                pt = []
            else:
                pt.append(float(t))
    except tokenize.TokenError:
        raise ValueError(INVALID_WKT_FMT % string)

    return dict(type='LineString', coordinates=coords)

Response: Loads a WKT string into a GeoJSON dict.


Instruction:
How would you explain what the following Python 3 function does
def _load_polygon(tokens, string):
    open_parens = next(tokens), next(tokens)
    if not open_parens == ('(', '('):
        raise ValueError(INVALID_WKT_FMT % string)

    # coords contains a list of rings
    # each ring contains a list of points
    # each point is a list of 2-4 values
    coords = []

    ring = []
    on_ring = True
    try:
        pt = []
        for t in tokens:
            if t == ')' and on_ring:
                # The ring is finished
                ring.append(pt)
                coords.append(ring)
                on_ring = False
            elif t == ')' and not on_ring:
                # it's the end of the polygon
                break
            elif t == '(':
                # it's a new ring
                ring = []
                pt = []
                on_ring = True
            elif t == ',' and on_ring:
                # it's the end of a point
                ring.append(pt)
                pt = []
            elif t == ',' and not on_ring:
                # there's another ring.
                # do nothing
                pass
            else:
                pt.append(float(t))
    except tokenize.TokenError:
        raise ValueError(INVALID_WKT_FMT % string)

    return dict(type='Polygon', coordinates=coords)

Response: Parses a WKT string and returns a GeoJSON Polygon representation of the WKT string.


Instruction:
Can you write a function in Python 3 where it
parses a WKT string and returns a GeoJSON MultiPoint representation of the WKT string.

Response:
def _load_multipoint(tokens, string):
    """
    Has similar inputs and return value to to :func:`_load_point`, except is
    for handling MULTIPOINT geometry.

    :returns:
        A GeoJSON `dict` MultiPoint representation of the WKT ``string``.
    """
    open_paren = next(tokens)
    if not open_paren == '(':
        raise ValueError(INVALID_WKT_FMT % string)

    coords = []
    pt = []

    paren_depth = 1
    try:
        for t in tokens:
            if t == '(':
                paren_depth += 1
            elif t == ')':
                paren_depth -= 1
                if paren_depth == 0:
                    break
            elif t == '':
                pass
            elif t == ',':
                # the point is done
                coords.append(pt)
                pt = []
            else:
                pt.append(float(t))
    except tokenize.TokenError:
        raise ValueError(INVALID_WKT_FMT % string)

    # Given the way we're parsing, we'll probably have to deal with the last
    # point after the loop
    if len(pt) > 0:
        coords.append(pt)

    return dict(type='MultiPoint', coordinates=coords)


Instruction:
Given the following Python 3 function, write the documentation
def _load_multipolygon(tokens, string):
    open_paren = next(tokens)
    if not open_paren == '(':
        raise ValueError(INVALID_WKT_FMT % string)

    polygons = []
    while True:
        try:
            poly = _load_polygon(tokens, string)
            polygons.append(poly['coordinates'])
            t = next(tokens)
            if t == ')':
                # we're done; no more polygons.
                break
        except StopIteration:
            # If we reach this, the WKT is not valid.
            raise ValueError(INVALID_WKT_FMT % string)

    return dict(type='MultiPolygon', coordinates=polygons)

Response: Loads a MULTIPOLYGON geometry from a WKT string.


Instruction:
How would you implement a function in Python 3 that
loads a MULTILINESTRING geometry from a WKT string.

Response:
def _load_multilinestring(tokens, string):
    """
    Has similar inputs and return value to to :func:`_load_point`, except is
    for handling MULTILINESTRING geometry.

    :returns:
        A GeoJSON `dict` MultiLineString representation of the WKT ``string``.
    """
    open_paren = next(tokens)
    if not open_paren == '(':
        raise ValueError(INVALID_WKT_FMT % string)

    linestrs = []
    while True:
        try:
            linestr = _load_linestring(tokens, string)
            linestrs.append(linestr['coordinates'])
            t = next(tokens)
            if t == ')':
                # we're done; no more linestrings.
                break
        except StopIteration:
            # If we reach this, the WKT is not valid.
            raise ValueError(INVALID_WKT_FMT % string)

    return dict(type='MultiLineString', coordinates=linestrs)


Instruction:
Write a Python 3 script to
parse a WKT string and returns a GeoJSON GeometryCollection representation of the WKT.

Response:
def _load_geometrycollection(tokens, string):
    """
    Has similar inputs and return value to to :func:`_load_point`, except is
    for handling GEOMETRYCOLLECTIONs.

    Delegates parsing to the parsers for the individual geometry types.

    :returns:
        A GeoJSON `dict` GeometryCollection representation of the WKT
        ``string``.
    """
    open_paren = next(tokens)
    if not open_paren == '(':
        raise ValueError(INVALID_WKT_FMT % string)

    geoms = []
    result = dict(type='GeometryCollection', geometries=geoms)
    while True:
        try:
            t = next(tokens)
            if t == ')':
                break
            elif t == ',':
                # another geometry still
                continue
            else:
                geom_type = t
                load_func = _loads_registry.get(geom_type)
                geom = load_func(tokens, string)
                geoms.append(geom)
        except StopIteration:
            raise ValueError(INVALID_WKT_FMT % string)
    return result


Instruction:
Here you have a function in Python 3, explain what it does
def _get_request_params(self, **kwargs):
        request_params = copy.deepcopy(self._shared_request_params)
        for key, value in iteritems(kwargs):
            if isinstance(value, dict) and key in request_params:
                # ensure we don't lose dict values like headers or cookies
                request_params[key].update(value)
            else:
                request_params[key] = value
        return request_params

Response: Merge shared params and new params.


Instruction:
Write a Python 3 script to
remove keyword arguments not used by requests

Response:
def _sanitize_request_params(self, request_params):
        """Remove keyword arguments not used by `requests`"""
        if 'verify_ssl' in request_params:
            request_params['verify'] = request_params.pop('verify_ssl')
        return dict((key, val) for key, val in request_params.items()
                    if key in self._VALID_REQUEST_ARGS)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def request(self, method, path, **kwargs):
        if path:
            url = '%s/%s' % (self.url.rstrip('/'), path.lstrip('/'))
        else:
            url = self.url

        request_params = self._get_request_params(method=method,
                                                  url=url, **kwargs)
        request_params = self.pre_send(request_params)

        sanitized_params = self._sanitize_request_params(request_params)
        start_time = time.time()
        response = super(HTTPServiceClient, self).request(**sanitized_params)

        # Log request and params (without passwords)
        log.debug(
            '%s HTTP [%s] call to "%s" %.2fms',
            response.status_code, method, response.url,
            (time.time() - start_time) * 1000)
        auth = sanitized_params.pop('auth', None)
        log.debug('HTTP request params: %s', sanitized_params)
        if auth:
            log.debug('Authentication via HTTP auth as "%s"', auth[0])

        response.is_ok = response.status_code < 300
        if not self.is_acceptable(response, request_params):
            raise HTTPServiceError(response)
        response = self.post_send(response, **request_params)
        return response

Response: Send a HTTP request and demand a


Instruction:
How would you code a function in Python 3 to
override this method to modify sent request parameters

Response:
def pre_send(self, request_params):
        """Override this method to modify sent request parameters"""
        for adapter in itervalues(self.adapters):
            adapter.max_retries = request_params.get('max_retries', 0)

        return request_params


Instruction:
Implement a Python 3 function for
returning True if the response is acceptable for the current request.

Response:
def is_acceptable(self, response, request_params):
        """
        Override this method to create a different definition of
        what kind of response is acceptable.
        If `bool(the_return_value) is False` then an `HTTPServiceError`
        will be raised.

        For example, you might want to assert that the body must be empty,
        so you could return `len(response.content) == 0`.

        In the default implementation, a response is acceptable
        if and only if the response code is either
        less than 300 (typically 200, i.e. OK) or if it is in the
        `expected_response_codes` parameter in the constructor.
        """
        expected_codes = request_params.get('expected_response_codes', [])
        return response.is_ok or response.status_code in expected_codes


Instruction:
Can you tell what is the following Python 3 function doing
def _roundSlist(slist):
    slist[-1] = 60 if slist[-1] >= 30 else 0
    for i in range(len(slist)-1, 1, -1):
        if slist[i] == 60:
            slist[i] = 0
            slist[i-1] += 1
    return slist[:-1]

Response: Rounds a signed list over the last element.


Instruction:
Implement a Python 3 function for
converting angle string to signed list.

Response:
def strSlist(string):
    """ Converts angle string to signed list. """
    sign = '-' if string[0] == '-' else '+'
    values = [abs(int(x)) for x in string.split(':')]
    return _fixSlist(list(sign) + values)


Instruction:
Create a Python 3 function for
converting signed list to angle string.

Response:
def slistStr(slist):
    """ Converts signed list to angle string. """
    slist = _fixSlist(slist)
    string = ':'.join(['%02d' % x for x in slist[1:]])
    return slist[0] + string


Instruction:
How would you code a function in Python 3 to
convert signed list to float.

Response:
def slistFloat(slist):
    """ Converts signed list to float. """
    values = [v / 60**(i) for (i,v) in enumerate(slist[1:])]
    value = sum(values)
    return -value if slist[0] == '-' else value


Instruction:
Can you tell what is the following Python 3 function doing
def floatSlist(value):
    slist = ['+', 0, 0, 0, 0]
    if value < 0:
        slist[0] = '-'
    value = abs(value)
    for i in range(1,5):
        slist[i] = math.floor(value)
        value = (value - slist[i]) * 60
    return _roundSlist(slist)

Response: Converts float to signed list.


Instruction:
Make a summary of the following Python 3 code
def toFloat(value):
    if isinstance(value, str):
        return strFloat(value)
    elif isinstance(value, list):
        return slistFloat(value)
    else:
        return value

Response: Converts string or signed list to float.


Instruction:
Can you tell what is the following Python 3 function doing
def inDignities(self, idA, idB):
        objA = self.chart.get(idA)
        info = essential.getInfo(objA.sign, objA.signlon)
        # Should we ignore exile and fall?
        return [dign for (dign, ID) in info.items() if ID == idB]

Response: Returns the dignities of A which belong to B.


Instruction:
Can you tell what is the following Python 3 function doing
def mutualReceptions(self, idA, idB):
        AB = self.receives(idA, idB)
        BA = self.receives(idB, idA)
        # Returns a product of both lists
        return [(a,b) for a in AB for b in BA]

Response: Returns all pairs of dignities in mutual reception.


Instruction:
Can you write a function in Python 3 where it
returns ruler and exaltation mutual receptions.

Response:
def reMutualReceptions(self, idA, idB):
        """ Returns ruler and exaltation mutual receptions. """
        mr = self.mutualReceptions(idA, idB)
        filter_ = ['ruler', 'exalt']
        # Each pair of dignities must be 'ruler' or 'exalt'
        return [(a,b) for (a,b) in mr if (a in filter_ and b in filter_)]


Instruction:
Can you tell what is the following Python 3 function doing
def validAspects(self, ID, aspList):
        obj = self.chart.getObject(ID)
        res = []

        for otherID in const.LIST_SEVEN_PLANETS:
            if ID == otherID:
                continue

            otherObj = self.chart.getObject(otherID)
            aspType = aspects.aspectType(obj, otherObj, aspList)
            if aspType != const.NO_ASPECT:
                res.append({
                    'id': otherID,
                    'asp': aspType,
                })
        return res

Response:
Returns a list with the aspects an object
        makes with the other six planets considering a
        list of possible aspects.


Instruction:
Here you have a function in Python 3, explain what it does
def aspectsByCat(self, ID, aspList):
        res = {
            const.APPLICATIVE: [],
            const.SEPARATIVE: [],
            const.EXACT: [],
            const.NO_MOVEMENT: []
        }

        objA = self.chart.getObject(ID)
        valid = self.validAspects(ID, aspList)
        for elem in valid:
            objB = self.chart.getObject(elem['id'])
            asp = aspects.getAspect(objA, objB, aspList)
            role = asp.getRole(objA.id)
            if role['inOrb']:
                movement = role['movement']
                res[movement].append({
                    'id': objB.id,
                    'asp': asp.type,
                    'orb': asp.orb
                })

        return res

Response: Returns the aspects an object makes with the highest priority.


Instruction:
How would you code a function in Python 3 to
return the last separation and next application based on a list of possible aspects.

Response:
def immediateAspects(self, ID, aspList):
        """ Returns the last separation and next application
        considering a list of possible aspects.

        """
        asps = self.aspectsByCat(ID, aspList)

        applications = asps[const.APPLICATIVE]
        separations = asps[const.SEPARATIVE]
        exact = asps[const.EXACT]

        # Get applications and separations sorted by orb

        applications = applications + [val for val in exact if val['orb'] >= 0]

        applications = sorted(applications, key=lambda var: var['orb'])
        separations = sorted(separations, key=lambda var: var['orb'])

        return (
            separations[0] if separations else None,
            applications[0] if applications else None
        )


Instruction:
How would you explain what the following Python 3 function does
def isVOC(self, ID):
        asps = self.aspectsByCat(ID, const.MAJOR_ASPECTS)
        applications = asps[const.APPLICATIVE]
        exacts = asps[const.EXACT]
        return len(applications) == 0 and len(exacts) == 0

Response: Returns if a planet is VOC of Course.


Instruction:
Can you generate the documentation for the following Python 3 function
def singleFactor(factors, chart, factor, obj, aspect=None):

    objID = obj if type(obj) == str else obj.id
    res = {
        'factor': factor,
        'objID': objID,
        'aspect': aspect
    }

    # For signs (obj as string) return sign element
    if type(obj) == str:
        res['element'] = props.sign.element[obj]

    # For Sun return sign and sunseason element
    elif objID == const.SUN:
        sunseason = props.sign.sunseason[obj.sign]
        res['sign'] = obj.sign
        res['sunseason'] = sunseason
        res['element'] = props.base.sunseasonElement[sunseason]

    # For Moon return phase and phase element
    elif objID == const.MOON:
        phase = chart.getMoonPhase()
        res['phase'] = phase
        res['element'] = props.base.moonphaseElement[phase]

    # For regular planets return element or sign/sign element
    # if there's an aspect involved
    elif objID in const.LIST_SEVEN_PLANETS:
        if aspect:
            res['sign'] = obj.sign
            res['element'] = props.sign.element[obj.sign]
        else:
            res['element'] = obj.element()

    try:
        # If there's element, insert into list
        res['element']
        factors.append(res)
    except KeyError:
        pass

    return res

Response: Single factor for the table.


Instruction:
Write a Python 3 function that can
compute a factor for a modifier.

Response:
def modifierFactor(chart, factor, factorObj, otherObj, aspList):
    """ Computes a factor for a modifier. """

    asp = aspects.aspectType(factorObj, otherObj, aspList)
    if asp != const.NO_ASPECT:
        return {
            'factor': factor,
            'aspect': asp,
            'objID': otherObj.id,
            'element': otherObj.element()
        }
    return None


Instruction:
Create a Python 3 function for
returning the list of factors for the temperament.

Response:
def getFactors(chart):
    """ Returns the factors for the temperament. """

    factors = []

    # Asc sign
    asc = chart.getAngle(const.ASC)
    singleFactor(factors, chart, ASC_SIGN, asc.sign)

    # Asc ruler
    ascRulerID = essential.ruler(asc.sign)
    ascRuler = chart.getObject(ascRulerID)
    singleFactor(factors, chart, ASC_RULER, ascRuler)
    singleFactor(factors, chart, ASC_RULER_SIGN, ascRuler.sign)

    # Planets in House 1
    house1 = chart.getHouse(const.HOUSE1)
    planetsHouse1 = chart.objects.getObjectsInHouse(house1)
    for obj in planetsHouse1:
        singleFactor(factors, chart, HOUSE1_PLANETS_IN, obj)

    # Planets conjunct Asc
    planetsConjAsc = chart.objects.getObjectsAspecting(asc, [0])
    for obj in planetsConjAsc:
        # Ignore planets already in house 1
        if obj not in planetsHouse1:
            singleFactor(factors, chart, ASC_PLANETS_CONJ, obj)

    # Planets aspecting Asc cusp
    aspList = [60, 90, 120, 180]
    planetsAspAsc = chart.objects.getObjectsAspecting(asc, aspList)
    for obj in planetsAspAsc:
        aspect = aspects.aspectType(obj, asc, aspList)
        singleFactor(factors, chart, ASC_PLANETS_ASP, obj, aspect)

    # Moon sign and phase
    moon = chart.getObject(const.MOON)
    singleFactor(factors, chart, MOON_SIGN, moon.sign)
    singleFactor(factors, chart, MOON_PHASE, moon)

    # Moon dispositor
    moonRulerID = essential.ruler(moon.sign)
    moonRuler = chart.getObject(moonRulerID)
    moonFactor = singleFactor(factors, chart, MOON_DISPOSITOR_SIGN, moonRuler.sign)
    moonFactor['planetID'] = moonRulerID  # Append moon dispositor ID

    # Planets conjunct Moon
    planetsConjMoon = chart.objects.getObjectsAspecting(moon, [0])
    for obj in planetsConjMoon:
        singleFactor(factors, chart, MOON_PLANETS_CONJ, obj)

    # Planets aspecting Moon
    aspList = [60, 90, 120, 180]
    planetsAspMoon = chart.objects.getObjectsAspecting(moon, aspList)
    for obj in planetsAspMoon:
        aspect = aspects.aspectType(obj, moon, aspList)
        singleFactor(factors, chart, MOON_PLANETS_ASP, obj, aspect)

    # Sun season
    sun = chart.getObject(const.SUN)
    singleFactor(factors, chart, SUN_SEASON, sun)

    return factors


Instruction:
Can you implement a function in Python 3 that
returns the factors of the temperament modifiers.

Response:
def getModifiers(chart):
    """ Returns the factors of the temperament modifiers. """

    modifiers = []

    # Factors which can be affected
    asc = chart.getAngle(const.ASC)
    ascRulerID = essential.ruler(asc.sign)
    ascRuler = chart.getObject(ascRulerID)
    moon = chart.getObject(const.MOON)
    factors = [
        [MOD_ASC, asc],
        [MOD_ASC_RULER, ascRuler],
        [MOD_MOON, moon]
    ]

    # Factors of affliction
    mars = chart.getObject(const.MARS)
    saturn = chart.getObject(const.SATURN)
    sun = chart.getObject(const.SUN)
    affect = [
        [mars, [0, 90, 180]],
        [saturn, [0, 90, 180]],
        [sun, [0]]
    ]

    # Do calculations of afflictions
    for affectingObj, affectingAsps in affect:
        for factor, affectedObj in factors:
            modf = modifierFactor(chart,
                                  factor,
                                  affectedObj,
                                  affectingObj,
                                  affectingAsps)
            if modf:
                modifiers.append(modf)

    return modifiers


Instruction:
How would you explain what the following Python 3 function does
def scores(factors):
    temperaments = {
        const.CHOLERIC: 0,
        const.MELANCHOLIC: 0,
        const.SANGUINE: 0,
        const.PHLEGMATIC: 0
    }

    qualities = {
        const.HOT: 0,
        const.COLD: 0,
        const.DRY: 0,
        const.HUMID: 0
    }

    for factor in factors:
        element = factor['element']

        # Score temperament
        temperament = props.base.elementTemperament[element]
        temperaments[temperament] += 1

        # Score qualities
        tqualities = props.base.temperamentQuality[temperament]
        qualities[tqualities[0]] += 1
        qualities[tqualities[1]] += 1

    return {
        'temperaments': temperaments,
        'qualities': qualities
    }

Response: Computes the score of temperaments and qualities of the current resource.


Instruction:
Explain what the following Python 3 code does
def getObject(ID, date, pos):
    obj = eph.getObject(ID, date.jd, pos.lat, pos.lon)
    return Object.fromDict(obj)

Response: Returns an ephemeris object.


Instruction:
Given the following Python 3 function, write the documentation
def getObjectList(IDs, date, pos):
    objList = [getObject(ID, date, pos) for ID in IDs]
    return ObjectList(objList)

Response: Returns a list of objects.


Instruction:
Implement a function in Python 3 to
return the lists of houses and angles.

Response:
def getHouses(date, pos, hsys):
    """ Returns the lists of houses and angles.

    Since houses and angles are computed at the
    same time, this function should be fast.

    """
    houses, angles = eph.getHouses(date.jd, pos.lat, pos.lon, hsys)
    hList = [House.fromDict(house) for house in houses]
    aList = [GenericObject.fromDict(angle) for angle in angles]
    return (HouseList(hList), GenericList(aList))


Instruction:
Write a Python 3 function for
returning a fixed star from the ephemeris.

Response:
def getFixedStar(ID, date):
    """ Returns a fixed star from the ephemeris. """
    star = eph.getFixedStar(ID, date.jd)
    return FixedStar.fromDict(star)


Instruction:
Given the following Python 3 function, write the documentation
def getFixedStarList(IDs, date):
    starList = [getFixedStar(ID, date) for ID in IDs]
    return FixedStarList(starList)

Response: Returns a list of fixed stars.


Instruction:
How would you implement a function in Python 3 that
returns the next date when sun is at longitude lon.

Response:
def nextSolarReturn(date, lon):
    """ Returns the next date when sun is at longitude 'lon'. """
    jd = eph.nextSolarReturn(date.jd, lon)
    return Datetime.fromJD(jd, date.utcoffset)


Instruction:
Can you generate the documentation for the following Python 3 function
def prevSolarReturn(date, lon):
    jd = eph.prevSolarReturn(date.jd, lon)
    return Datetime.fromJD(jd, date.utcoffset)

Response: Returns the previous date when sun is at longitude lon.


Instruction:
Can you create a Python 3 function that
returns the date of the next sunrise.

Response:
def nextSunrise(date, pos):
    """ Returns the date of the next sunrise. """
    jd = eph.nextSunrise(date.jd, pos.lat, pos.lon)
    return Datetime.fromJD(jd, date.utcoffset)


Instruction:
Can you write a function in Python 3 where it
returns the aproximate date of the next station.

Response:
def nextStation(ID, date):
    """ Returns the aproximate date of the next station. """
    jd = eph.nextStation(ID, date.jd)
    return Datetime.fromJD(jd, date.utcoffset)


Instruction:
Given the following Python 3 function, write the documentation
def prevSolarEclipse(date):

    eclipse = swe.solarEclipseGlobal(date.jd, backward=True)
    return Datetime.fromJD(eclipse['maximum'], date.utcoffset)

Response: Returns the Datetime of the maximum phase of the previous global solar eclipse.


Instruction:
Given the following Python 3 function, write the documentation
def nextSolarEclipse(date):

    eclipse = swe.solarEclipseGlobal(date.jd, backward=False)
    return Datetime.fromJD(eclipse['maximum'], date.utcoffset)

Response: Returns the Datetime of the maximum phase of the next global solar eclipse.


Instruction:
Given the following Python 3 function, write the documentation
def prevLunarEclipse(date):

    eclipse = swe.lunarEclipseGlobal(date.jd, backward=True)
    return Datetime.fromJD(eclipse['maximum'], date.utcoffset)

Response: Returns the Datetime of the maximum phase of the previous global lunar eclipse.


Instruction:
Make a summary of the following Python 3 code
def nextLunarEclipse(date):

    eclipse = swe.lunarEclipseGlobal(date.jd, backward=False)
    return Datetime.fromJD(eclipse['maximum'], date.utcoffset)

Response: Returns the Datetime of the maximum phase of the next global lunar eclipse.


Instruction:
How would you implement a function in Python 3 that
plots the tropical solar length by year.

Response:
def plot(hdiff, title):
    """ Plots the tropical solar length
    by year.

    """
    import matplotlib.pyplot as plt
    years = [elem[0] for elem in hdiff]
    diffs = [elem[1] for elem in hdiff]
    plt.plot(years, diffs)
    plt.ylabel('Distance in minutes')
    plt.xlabel('Year')
    plt.title(title)
    plt.axhline(y=0, c='red')
    plt.show()


Instruction:
Make a summary of the following Python 3 code
def ascdiff(decl, lat):
    delta = math.radians(decl)
    phi = math.radians(lat)
    ad = math.asin(math.tan(delta) * math.tan(phi))
    return math.degrees(ad)

Response: Returns the Ascensional Difference of a point.


Instruction:
How would you code a function in Python 3 to
return the diurnal and nocturnal arcs of a point.

Response:
def dnarcs(decl, lat):
    """ Returns the diurnal and nocturnal arcs of a point. """
    dArc = 180 + 2 * ascdiff(decl, lat)
    nArc = 360 - dArc
    return (dArc, nArc)


Instruction:
Can you write a function in Python 3 where it
returns True if an object s ra and decl is above the horizon at a specific latitude.

Response:
def isAboveHorizon(ra, decl, mcRA, lat):
    """ Returns if an object's 'ra' and 'decl'
    is above the horizon at a specific latitude,
    given the MC's right ascension.

    """
    # This function checks if the equatorial distance from
    # the object to the MC is within its diurnal semi-arc.

    dArc, _ = dnarcs(decl, lat)
    dist = abs(angle.closestdistance(mcRA, ra))
    return dist <= dArc/2.0 + 0.0003


Instruction:
Can you tell what is the following Python 3 function doing
def eqCoords(lon, lat):
    # Convert to radians
    _lambda = math.radians(lon)
    _beta = math.radians(lat)
    _epson = math.radians(23.44)  # The earth's inclination

    # Declination in radians
    decl = math.asin(math.sin(_epson) * math.sin(_lambda) * math.cos(_beta) + \
           math.cos(_epson) * math.sin(_beta))

    # Equatorial Distance in radians
    ED = math.acos(math.cos(_lambda) * math.cos(_beta) / math.cos(decl))

    # RA in radians
    ra = ED if lon < 180 else math.radians(360) - ED

    # Correctness of RA if longitude is close to 0º or 180º in a radius of 5º
    if (abs(angle.closestdistance(lon, 0)) < 5 or
        abs(angle.closestdistance(lon, 180)) < 5):
            a = math.sin(ra) * math.cos(decl)
            b = math.cos(_epson) * math.sin(_lambda) * math.cos(_beta) - \
                math.sin(_epson) * math.sin(_beta)
            if (math.fabs(a-b) > 0.0003):
                ra = math.radians(360) - ra

    return (math.degrees(ra), math.degrees(decl))

Response: Converts from ecliptical to equatorial coordinates.


Instruction:
Can you write a function in Python 3 where it
returns an object s relation with the sun.

Response:
def sunRelation(obj, sun):
    """ Returns an object's relation with the sun. """
    if obj.id == const.SUN:
        return None
    dist = abs(angle.closestdistance(sun.lon, obj.lon))
    if dist < 0.2833: return CAZIMI
    elif dist < 8.0: return COMBUST
    elif dist < 16.0: return UNDER_SUN
    else:
        return None


Instruction:
Can you write a function in Python 3 where it
returns if an object is augmenting or diminishing light.

Response:
def light(obj, sun):
    """ Returns if an object is augmenting or diminishing light. """
    dist = angle.distance(sun.lon, obj.lon)
    faster = sun if sun.lonspeed > obj.lonspeed else obj
    if faster == sun:
        return LIGHT_DIMINISHING if dist < 180 else LIGHT_AUGMENTING
    else:
        return LIGHT_AUGMENTING if dist < 180 else LIGHT_DIMINISHING


Instruction:
Explain what the following Python 3 code does
def orientality(obj, sun):
    dist = angle.distance(sun.lon, obj.lon)
    return OCCIDENTAL if dist < 180 else ORIENTAL

Response:
Returns if an object is oriental or
    occidental to the sun.


Instruction:
Write a Python 3 script for
returning if an object is in Haiz.

Response:
def haiz(obj, chart):
    """ Returns if an object is in Haiz. """
    objGender = obj.gender()
    objFaction = obj.faction()

    if obj.id == const.MERCURY:
        # Gender and faction of mercury depends on orientality
        sun = chart.getObject(const.SUN)
        orientalityM = orientality(obj, sun)
        if orientalityM == ORIENTAL:
            objGender = const.MASCULINE
            objFaction = const.DIURNAL
        else:
            objGender = const.FEMININE
            objFaction = const.NOCTURNAL

    # Object gender match sign gender?
    signGender = props.sign.gender[obj.sign]
    genderConformity = (objGender == signGender)

    # Match faction
    factionConformity = False
    diurnalChart = chart.isDiurnal()

    if obj.id == const.SUN and not diurnalChart:
        # Sun is in conformity only when above horizon
        factionConformity = False
    else:
        # Get list of houses in the chart's diurnal faction
        if diurnalChart:
            diurnalFaction = props.house.aboveHorizon
            nocturnalFaction = props.house.belowHorizon
        else:
            diurnalFaction = props.house.belowHorizon
            nocturnalFaction = props.house.aboveHorizon

        # Get the object's house and match factions
        objHouse = chart.houses.getObjectHouse(obj)
        if (objFaction == const.DIURNAL and objHouse.id in diurnalFaction or
            objFaction == const.NOCTURNAL and objHouse.id in nocturnalFaction):
                factionConformity = True

    # Match things
    if (genderConformity and factionConformity):
        return HAIZ
    elif (not genderConformity and not factionConformity):
        return CHAIZ
    else:
        return None


Instruction:
Write a Python 3 function for
returning the object s house.

Response:
def house(self):
        """ Returns the object's house. """
        house = self.chart.houses.getObjectHouse(self.obj)
        return house


Instruction:
How would you explain what the following Python 3 function does
def sunRelation(self):
        sun = self.chart.getObject(const.SUN)
        return sunRelation(self.obj, sun)

Response: Returns the relation of the object with the sun.


Instruction:
How would you implement a function in Python 3 that
returns if object is augmenting or diminishing its

Response:
def light(self):
        """ Returns if object is augmenting or diminishing its
        light.

        """
        sun = self.chart.getObject(const.SUN)
        return light(self.obj, sun)


Instruction:
How would you implement a function in Python 3 that
returns the orientality of the object.

Response:
def orientality(self):
        """ Returns the orientality of the object. """
        sun = self.chart.getObject(const.SUN)
        return orientality(self.obj, sun)


Instruction:
Write a Python 3 function that can
return True if the object is in its house of joy.

Response:
def inHouseJoy(self):
        """ Returns if the object is in its house of joy. """
        house = self.house()
        return props.object.houseJoy[self.obj.id] == house.id


Instruction:
Can you implement a function in Python 3 that
returns True if the object is in its sign of joy.

Response:
def inSignJoy(self):
        """ Returns if the object is in its sign of joy. """
        return props.object.signJoy[self.obj.id] == self.obj.sign


Instruction:
Can you generate a brief explanation for the following Python 3 code
def reMutualReceptions(self):
        planets = copy(const.LIST_SEVEN_PLANETS)
        planets.remove(self.obj.id)
        mrs = {}
        for ID in planets:
            mr = self.dyn.reMutualReceptions(self.obj.id, ID)
            if mr:
                mrs[ID] = mr
        return mrs

Response:
Returns all mutual receptions with the object
        and other planets indexed by planet ID.


Instruction:
Here you have a function in Python 3, explain what it does
def eqMutualReceptions(self):
        mrs = self.reMutualReceptions()
        res = []
        for ID, receptions in mrs.items():
            for pair in receptions:
                if pair[0] == pair[1]:
                    res.append(pair[0])
        return res

Response:
Returns a list with all mutual receptions with the
        object and other planets when the reception is the
        same for both ruler and both exaltation.


Instruction:
Implement a function in Python 3 to
return a list with the aspects that the object makes to the objects in IDs. It considers only conjunctions and other exact or applicative aspects are returned.

Response:
def __aspectLists(self, IDs, aspList):
        """ Returns a list with the aspects that the object
        makes to the objects in IDs. It considers only
        conjunctions and other exact/applicative aspects
        if in aspList.

        """
        res = []

        for otherID in IDs:
            # Ignore same
            if otherID == self.obj.id:
                continue

            # Get aspects to the other object
            otherObj = self.chart.getObject(otherID)
            asp = aspects.getAspect(self.obj, otherObj, aspList)

            if asp.type == const.NO_ASPECT:
                continue
            elif asp.type == const.CONJUNCTION:
                res.append(asp.type)
            else:
                # Only exact or applicative aspects
                movement = asp.movement()
                if movement in [const.EXACT, const.APPLICATIVE]:
                    res.append(asp.type)

        return res


Instruction:
Implement a Python 3 function for
returning a list of good aspects the object makes to the benefics.

Response:
def aspectBenefics(self):
        """ Returns a list with the good aspects the object
        makes to the benefics.

        """
        benefics = [const.VENUS, const.JUPITER]
        return self.__aspectLists(benefics, aspList=[0, 60, 120])


Instruction:
Can you tell what is the following Python 3 function doing
def aspectMalefics(self):
        malefics = [const.MARS, const.SATURN]
        return self.__aspectLists(malefics, aspList=[0, 90, 180])

Response:
Returns a list with the bad aspects the object

        makes to the malefics.


Instruction:
Can you implement a function in Python 3 that
returns true if the object last and next movement are separations and applications to objects in list IDs.

Response:
def __sepApp(self, IDs, aspList):
        """ Returns true if the object last and next movement are
        separations and applications to objects in list IDs.
        It only considers aspects in aspList.

        This function is static since it does not test if the next
        application will be indeed perfected. It considers only
        a snapshot of the chart and not its astronomical movement.

        """
        sep, app = self.dyn.immediateAspects(self.obj.id, aspList)
        if sep is None or app is None:
            return False
        else:
            sepCondition = sep['id'] in IDs
            appCondition = app['id'] in IDs
            return sepCondition == appCondition == True


Instruction:
How would you code a function in Python 3 to
return True if the object is separating and applying to a benefic considering good aspects.

Response:
def isAuxilied(self):
        """ Returns if the object is separating and applying to
        a benefic considering good aspects.

        """
        benefics = [const.VENUS, const.JUPITER]
        return self.__sepApp(benefics, aspList=[0, 60, 120])


Instruction:
Create a Python 3 function to
return True if the object is separating and applying to a malefic considering bad aspects.

Response:
def isSurrounded(self):
        """ Returns if the object is separating and applying to
        a malefic considering bad aspects.

        """
        malefics = [const.MARS, const.SATURN]
        return self.__sepApp(malefics, aspList=[0, 90, 180])


Instruction:
Write a Python 3 function for
returning if object is conjunct north node.

Response:
def isConjNorthNode(self):
        """ Returns if object is conjunct north node. """
        node = self.chart.getObject(const.NORTH_NODE)
        return aspects.hasAspect(self.obj, node, aspList=[0])


Instruction:
Implement a function in Python 3 to
return if object is conjunct south node.

Response:
def isConjSouthNode(self):
        """ Returns if object is conjunct south node. """
        node = self.chart.getObject(const.SOUTH_NODE)
        return aspects.hasAspect(self.obj, node, aspList=[0])


Instruction:
Can you write a function in Python 3 where it
returns true if the object has any as well as any .

Response:
def isFeral(self):
        """ Returns true if the object does not have any
        aspects.

        """
        planets = copy(const.LIST_SEVEN_PLANETS)
        planets.remove(self.obj.id)
        for otherID in planets:
            otherObj = self.chart.getObject(otherID)
            if aspects.hasAspect(self.obj, otherObj, const.MAJOR_ASPECTS):
                return False
        return True


Instruction:
Given the following Python 3 function, write the documentation
def getScoreProperties(self):
        obj = self.obj
        score = {}

        # Peregrine
        isPeregrine = essential.isPeregrine(obj.id, obj.sign, obj.signlon)
        score['peregrine'] = -5 if isPeregrine else 0

        # Ruler-Ruler and Exalt-Exalt mutual receptions
        mr = self.eqMutualReceptions()
        score['mr_ruler'] = +5 if 'ruler' in mr else 0
        score['mr_exalt'] = +4 if 'exalt' in mr else 0

        # House scores
        score['house'] = self.houseScore()

        # Joys
        score['joy_sign'] = +3 if self.inSignJoy() else 0
        score['joy_house'] = +2 if self.inHouseJoy() else 0

        # Relations with sun
        score['cazimi'] = +5 if self.isCazimi() else 0
        score['combust'] = -6 if self.isCombust() else 0
        score['under_sun'] = -4 if self.isUnderSun() else 0
        score['no_under_sun'] = 0
        if obj.id != const.SUN and not self.sunRelation():
            score['no_under_sun'] = +5

        # Light
        score['light'] = 0
        if obj.id != const.SUN:
            score['light'] = +1 if self.isAugmentingLight() else -1

        # Orientality
        score['orientality'] = 0
        if obj.id in [const.SATURN, const.JUPITER, const.MARS]:
            score['orientality'] = +2 if self.isOriental() else -2
        elif obj.id in [const.VENUS, const.MERCURY, const.MOON]:
            score['orientality'] = -2 if self.isOriental() else +2

        # Moon nodes
        score['north_node'] = -3 if self.isConjNorthNode() else 0
        score['south_node'] = -5 if self.isConjSouthNode() else 0

        # Direction and speed
        score['direction'] = 0
        if obj.id not in [const.SUN, const.MOON]:
            score['direction'] = +4 if obj.isDirect() else -5
        score['speed'] = +2 if obj.isFast() else -2

        # Aspects to benefics
        aspBen = self.aspectBenefics()
        score['benefic_asp0'] = +5 if const.CONJUNCTION in aspBen else 0
        score['benefic_asp120'] = +4 if const.TRINE in aspBen else 0
        score['benefic_asp60'] = +3 if const.SEXTILE in aspBen else 0

        # Aspects to malefics
        aspMal = self.aspectMalefics()
        score['malefic_asp0'] = -5 if const.CONJUNCTION in aspMal else 0
        score['malefic_asp180'] = -4 if const.OPPOSITION in aspMal else 0
        score['malefic_asp90'] = -3 if const.SQUARE in aspMal else 0

        # Auxily and Surround
        score['auxilied'] = +5 if self.isAuxilied() else 0
        score['surround'] = -5 if self.isSurrounded() else 0

        # Voc and Feral
        score['feral'] = -3 if self.isFeral() else 0
        score['void'] = -2 if (self.isVoc() and score['feral'] == 0) else 0

        # Haiz
        haiz = self.haiz()
        score['haiz'] = 0
        if haiz == HAIZ:
            score['haiz'] = +3
        elif haiz == CHAIZ:
            score['haiz'] = -2

        # Moon via combusta
        score['viacombusta'] = 0
        if obj.id == const.MOON and viaCombusta(obj):
            score['viacombusta'] = -2

        return score

Response:
Returns the accidental dignity score of the object
        as dict.


Instruction:
How would you explain what the following Python 3 function does
def getActiveProperties(self):
        score = self.getScoreProperties()
        return {key: value for (key, value) in score.items()
                if value != 0}

Response: Returns the non - zero accidental dignities.


Instruction:
Can you write a function in Python 3 where it
returns the sum of the accidental dignities clf.

Response:
def score(self):
        """ Returns the sum of the accidental dignities
        score.

        """
        if not self.scoreProperties:
            self.scoreProperties = self.getScoreProperties()
        return sum(self.scoreProperties.values())


Instruction:
Implement a Python 3 function for
building an object from a dictionary of properties.

Response:
def fromDict(cls, _dict):
        """ Builds instance from dictionary of properties. """
        obj = cls()
        obj.__dict__.update(_dict)
        return obj


Instruction:
Write a Python 3 function for
returning the Equatorial Coordinates of this object.

Response:
def eqCoords(self, zerolat=False):
        """ Returns the Equatorial Coordinates of this object.
        Receives a boolean parameter to consider a zero latitude.

        """
        lat = 0.0 if zerolat else self.lat
        return utils.eqCoords(self.lon, lat)


Instruction:
Write a Python 3 script to
relocate this object to a new longitude.

Response:
def relocate(self, lon):
        """ Relocates this object to a new longitude. """
        self.lon = angle.norm(lon)
        self.signlon = self.lon % 30
        self.sign = const.LIST_SIGNS[int(self.lon / 30.0)]


Instruction:
Can you generate the documentation for the following Python 3 function
def antiscia(self):
        obj = self.copy()
        obj.type = const.OBJ_GENERIC
        obj.relocate(360 - obj.lon + 180)
        return obj

Response: Returns an antiscia object.


Instruction:
Can you generate the documentation for the following Python 3 function
def movement(self):
        if abs(self.lonspeed) < 0.0003:
            return const.STATIONARY
        elif self.lonspeed > 0:
            return const.DIRECT
        else:
            return const.RETROGRADE

Response:
Returns if this object is direct retrograde
        or stationary. Otherwise returns direct retrograde
       .


Instruction:
Can you generate a brief explanation for the following Python 3 code
def inHouse(self, lon):
        dist = angle.distance(self.lon + House._OFFSET, lon)
        return dist < self.size

Response: Returns True if a longitude belongs to this house.


Instruction:
Make a summary of the following Python 3 code
def orb(self):
        for (mag, orb) in FixedStar._ORBS:
            if self.mag < mag:
                return orb
        return 0.5

Response: Returns the orb of this fixed star.


Instruction:
Write a Python 3 script for
returning true if this star aspects another object.

Response:
def aspects(self, obj):
        """ Returns true if this star aspects another object.
        Fixed stars only aspect by conjunctions.

        """
        dist = angle.closestdistance(self.lon, obj.lon)
        return abs(dist) < self.orb()


Instruction:
Implement a function in Python 3 to
return a list with all objects in a house.

Response:
def getObjectsInHouse(self, house):
        """ Returns a list with all objects in a house. """
        res = [obj for obj in self if house.hasObject(obj)]
        return ObjectList(res)


Instruction:
Given the following Python 3 function, write the documentation
def getObjectsAspecting(self, point, aspList):
        res = []
        for obj in self:
            if obj.isPlanet() and aspects.isAspecting(obj, point, aspList):
                res.append(obj)
        return ObjectList(res)

Response:
Returns a list of objects aspecting a point
        considering a list of possible aspects.


Instruction:
Make a summary of the following Python 3 code
def arc(pRA, pDecl, sRA, sDecl, mcRA, lat):
    pDArc, pNArc = utils.dnarcs(pDecl, lat)
    sDArc, sNArc = utils.dnarcs(sDecl, lat)

    # Select meridian and arcs to be used
    # Default is MC and Diurnal arcs
    mdRA = mcRA
    sArc = sDArc
    pArc = pDArc
    if not utils.isAboveHorizon(sRA, sDecl, mcRA, lat):
        # Use IC and Nocturnal arcs
        mdRA = angle.norm(mcRA + 180)
        sArc = sNArc
        pArc = pNArc

    # Promissor and Significator distance to meridian
    pDist = angle.closestdistance(mdRA, pRA)
    sDist = angle.closestdistance(mdRA, sRA)

    # Promissor should be after significator (in degrees)
    if pDist < sDist:
        pDist += 360

    # Meridian distances proportional to respective semi-arcs
    sPropDist = sDist / (sArc / 2.0)
    pPropDist = pDist / (pArc / 2.0)

    # The arc is how much of the promissor's semi-arc is
    # needed to reach the significator
    return (pPropDist - sPropDist) * (pArc / 2.0)

Response: Returns the arc of direction between a promissor and significator.


Instruction:
Write a Python 3 script to
return the arc of direction between a promissor and a significator.

Response:
def getArc(prom, sig, mc, pos, zerolat):
    """ Returns the arc of direction between a promissor
    and a significator. Arguments are also the MC, the
    geoposition and zerolat to assume zero ecliptical
    latitudes.

    ZeroLat true => inZodiaco, false => inMundo

    """
    pRA, pDecl = prom.eqCoords(zerolat)
    sRa, sDecl = sig.eqCoords(zerolat)
    mcRa, mcDecl = mc.eqCoords()
    return arc(pRA, pDecl, sRa, sDecl, mcRa, pos.lat)


Instruction:
Write a Python 3 script to
build a data structure indexing the terms longitude by sign and object.

Response:
def _buildTerms(self):
        """ Builds a data structure indexing the terms
        longitude by sign and object.

        """
        termLons = tables.termLons(tables.EGYPTIAN_TERMS)
        res = {}
        for (ID, sign, lon) in termLons:
            try:
                res[sign][ID] = lon
            except KeyError:
                res[sign] = {}
                res[sign][ID] = lon
        return res


Instruction:
Here you have a function in Python 3, explain what it does
def G(self, ID, lat, lon):

        # Equatorial coordinates
        eqM = utils.eqCoords(lon, lat)
        eqZ = eqM
        if lat != 0:
            eqZ = utils.eqCoords(lon, 0)

        return {
            'id': ID,
            'lat': lat,
            'lon': lon,
            'ra': eqM[0],
            'decl': eqM[1],
            'raZ': eqZ[0],
            'declZ': eqZ[1],
        }

Response: Creates a generic entry for an object.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def T(self, ID, sign):
        lon = self.terms[sign][ID]
        ID = 'T_%s_%s' % (ID, sign)
        return self.G(ID, 0, lon)

Response: Returns the term of an object in a sign.


Instruction:
Given the following Python 3 function, write the documentation
def A(self, ID):
        obj = self.chart.getObject(ID).antiscia()
        ID = 'A_%s' % (ID)
        return self.G(ID, obj.lat, obj.lon)

Response: Returns the Antiscia of an object.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def C(self, ID):
        obj = self.chart.getObject(ID).cantiscia()
        ID = 'C_%s' % (ID)
        return self.G(ID, obj.lat, obj.lon)

Response: Returns the CAntiscia of an object.


Instruction:
How would you code a function in Python 3 to
return the dexter aspect of an object.

Response:
def D(self, ID, asp):
        """ Returns the dexter aspect of an object. """
        obj = self.chart.getObject(ID).copy()
        obj.relocate(obj.lon - asp)
        ID = 'D_%s_%s' % (ID, asp)
        return self.G(ID, obj.lat, obj.lon)


Instruction:
How would you implement a function in Python 3 that
returns the conjunction or opposition aspect of an object.

Response:
def N(self, ID, asp=0):
        """ Returns the conjunction or opposition aspect
        of an object.

        """
        obj = self.chart.get(ID).copy()
        obj.relocate(obj.lon + asp)
        ID = 'N_%s_%s' % (ID, asp)
        return self.G(ID, obj.lat, obj.lon)


Instruction:
Explain what the following Python 3 code does
def _arc(self, prom, sig):
        arcm = arc(prom['ra'], prom['decl'],
                   sig['ra'], sig['decl'],
                   self.mcRA, self.lat)
        arcz = arc(prom['raZ'], prom['declZ'],
                   sig['raZ'], sig['declZ'],
                   self.mcRA, self.lat)
        return {
            'arcm': arcm,
            'arcz': arcz
        }

Response:
Computes the in - zodiaco and in - mundo arcs
        between a promissor and a significator.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def getArc(self, prom, sig):
        res = self._arc(prom, sig)
        res.update({
            'prom': prom['id'],
            'sig': sig['id']
        })
        return res

Response: Returns the arcs between a promissor and a significator.


Instruction:
How would you explain what the following Python 3 function does
def _elements(self, IDs, func, aspList):
        res = []
        for asp in aspList:
            if (asp in [0, 180]):
                # Generate func for conjunctions and oppositions
                if func == self.N:
                    res.extend([func(ID, asp) for ID in IDs])
                else:
                    res.extend([func(ID) for ID in IDs])
            else:
                # Generate Dexter and Sinister for others
                res.extend([self.D(ID, asp) for ID in IDs])
                res.extend([self.S(ID, asp) for ID in IDs])
        return res

Response: Returns the IDs as objects considering the aspList and the function.