Exemplo n.º 1
0
 def to_instance(cls, ob, default=None, strict=False):
     """Encode a GeoJSON dict into an GeoJSON object.
     
     Assumes the caller knows that the dict should satisfy a GeoJSON type.
     """
     if ob is None and default is not None:
         instance = default()
     elif isinstance(ob, GeoJSON):
         instance = ob
     else:
         mapping = to_mapping(ob)
         d = dict((str(k), mapping[k]) for k in mapping)
         try:
             type_ = d.pop("type")
             geojson_factory = getattr(geojson.factory, type_)
             if not issubclass(geojson_factory, GeoJSON):
                 raise TypeError("""\
                 Not a valid GeoJSON type:
                 %r (geojson_factory: %r, cls: %r)
                 """ % (type_, geojson_factory, cls))
             instance = geojson_factory(**d)
         except (AttributeError, KeyError) as invalid:
             if not strict:
                 instance = ob
             else:
                 msg = "Cannot coerce %r into a valid GeoJSON structure: %s"
                 msg %= (ob, invalid)
                 raise ValueError(msg)
     return instance
Exemplo n.º 2
0
 def to_instance(cls, ob, default=None, strict=False):
     """Encode a GeoJSON dict into an GeoJSON object.
     
     Assumes the caller knows that the dict should satisfy a GeoJSON type.
     """
     if ob is None and default is not None:
         instance = default()
     elif isinstance(ob, GeoJSON):
         instance = ob
     else:
         mapping = to_mapping(ob)
         d = dict((str(k), mapping[k]) for k in mapping)
         try:
             type_ = d.pop("type")
             geojson_factory = getattr(geojson.factory, type_)
             if not issubclass(geojson_factory, GeoJSON):
                 raise TypeError("""\
                 Not a valid GeoJSON type:
                 %r (geojson_factory: %r, cls: %r)
                 """ % (type_, geojson_factory, cls))
             instance = geojson_factory(**d)
         except (AttributeError, KeyError), invalid:
             if not strict:
                 instance = ob
             else:
                 msg = "Cannot coerce %r into a valid GeoJSON structure: %s"
                 msg %= (ob, invalid)
                 raise ValueError(msg)
Exemplo n.º 3
0
    def positions(self) -> ScanResult:
        '''
        Extracts positions from SWATH_BATHYMETRY records. Scan result includes
        geojson line definition comprised of these unique positions.
        
        :return: :class:`hyo2.mate.lib.scan.ScanResult`
        '''

        if pygsf.SWATH_BATHYMETRY not in self.datagrams:
            msg = (
                "Swath bathymetry datagram (record id {}) not found in file. "
                "Unable to extract position data".format(
                    pygsf.SWATH_BATHYMETRY))
            return ScanResult(state=ScanState.WARNING, messages=msg)

        p_datagrams = self.datagrams[pygsf.SWATH_BATHYMETRY]
        position_points = []
        last_point = None
        for p_datagram in p_datagrams:
            pt = Point([p_datagram.longitude, p_datagram.latitude])
            if (last_point is not None
                    and pt.coordinates[0] == last_point.coordinates[0]
                    and pt.coordinates[1] == last_point.coordinates[1]):
                # skip any points that have the same location
                continue
            position_points.append(pt)
            last_point = pt
        line = LineString(position_points)
        feature = Feature(geometry=line)
        feature_collection = FeatureCollection([feature])
        data = {'map': to_mapping(feature_collection)}

        return ScanResult(state=ScanState.PASS, messages=[], data=data)
Exemplo n.º 4
0
    def positions(self) -> ScanResult:
        '''
        Extracts positions from position datagram. Scan result includes
        geojson line definition comprised of these unique positions.
        
        :return: :class:`hyo2.mate.lib.scan.ScanResult`
        '''

        if 'P' not in self.datagrams:
            return ScanResult(
                state=ScanState.WARNING,
                messages="Posistion datagram (P) not found in file",
                data={})

        p_datagrams = self.datagrams['P']
        position_points = []
        last_point = None
        for p_datagram in p_datagrams:
            pt = Point([p_datagram.Longitude, p_datagram.Latitude])
            if (last_point is not None
                    and pt.coordinates[0] == last_point.coordinates[0]
                    and pt.coordinates[1] == last_point.coordinates[1]):
                # skip any points that have the same location
                continue
            position_points.append(pt)
            last_point = pt
        line = LineString(position_points)
        feature = Feature(geometry=line)
        feature_collection = FeatureCollection([feature])
        data = {'map': to_mapping(feature_collection)}

        return ScanResult(state=ScanState.PASS, messages=[], data=data)
Exemplo n.º 5
0
    def to_instance(cls, ob, default=None, strict=False):
        """Encode a GeoJSON dict into an GeoJSON object.
        Assumes the caller knows that the dict should satisfy a GeoJSON type.

        :param cls: Dict containing the elements to be encoded into a GeoJSON
        object.
        :type cls: dict
        :param ob: GeoJSON object into which to encode the dict provided in
        `cls`.
        :type ob: GeoJSON
        :param default: A default instance to append the content of the dict
        to if none is provided.
        :type default: GeoJSON
        :param strict: Raise error if unable to coerce particular keys or
        attributes to a valid GeoJSON structure.
        :type strict: bool
        :return: A GeoJSON object with the dict's elements as its constituents.
        :rtype: GeoJSON
        :raises TypeError: If the input dict contains items that are not valid
        GeoJSON types.
        :raises UnicodeEncodeError: If the input dict contains items of a type
        that contain non-ASCII characters.
        :raises AttributeError: If the input dict contains items that are not
        valid GeoJSON types.
        """
        if ob is None and default is not None:
            instance = default()
        elif isinstance(ob, GeoJSON):
            instance = ob
        else:
            mapping = to_mapping(ob)
            d = {}
            for k in mapping:
                d[k] = mapping[k]
            try:
                type_ = d.pop("type")
                try:
                    type_ = str(type_)
                except UnicodeEncodeError:
                    # If the type contains non-ascii characters, we can assume
                    # it's not a valid GeoJSON type
                    raise AttributeError("{0} is not a GeoJSON type").format(
                        type_)
                geojson_factory = getattr(geojson.factory, type_)
                if not issubclass(geojson_factory, GeoJSON):
                    raise TypeError("""\
                    Not a valid GeoJSON type:
                    %r (geojson_factory: %r, cls: %r)
                    """ % (type_, geojson_factory, cls))
                instance = geojson_factory(**d)
            except (AttributeError, KeyError) as invalid:
                if strict:
                    msg = "Cannot coerce %r into a valid GeoJSON structure: %s"
                    msg %= (ob, invalid)
                    raise ValueError(msg)
                instance = ob
        return instance
Exemplo n.º 6
0
    def to_instance(cls, ob, default=None, strict=False):
        """Encode a GeoJSON dict into an GeoJSON object.
        Assumes the caller knows that the dict should satisfy a GeoJSON type.

        :param cls: Dict containing the elements to be encoded into a GeoJSON
        object.
        :type cls: dict
        :param ob: GeoJSON object into which to encode the dict provided in
        `cls`.
        :type ob: GeoJSON
        :param default: A default instance to append the content of the dict
        to if none is provided.
        :type default: GeoJSON
        :param strict: Raise error if unable to coerce particular keys or
        attributes to a valid GeoJSON structure.
        :type strict: bool
        :return: A GeoJSON object with the dict's elements as its constituents.
        :rtype: GeoJSON
        :raises TypeError: If the input dict contains items that are not valid
        GeoJSON types.
        :raises UnicodeEncodeError: If the input dict contains items of a type
        that contain non-ASCII characters.
        :raises AttributeError: If the input dict contains items that are not
        valid GeoJSON types.
        """
        if ob is None and default is not None:
            instance = default()
        elif isinstance(ob, GeoJSON):
            instance = ob
        else:
            mapping = to_mapping(ob)
            d = {}
            for k in mapping:
                d[k] = mapping[k]
            try:
                type_ = d.pop("type")
                try:
                    type_ = str(type_)
                except UnicodeEncodeError:
                    # If the type contains non-ascii characters, we can assume
                    # it's not a valid GeoJSON type
                    raise AttributeError(
                        "{0} is not a GeoJSON type").format(type_)
                geojson_factory = getattr(geojson.factory, type_)
                if not issubclass(geojson_factory, GeoJSON):
                    raise TypeError("""\
                    Not a valid GeoJSON type:
                    %r (geojson_factory: %r, cls: %r)
                    """ % (type_, geojson_factory, cls))
                instance = geojson_factory(**d)
            except (AttributeError, KeyError) as invalid:
                if strict:
                    msg = "Cannot coerce %r into a valid GeoJSON structure: %s"
                    msg %= (ob, invalid)
                    raise ValueError(msg)
                instance = ob
        return instance
Exemplo n.º 7
0
 def default(self, obj):
     if isinstance(obj, Mapping):
         mapping = obj
     else:
         mapping = to_mapping(obj)
     d = dict(mapping)
     type_str = d.pop("type", None)
     if type_str:
         geojson_factory = getattr(geojson.factory, type_str, geojson.factory.GeoJSON)
         d = geojson_factory(**d).__geo_interface__
     return d
 def encode(self, message, **kwargs):
     """
     Encode message for sending via channel
     - message in format FeatureCollection
     """
     if "metadata" in message:
         message["data"] = to_mapping(message["data"])
         print message
         return self.encode_channel(json.dumps(message))
     else:
         return self.encode_channel(geojson.dumps(message))
 def pack(self, messages, which="all", which_index=0):
     """
     pack messages for store
     """
     if which == "first":
         return geojson.dumps(messages[0])
     elif which == "last":
         return geojson.dumps(messages[-1])
     elif which == "index":
         return geojson.dumps(messages[which_index])
     else:
         package = {'messages': [to_mapping(m) for m in messages]}
         return json.dumps(package)
Exemplo n.º 10
0
    def to_instance(cls, ob, default=None, strict=False):
        """Encode a GeoJSON dict into an GeoJSON object.

        Assumes the caller knows that the dict should satisfy a GeoJSON type.
        """
        if ob is None and default is not None:
            instance = default()
        elif isinstance(ob, GeoJSON):
            instance = ob
        else:
            mapping = to_mapping(ob)
            d = {}
            for k in mapping:
                try:
                    str_key = str(k)
                except (UnicodeEncodeError):
                    str_key = unicode(k)
                d[str_key] = mapping[k]
            try:
                type_ = d.pop("type")
                try:
                    type_ = str(type_)
                except (UnicodeEncodeError):
                    # If the type contains non-ascii characters, we can assume
                    # it's not a valid GeoJSON type
                    raise AttributeError(
                        unicode("{0} is not a GeoJSON type").format(
                        unicode(type_)))
                geojson_factory = getattr(geojson.factory, type_)
                if not issubclass(geojson_factory, GeoJSON):
                    raise TypeError("""\
                    Not a valid GeoJSON type:
                    %r (geojson_factory: %r, cls: %r)
                    """ % (type_, geojson_factory, cls))
                instance = geojson_factory(**d)
            except (AttributeError, KeyError) as invalid:
                if not strict:
                    instance = ob
                else:
                    msg = "Cannot coerce %r into a valid GeoJSON structure: %s"
                    msg %= (ob, invalid)
                    raise ValueError(msg)
        return instance
Exemplo n.º 11
0
    def _to_points_geojson(self, items):
        '''
        Converts a list of dicts, where each dict contains a Latitude and
        Longitude into a geojson object
        '''

        features = []
        for item in items:
            pt = Point([item["Longitude"], item["Latitude"]])
            # remove the lat/lng otherwise it will be included in the geom
            # definition AND the properties for this point
            item_clone = item.copy()
            del item_clone["Longitude"]
            del item_clone["Latitude"]
            feature = Feature(geometry=pt, properties=item_clone)
            features.append(feature)

        fc = FeatureCollection(features)
        return to_mapping(fc)
Exemplo n.º 12
0
    def to_instance(cls, ob, default=None, strict=False):
        """Encode a GeoJSON dict into an GeoJSON object.

        Assumes the caller knows that the dict should satisfy a GeoJSON type.
        """
        if ob is None and default is not None:
            instance = default()
        elif isinstance(ob, GeoJSON):
            instance = ob
        else:
            mapping = to_mapping(ob)
            d = {}
            for k in mapping:
                try:
                    str_key = str(k)
                except (UnicodeEncodeError):
                    str_key = unicode(k)
                d[str_key] = mapping[k]
            try:
                type_ = d.pop("type")
                try:
                    type_ = str(type_)
                except (UnicodeEncodeError):
                    # If the type contains non-ascii characters, we can assume
                    # it's not a valid GeoJSON type
                    raise AttributeError(
                        unicode("{0} is not a GeoJSON type").format(
                            unicode(type_)))
                geojson_factory = getattr(geojson.factory, type_)
                if not issubclass(geojson_factory, GeoJSON):
                    raise TypeError("""\
                    Not a valid GeoJSON type:
                    %r (geojson_factory: %r, cls: %r)
                    """ % (type_, geojson_factory, cls))
                instance = geojson_factory(**d)
            except (AttributeError, KeyError) as invalid:
                if not strict:
                    instance = ob
                else:
                    msg = "Cannot coerce %r into a valid GeoJSON structure: %s"
                    msg %= (ob, invalid)
                    raise ValueError(msg)
        return instance
Exemplo n.º 13
0
    def test_GeoJSON(self):
        self.assertEqual(None, geojson.GeoJSON().__geo_interface__)

        self.assertEqual({"type": "GeoJSON"}, to_mapping(geojson.GeoJSON()))
Exemplo n.º 14
0
 def test_mapping(self):
     self.assertEqual(to_mapping(geojson.Point([1.0, 2.0])), {
         "coordinates": [1.0, 2.0],
         "type": "Point"
     })
Exemplo n.º 15
0
def dumps(obj, cls=GeoJSONEncoder, allow_nan=False, **kwargs):
    return json.dumps(to_mapping(obj),
                      cls=cls, allow_nan=allow_nan, **kwargs)
Exemplo n.º 16
0
 def test_mapping(self):
     self.assertEqual(to_mapping(geojson.Point([1, 2])),
                      {"coordinates": [1, 2], "type": "Point"})
Exemplo n.º 17
0
    def test_GeoJSON(self):
        self.assertEqual(None, geojson.GeoJSON().__geo_interface__)

        self.assertEqual({"type": "GeoJSON"}, to_mapping(geojson.GeoJSON()))
Exemplo n.º 18
0
def dumps(obj, cls=GeoJSONEncoder, **kwargs):
    return simplejson.dumps(to_mapping(obj), cls=cls, **kwargs)
Exemplo n.º 19
0
def to_dict(instance, deep=None, exclude=None, include=None,
            exclude_relations=None, include_relations=None,
            include_methods=None):
    """Returns a dictionary representing the fields of the specified `instance`
    of a SQLAlchemy model.

    The returned dictionary is suitable as an argument to
    :func:`flask.jsonify`; :class:`datetime.date` and :class:`uuid.UUID`
    objects are converted to string representations, so no special JSON encoder
    behavior is required.

    `deep` is a dictionary containing a mapping from a relation name (for a
    relation of `instance`) to either a list or a dictionary. This is a
    recursive structure which represents the `deep` argument when calling
    :func:`!_to_dict` on related instances. When an empty list is encountered,
    :func:`!_to_dict` returns a list of the string representations of the
    related instances.

    If either `include` or `exclude` is not ``None``, exactly one of them must
    be specified. If both are not ``None``, then this function will raise a
    :exc:`ValueError`. `exclude` must be a list of strings specifying the
    columns which will *not* be present in the returned dictionary
    representation of the object (in other words, it is a
    blacklist). Similarly, `include` specifies the only columns which will be
    present in the returned dictionary (in other words, it is a whitelist).

    .. note::

       If `include` is an iterable of length zero (like the empty tuple or the
       empty list), then the returned dictionary will be empty. If `include` is
       ``None``, then the returned dictionary will include all columns not
       excluded by `exclude`.

    `include_relations` is a dictionary mapping strings representing relation
    fields on the specified `instance` to a list of strings representing the
    names of fields on the related model which should be included in the
    returned dictionary; `exclude_relations` is similar.

    `include_methods` is a list mapping strings to method names which will
    be called and their return values added to the returned dictionary.

    """
    if (exclude is not None or exclude_relations is not None) and \
            (include is not None or include_relations is not None):
        raise ValueError('Cannot specify both include and exclude.')
    # create a list of names of columns, including hybrid properties
    instance_type = type(instance)
    columns = []
    try:
        inspected_instance = sqlalchemy_inspect(instance_type)
        column_attrs = inspected_instance.column_attrs.keys()
        descriptors = inspected_instance.all_orm_descriptors.items()
        hybrid_columns = [k for k, d in descriptors
                          if d.extension_type == hybrid.HYBRID_PROPERTY]
        columns = column_attrs + hybrid_columns
    except NoInspectionAvailable:
        return instance
    # filter the columns based on exclude and include values
    if exclude is not None:
        columns = (c for c in columns if c not in exclude)
    elif include is not None:
        columns = (c for c in columns if c in include)
    # create a dictionary mapping column name to value
    result = dict((col, getattr(instance, col)) for col in columns
                  if not (col.startswith('__') or col in COLUMN_BLACKLIST))
    # add any included methods
    if include_methods is not None:
        result.update(dict((method, getattr(instance, method)())
                           for method in include_methods
                           if not '.' in method))
    # Check for objects in the dictionary that may not be serializable by
    # default. Convert datetime objects to ISO 8601 format, convert UUID
    # objects to hexadecimal strings, etc.
    for key, value in result.items():
        if isinstance(value, (datetime.date, datetime.time)):
            result[key] = value.isoformat()
        elif isinstance(value, uuid.UUID):
            result[key] = str(value)
        elif isinstance(value, WKBElement):
            shape = to_shape(value)
            result[key] = to_mapping(shape)
        elif key not in column_attrs and is_mapped_class(type(value)):
            result[key] = to_dict(value)
    # recursively call _to_dict on each of the `deep` relations
    deep = deep or {}
    for relation, rdeep in deep.items():
        # Get the related value so we can see if it is None, a list, a query
        # (as specified by a dynamic relationship loader), or an actual
        # instance of a model.
        relatedvalue = getattr(instance, relation)
        if relatedvalue is None:
            result[relation] = None
            continue
        # Determine the included and excluded fields for the related model.
        newexclude = None
        newinclude = None
        if exclude_relations is not None and relation in exclude_relations:
            newexclude = exclude_relations[relation]
        elif (include_relations is not None and
              relation in include_relations):
            newinclude = include_relations[relation]
        # Determine the included methods for the related model.
        newmethods = None
        if include_methods is not None:
            newmethods = [method.split('.', 1)[1] for method in include_methods
                          if method.split('.', 1)[0] == relation]
        if is_like_list(instance, relation):
            result[relation] = [to_dict(inst, rdeep, exclude=newexclude,
                                        include=newinclude,
                                        include_methods=newmethods)
                                for inst in relatedvalue]
            continue
        # If the related value is dynamically loaded, resolve the query to get
        # the single instance.
        if isinstance(relatedvalue, Query):
            relatedvalue = relatedvalue.one()
        result[relation] = to_dict(relatedvalue, rdeep, exclude=newexclude,
                                   include=newinclude,
                                   include_methods=newmethods)
    return result