desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Generator that yields EasyInstanceFields for each field in this
EasyInstance\'s model.'
| def fields(self):
| for f in (self.model.model._meta.fields + self.model.model._meta.many_to_many):
(yield EasyInstanceField(self.model, self, f))
|
'Generator that yields dictionaries of all models that have this
EasyInstance\'s model as a ForeignKey or ManyToManyField, along with
lists of related objects.'
| def related_objects(self):
| for rel_object in (self.model.model._meta.get_all_related_objects() + self.model.model._meta.get_all_related_many_to_many_objects()):
if (rel_object.model not in self.model.model_list):
continue
em = EasyModel(self.model.site, rel_object.model)
(yield {'model': em, 'related_field... |
'Returns a list of values for this field for this instance. It\'s a list
so we can accomodate many-to-many fields.'
| def values(self):
| if self.field.rel:
if isinstance(self.field.rel, models.ManyToOneRel):
objs = getattr(self.instance.instance, self.field.name)
elif isinstance(self.field.rel, models.ManyToManyRel):
return list(getattr(self.instance.instance, self.field.name).all())
elif self.field.choice... |
'Returns a list of (value, URL) tuples.'
| def urls(self):
| plugin_urls = []
for (plugin_name, plugin) in self.model.model_databrowse().plugins.items():
urls = plugin.urls(plugin_name, self)
if (urls is not None):
values = self.values()
return zip(self.values(), urls)
if self.field.rel:
m = EasyModel(self.model.site, s... |
'Given an EasyInstanceField object, returns a list of URLs for this
plugin\'s views of this object. These URLs should be absolute.
Returns None if the EasyInstanceField object doesn\'t get a
list of plugin-specific URLs.'
| def urls(self, plugin_name, easy_instance_field):
| return None
|
'Returns a snippet of HTML to include on the model index page.'
| def model_index_html(self, request, model, site):
| return ''
|
'Handles main URL routing for a plugin\'s model-specific pages.'
| def model_view(self, request, model_databrowse, url):
| raise NotImplementedError
|
'Handles main URL routing for the databrowse app.
`url` is the remainder of the URL -- e.g. \'objects/3\'.'
| def root(self, request, url):
| if (url is None):
return self.main_view(request)
try:
(plugin_name, rest_of_url) = url.split('/', 1)
except ValueError:
(plugin_name, rest_of_url) = (url, None)
try:
plugin = self.plugins[plugin_name]
except KeyError:
raise http.Http404('A plugin with ... |
'Registers the given model(s) with the given databrowse site.
The model(s) should be Model classes, not instances.
If a databrowse class isn\'t given, it will use DefaultModelDatabrowse
(the default databrowse options).
If a model is already registered, this will raise AlreadyRegistered.'
| def register(self, model_or_iterable, databrowse_class=None, **options):
| databrowse_class = (databrowse_class or DefaultModelDatabrowse)
if issubclass(model_or_iterable, models.Model):
model_or_iterable = [model_or_iterable]
for model in model_or_iterable:
if (model in self.registry):
raise AlreadyRegistered(('The model %s is already re... |
'Unregisters the given model(s).
If a model isn\'t already registered, this will raise NotRegistered.'
| def unregister(self, model_or_iterable):
| if issubclass(model_or_iterable, models.Model):
model_or_iterable = [model_or_iterable]
for model in model_or_iterable:
if (model not in self.registry):
raise NotRegistered(('The model %s is not registered' % model.__name__))
del self.registry[model]
|
'Handles main URL routing for the databrowse app.
`url` is the remainder of the URL -- e.g. \'comments/comment/\'.'
| def root(self, request, url):
| self.root_url = request.path[:(len(request.path) - len(url))]
url = url.rstrip('/')
if (url == ''):
return self.index(request)
elif ('/' in url):
return self.model_page(request, *url.split('/', 2))
raise http.Http404('The requested databrowse page does not exist.')
|
'Handles the model-specific functionality of the databrowse site, delegating
to the appropriate ModelDatabrowse class.'
| def model_page(self, request, app_label, model_name, rest_of_url=None):
| model = models.get_model(app_label, model_name)
if (model is None):
raise http.Http404(('App %r, model %r, not found.' % (app_label, model_name)))
try:
databrowse_class = self.registry[model]
except KeyError:
raise http.Http404('This model exists but ha... |
'Helper function that returns a dictionary of all DateFields or
DateTimeFields in the given model. If self.field_names is set, it takes
take that into account when building the dictionary.'
| def field_dict(self, model):
| if (self.field_names is None):
return dict([(f.name, f) for f in model._meta.fields if isinstance(f, models.DateField)])
else:
return dict([(f.name, f) for f in model._meta.fields if (isinstance(f, models.DateField) and (f.name in self.field_names))])
|
'Helper function that returns a dictionary of all fields in the given
model. If self.field_filter is set, it only includes the fields that
match the filter.'
| def field_dict(self, model):
| if self.field_filter:
return dict([(f.name, f) for f in model._meta.fields if self.field_filter(f)])
else:
return dict([(f.name, f) for f in model._meta.fields if ((not f.rel) and (not f.primary_key) and (not f.unique) and (not isinstance(f, (models.AutoField, models.TextField))))])
|
'Proxy initializes on the given Geometry class (not an instance) and
the GeometryField.'
| def __init__(self, klass, field):
| self._field = field
self._klass = klass
|
'This accessor retrieves the geometry, initializing it using the geometry
class specified during initialization and the HEXEWKB value of the field.
Currently, only GEOS or OGR geometries are supported.'
| def __get__(self, obj, type=None):
| if (obj is None):
return self
geom_value = obj.__dict__[self._field.attname]
if isinstance(geom_value, self._klass):
geom = geom_value
elif ((geom_value is None) or (geom_value == '')):
geom = None
else:
geom = self._klass(geom_value)
setattr(obj, self._field.... |
'This accessor sets the proxied geometry with the geometry class
specified during initialization. Values of None, HEXEWKB, or WKT may
be used to set the geometry as well.'
| def __set__(self, obj, value):
| gtype = self._field.geom_type
if (isinstance(value, self._klass) and ((str(value.geom_type).upper() == gtype) or (gtype == 'GEOMETRY'))):
if (value.srid is None):
value.srid = self._field.srid
elif ((value is None) or isinstance(value, (basestring, buffer))):
pass
else:
... |
'The initialization function for geometry fields. Takes the following
as keyword arguments:
srid:
The spatial reference system identifier, an OGC standard.
Defaults to 4326 (WGS84).
spatial_index:
Indicates whether to create a spatial index. Defaults to True.
Set this instead of \'db_index\' for geographic fields sin... | def __init__(self, verbose_name=None, srid=4326, spatial_index=True, dim=2, geography=False, **kwargs):
| self.spatial_index = spatial_index
self.srid = srid
self.dim = dim
kwargs['verbose_name'] = verbose_name
self.geography = geography
self._extent = kwargs.pop('extent', ((-180.0), (-90.0), 180.0, 90.0))
self._tolerance = kwargs.pop('tolerance', 0.05)
super(GeometryField, self).__init__(**... |
'Returns true if this field\'s SRID corresponds with a coordinate
system that uses non-projected units (e.g., latitude/longitude).'
| def geodetic(self, connection):
| return (self.units_name(connection) in self.geodetic_units)
|
'Returns a distance number in units of the field. For example, if
`D(km=1)` was passed in and the units of the field were in meters,
then 1000 would be returned.'
| def get_distance(self, value, lookup_type, connection):
| return connection.ops.get_distance(self, value, lookup_type)
|
'Spatial lookup values are either a parameter that is (or may be
converted to) a geometry, or a sequence of lookup values that
begins with a geometry. This routine will setup the geometry
value properly, and preserve any other lookup parameters before
returning to the caller.'
| def get_prep_value(self, value):
| if isinstance(value, SQLEvaluator):
return value
elif isinstance(value, (tuple, list)):
geom = value[0]
seq_value = True
else:
geom = value
seq_value = False
if isinstance(geom, Geometry):
pass
elif (isinstance(geom, basestring) or hasattr(geom, '__geo... |
'Returns the default SRID for the given geometry, taking into account
the SRID set for the field. For example, if the input geometry
has no SRID, then that of the field will be returned.'
| def get_srid(self, geom):
| gsrid = geom.srid
if ((gsrid is None) or (self.srid == (-1)) or ((gsrid == (-1)) and (self.srid != (-1)))):
return self.srid
else:
return gsrid
|
'Prepare for the database lookup, and return any spatial parameters
necessary for the query. This includes wrapping any geometry
parameters with a backend-specific adapter and formatting any distance
parameters into the correct units for the coordinate system of the
field.'
| def get_db_prep_lookup(self, lookup_type, value, connection, prepared=False):
| if (lookup_type in connection.ops.gis_terms):
if (lookup_type == 'isnull'):
return []
if isinstance(value, (tuple, list)):
params = [connection.ops.Adapter(value[0])]
if (lookup_type in connection.ops.distance_functions):
params += self.get_distanc... |
'Prepares the value for saving in the database.'
| def get_db_prep_save(self, value, connection):
| if (value is None):
return None
else:
return connection.ops.Adapter(self.get_prep_value(value))
|
'Returns the placeholder for the geometry column for the
given value.'
| def get_placeholder(self, value, connection):
| return connection.ops.get_geom_placeholder(self, value)
|
'Returns the area of the geographic field in an `area` attribute on
each element of this GeoQuerySet.'
| def area(self, tolerance=0.05, **kwargs):
| (procedure_args, geo_field) = self._spatial_setup('area', field_name=kwargs.get('field_name', None))
s = {'procedure_args': procedure_args, 'geo_field': geo_field, 'setup': False}
connection = connections[self.db]
backend = connection.ops
if backend.oracle:
s['procedure_fmt'] = '%(geo_col)s,... |
'Returns the centroid of the geographic field in a `centroid`
attribute on each element of this GeoQuerySet.'
| def centroid(self, **kwargs):
| return self._geom_attribute('centroid', **kwargs)
|
'Performs an aggregate collect operation on the given geometry field.
This is analagous to a union operation, but much faster because
boundaries are not dissolved.'
| def collect(self, **kwargs):
| return self._spatial_aggregate(aggregates.Collect, **kwargs)
|
'Returns the spatial difference of the geographic field in a `difference`
attribute on each element of this GeoQuerySet.'
| def difference(self, geom, **kwargs):
| return self._geomset_attribute('difference', geom, **kwargs)
|
'Returns the distance from the given geographic field name to the
given geometry in a `distance` attribute on each element of the
GeoQuerySet.
Keyword Arguments:
`spheroid` => If the geometry field is geodetic and PostGIS is
the spatial database, then the more accurate
spheroid calculation will be used instead of the
... | def distance(self, geom, **kwargs):
| return self._distance_attribute('distance', geom, **kwargs)
|
'Returns a Geometry representing the bounding box of the
Geometry field in an `envelope` attribute on each element of
the GeoQuerySet.'
| def envelope(self, **kwargs):
| return self._geom_attribute('envelope', **kwargs)
|
'Returns the extent (aggregate) of the features in the GeoQuerySet. The
extent will be returned as a 4-tuple, consisting of (xmin, ymin, xmax, ymax).'
| def extent(self, **kwargs):
| return self._spatial_aggregate(aggregates.Extent, **kwargs)
|
'Returns the aggregate extent, in 3D, of the features in the
GeoQuerySet. It is returned as a 6-tuple, comprising:
(xmin, ymin, zmin, xmax, ymax, zmax).'
| def extent3d(self, **kwargs):
| return self._spatial_aggregate(aggregates.Extent3D, **kwargs)
|
'Returns a modified version of the Polygon/MultiPolygon in which
all of the vertices follow the Right-Hand-Rule. By default,
this is attached as the `force_rhr` attribute on each element
of the GeoQuerySet.'
| def force_rhr(self, **kwargs):
| return self._geom_attribute('force_rhr', **kwargs)
|
'Returns a GeoJSON representation of the geomtry field in a `geojson`
attribute on each element of the GeoQuerySet.
The `crs` and `bbox` keywords may be set to True if the users wants
the coordinate reference system and the bounding box to be included
in the GeoJSON representation of the geometry.'
| def geojson(self, precision=8, crs=False, bbox=False, **kwargs):
| backend = connections[self.db].ops
if (not backend.geojson):
raise NotImplementedError('Only PostGIS 1.3.4+ supports GeoJSON serialization.')
if (not isinstance(precision, (int, long))):
raise TypeError('Precision keyword must be set with an integer.')
... |
'Returns a GeoHash representation of the given field in a `geohash`
attribute on each element of the GeoQuerySet.
The `precision` keyword may be used to custom the number of
_characters_ used in the output GeoHash, the default is 20.'
| def geohash(self, precision=20, **kwargs):
| s = {'desc': 'GeoHash', 'procedure_args': {'precision': precision}, 'procedure_fmt': '%(geo_col)s,%(precision)s'}
return self._spatial_attribute('geohash', s, **kwargs)
|
'Returns GML representation of the given field in a `gml` attribute
on each element of the GeoQuerySet.'
| def gml(self, precision=8, version=2, **kwargs):
| backend = connections[self.db].ops
s = {'desc': 'GML', 'procedure_args': {'precision': precision}}
if backend.postgis:
if (backend.spatial_version > (1, 3, 1)):
procedure_fmt = '%(version)s,%(geo_col)s,%(precision)s'
else:
procedure_fmt = '%(geo_col)s,%(precision)s,%(... |
'Returns the spatial intersection of the Geometry field in
an `intersection` attribute on each element of this
GeoQuerySet.'
| def intersection(self, geom, **kwargs):
| return self._geomset_attribute('intersection', geom, **kwargs)
|
'Returns KML representation of the geometry field in a `kml`
attribute on each element of this GeoQuerySet.'
| def kml(self, **kwargs):
| s = {'desc': 'KML', 'procedure_fmt': '%(geo_col)s,%(precision)s', 'procedure_args': {'precision': kwargs.pop('precision', 8)}}
return self._spatial_attribute('kml', s, **kwargs)
|
'Returns the length of the geometry field as a `Distance` object
stored in a `length` attribute on each element of this GeoQuerySet.'
| def length(self, **kwargs):
| return self._distance_attribute('length', None, **kwargs)
|
'Creates a linestring from all of the PointField geometries in the
this GeoQuerySet and returns it. This is a spatial aggregate
method, and thus returns a geometry rather than a GeoQuerySet.'
| def make_line(self, **kwargs):
| return self._spatial_aggregate(aggregates.MakeLine, geo_field_type=PointField, **kwargs)
|
'Returns the memory size (number of bytes) that the geometry field takes
in a `mem_size` attribute on each element of this GeoQuerySet.'
| def mem_size(self, **kwargs):
| return self._spatial_attribute('mem_size', {}, **kwargs)
|
'Returns the number of geometries if the field is a
GeometryCollection or Multi* Field in a `num_geom`
attribute on each element of this GeoQuerySet; otherwise
the sets with None.'
| def num_geom(self, **kwargs):
| return self._spatial_attribute('num_geom', {}, **kwargs)
|
'Returns the number of points in the first linestring in the
Geometry field in a `num_points` attribute on each element of
this GeoQuerySet; otherwise sets with None.'
| def num_points(self, **kwargs):
| return self._spatial_attribute('num_points', {}, **kwargs)
|
'Returns the perimeter of the geometry field as a `Distance` object
stored in a `perimeter` attribute on each element of this GeoQuerySet.'
| def perimeter(self, **kwargs):
| return self._distance_attribute('perimeter', None, **kwargs)
|
'Returns a Point geometry guaranteed to lie on the surface of the
Geometry field in a `point_on_surface` attribute on each element
of this GeoQuerySet; otherwise sets with None.'
| def point_on_surface(self, **kwargs):
| return self._geom_attribute('point_on_surface', **kwargs)
|
'Reverses the coordinate order of the geometry, and attaches as a
`reverse` attribute on each element of this GeoQuerySet.'
| def reverse_geom(self, **kwargs):
| s = {'select_field': GeomField()}
kwargs.setdefault('model_att', 'reverse_geom')
if connections[self.db].ops.oracle:
s['geo_field_type'] = LineStringField
return self._spatial_attribute('reverse', s, **kwargs)
|
'Scales the geometry to a new size by multiplying the ordinates
with the given x,y,z scale factors.'
| def scale(self, x, y, z=0.0, **kwargs):
| if connections[self.db].ops.spatialite:
if (z != 0.0):
raise NotImplementedError('SpatiaLite does not support 3D scaling.')
s = {'procedure_fmt': '%(geo_col)s,%(x)s,%(y)s', 'procedure_args': {'x': x, 'y': y}, 'select_field': GeomField()}
else:
s = {'procedure_f... |
'Snap all points of the input geometry to the grid. How the
geometry is snapped to the grid depends on how many arguments
were given:
- 1 argument : A single size to snap both the X and Y grids to.
- 2 arguments: X and Y sizes to snap the grid to.
- 4 arguments: X, Y sizes and the X, Y origins.'
| def snap_to_grid(self, *args, **kwargs):
| if (False in [isinstance(arg, (float, int, long)) for arg in args]):
raise TypeError('Size argument(s) for the grid must be a float or integer values.')
nargs = len(args)
if (nargs == 1):
size = args[0]
procedure_fmt = '%(geo_col)s,%(size)s'
p... |
'Returns SVG representation of the geographic field in a `svg`
attribute on each element of this GeoQuerySet.
Keyword Arguments:
`relative` => If set to True, this will evaluate the path in
terms of relative moves (rather than absolute).
`precision` => May be used to set the maximum number of decimal
digits used in ou... | def svg(self, relative=False, precision=8, **kwargs):
| relative = int(bool(relative))
if (not isinstance(precision, (int, long))):
raise TypeError('SVG precision keyword argument must be an integer.')
s = {'desc': 'SVG', 'procedure_fmt': '%(geo_col)s,%(rel)s,%(precision)s', 'procedure_args': {'rel': relative, 'precision': precision}... |
'Returns the symmetric difference of the geographic field in a
`sym_difference` attribute on each element of this GeoQuerySet.'
| def sym_difference(self, geom, **kwargs):
| return self._geomset_attribute('sym_difference', geom, **kwargs)
|
'Translates the geometry to a new location using the given numeric
parameters as offsets.'
| def translate(self, x, y, z=0.0, **kwargs):
| if connections[self.db].ops.spatialite:
if (z != 0.0):
raise NotImplementedError('SpatiaLite does not support 3D translation.')
s = {'procedure_fmt': '%(geo_col)s,%(x)s,%(y)s', 'procedure_args': {'x': x, 'y': y}, 'select_field': GeomField()}
else:
s = {'procedu... |
'Transforms the given geometry field to the given SRID. If no SRID is
provided, the transformation will default to using 4326 (WGS84).'
| def transform(self, srid=4326, **kwargs):
| if (not isinstance(srid, (int, long))):
raise TypeError('An integer SRID must be provided.')
field_name = kwargs.get('field_name', None)
(tmp, geo_field) = self._spatial_setup('transform', field_name=field_name)
field_col = self._geocol_select(geo_field, field_name)
geo_col = ... |
'Returns the union of the geographic field with the given
Geometry in a `union` attribute on each element of this GeoQuerySet.'
| def union(self, geom, **kwargs):
| return self._geomset_attribute('union', geom, **kwargs)
|
'Performs an aggregate union on the given geometry field. Returns
None if the GeoQuerySet is empty. The `tolerance` keyword is for
Oracle backends only.'
| def unionagg(self, **kwargs):
| return self._spatial_aggregate(aggregates.Union, **kwargs)
|
'Performs set up for executing the spatial function.'
| def _spatial_setup(self, att, desc=None, field_name=None, geo_field_type=None):
| connection = connections[self.db]
func = getattr(connection.ops, att, False)
if (desc is None):
desc = att
if (not func):
raise NotImplementedError(('%s stored procedure not available on the %s backend.' % (desc, connection.ops.name)))
procedure_args = {'funct... |
'DRY routine for calling aggregate spatial stored procedures and
returning their result to the caller of the function.'
| def _spatial_aggregate(self, aggregate, field_name=None, geo_field_type=None, tolerance=0.05):
| geo_field = self.query._geo_field(field_name)
if (not geo_field):
raise TypeError(('%s aggregate only available on GeometryFields.' % aggregate.name))
if ((not (geo_field_type is None)) and (not isinstance(geo_field, geo_field_type))):
raise TypeError(('%s aggregate may ... |
'DRY routine for calling a spatial stored procedure on a geometry column
and attaching its output as an attribute of the model.
Arguments:
att:
The name of the spatial attribute that holds the spatial
SQL function to call.
settings:
Dictonary of internal settings to customize for the spatial procedure.
Public Keyword A... | def _spatial_attribute(self, att, settings, field_name=None, model_att=None):
| settings.setdefault('desc', None)
settings.setdefault('geom_args', ())
settings.setdefault('geom_field', None)
settings.setdefault('procedure_args', {})
settings.setdefault('procedure_fmt', '%(geo_col)s')
settings.setdefault('select_params', [])
connection = connections[self.db]
backend ... |
'DRY routine for GeoQuerySet distance attribute routines.'
| def _distance_attribute(self, func, geom=None, tolerance=0.05, spheroid=False, **kwargs):
| (procedure_args, geo_field) = self._spatial_setup(func, field_name=kwargs.get('field_name', None))
connection = connections[self.db]
geodetic = geo_field.geodetic(connection)
geography = geo_field.geography
if geodetic:
dist_att = 'm'
else:
dist_att = Distance.unit_attname(geo_fi... |
'DRY routine for setting up a GeoQuerySet method that attaches a
Geometry attribute (e.g., `centroid`, `point_on_surface`).'
| def _geom_attribute(self, func, tolerance=0.05, **kwargs):
| s = {'select_field': GeomField()}
if connections[self.db].ops.oracle:
s['procedure_fmt'] = '%(geo_col)s,%(tolerance)s'
s['procedure_args'] = {'tolerance': tolerance}
return self._spatial_attribute(func, s, **kwargs)
|
'DRY routine for setting up a GeoQuerySet method that attaches a
Geometry attribute and takes a Geoemtry parameter. This is used
for geometry set-like operations (e.g., intersection, difference,
union, sym_difference).'
| def _geomset_attribute(self, func, geom, tolerance=0.05, **kwargs):
| s = {'geom_args': ('geom',), 'select_field': GeomField(), 'procedure_fmt': '%(geo_col)s,%(geom)s', 'procedure_args': {'geom': geom}}
if connections[self.db].ops.oracle:
s['procedure_fmt'] += ',%(tolerance)s'
s['procedure_args']['tolerance'] = tolerance
return self._spatial_attribute(func, s,... |
'Helper routine for constructing the SQL to select the geographic
column. Takes into account if the geographic field is in a
ForeignKey relation to the current model.'
| def _geocol_select(self, geo_field, field_name):
| opts = self.model._meta
if (not (geo_field in opts.fields)):
self.query.add_select_related([field_name])
compiler = self.query.get_compiler(self.db)
compiler.pre_sql_setup()
(rel_table, rel_col) = self.query.related_select_cols[self.query.related_select_fields.index(geo_field)]
... |
'Utility for checking the given lookup with the given model options.
The lookup is a string either specifying the geographic field, e.g.
\'point, \'the_geom\', or a related lookup on a geographic field like
\'address__point\'.
If a GeometryField exists according to the given lookup on the model
options, it will be retu... | @classmethod
def _check_geo_field(cls, opts, lookup):
| field_list = lookup.split(LOOKUP_SEP)
field_list.reverse()
fld_name = field_list.pop()
try:
geo_fld = opts.get_field(fld_name)
while len(field_list):
opts = geo_fld.rel.to._meta
geo_fld = opts.get_field(field_list.pop())
except (FieldDoesNotExist, AttributeErr... |
'Overloaded method so OracleQuery.convert_values doesn\'t balk.'
| def get_internal_type(self):
| return None
|
'Using the same routines that Oracle does we can convert our
extra selection objects into Geometry and Distance objects.
TODO: Make converted objects \'lazy\' for less overhead.'
| def convert_values(self, value, field, connection):
| if connection.ops.oracle:
value = super(GeoQuery, self).convert_values(value, (field or GeomField()), connection)
if (value is None):
pass
elif isinstance(field, DistanceField):
value = Distance(**{field.distance_att: value})
elif isinstance(field, AreaField):
value = Are... |
'Overridden from GeoQuery\'s normalize to handle the conversion of
GeoAggregate objects.'
| def resolve_aggregate(self, value, aggregate, connection):
| if isinstance(aggregate, self.aggregates_module.GeoAggregate):
if aggregate.is_extent:
if (aggregate.is_extent == '3D'):
return connection.ops.convert_extent3d(value)
else:
return connection.ops.convert_extent(value)
else:
return co... |
'Returns the first Geometry field encountered; or specified via the
`field_name` keyword. The `field_name` may be a string specifying
the geometry field on this GeoQuery\'s model, or a lookup string
to a geometry field via a ForeignKey relation.'
| def _geo_field(self, field_name=None):
| if (field_name is None):
for fld in self.model._meta.fields:
if isinstance(fld, GeometryField):
return fld
return False
else:
return GeoWhereNode._check_geo_field(self.model._meta, field_name)
|
'Return the aggregate, rendered as SQL.'
| def as_sql(self, qn, connection):
| if connection.ops.oracle:
self.extra['tolerance'] = self.tolerance
if hasattr(self.col, 'as_sql'):
field_name = self.col.as_sql(qn, connection)
elif isinstance(self.col, (list, tuple)):
field_name = '.'.join([qn(c) for c in self.col])
else:
field_name = self.col
(sql_... |
'Return the list of columns to use in the select statement. If no
columns have been specified, returns all columns relating to fields in
the model.
If \'with_aliases\' is true, any column names that are duplicated
(without the table names) are given unique aliases. This is needed in
some cases to avoid ambiguitity with... | def get_columns(self, with_aliases=False):
| qn = self.quote_name_unless_alias
qn2 = self.connection.ops.quote_name
result = [('(%s) AS %s' % ((self.get_extra_select_format(alias) % col[0]), qn2(alias))) for (alias, col) in self.query.extra_select.iteritems()]
aliases = set(self.query.extra_select.keys())
if with_aliases:
col_ali... |
'Computes the default columns for selecting every field in the base
model. Will sometimes be called to pull in related models (e.g. via
select_related), in which case "opts" and "start_alias" will be given
to provide a starting point for the traversal.
Returns a list of strings, quoted appropriately for use in SQL
dire... | def get_default_columns(self, with_aliases=False, col_aliases=None, start_alias=None, opts=None, as_pairs=False, local_only=False):
| result = []
if (opts is None):
opts = self.query.model._meta
aliases = set()
only_load = self.deferred_to_columns()
proxied_model = get_proxied_model(opts)
if start_alias:
seen = {None: start_alias}
for (field, model) in opts.get_fields_with_model():
if (local_only an... |
'This routine is necessary so that distances and geometries returned
from extra selection SQL get resolved appropriately into Python
objects.'
| def resolve_columns(self, row, fields=()):
| values = []
aliases = self.query.extra_select.keys()
if self.query.aggregates:
aliases.extend([None for i in xrange(len(self.query.aggregates))])
rn_offset = 0
if self.connection.ops.oracle:
if ((self.query.high_mark is not None) or self.query.low_mark):
rn_offset = 1
... |
'Returns the SELECT SQL string for the given field. Figures out
if any custom selection SQL is needed for the column The `alias`
keyword may be used to manually specify the database table where
the column exists, if not in the model associated with this
`GeoQuery`. Similarly, `column` may be used to specify the exac... | def get_field_select(self, field, alias=None, column=None):
| sel_fmt = self.get_select_format(field)
if (field in self.query.custom_select):
field_sel = (sel_fmt % self.query.custom_select[field])
else:
field_sel = (sel_fmt % self._field_column(field, alias, column))
return field_sel
|
'Returns the selection format string, depending on the requirements
of the spatial backend. For example, Oracle and MySQL require custom
selection formats in order to retrieve geometries in OGC WKT. For all
other fields a simple \'%s\' format string is returned.'
| def get_select_format(self, fld):
| if (self.connection.ops.select and hasattr(fld, 'geom_type')):
sel_fmt = self.connection.ops.select
if (self.query.transformed_srid and (self.connection.ops.oracle or self.connection.ops.spatialite)):
sel_fmt = ("'SRID=%d;'||%s" % (self.query.transformed_srid, sel_fmt))
else:
... |
'Helper function that returns the database column for the given field.
The table and column are returned (quoted) in the proper format, e.g.,
`"geoapp_city"."point"`. If `table_alias` is not specified, the
database table associated with the model of this `GeoQuery` will be
used. If `column` is specified, it will be u... | def _field_column(self, field, table_alias=None, column=None):
| if (table_alias is None):
table_alias = self.query.model._meta.db_table
return ('%s.%s' % (self.quote_name_unless_alias(table_alias), self.connection.ops.quote_name((column or field.column))))
|
'Returns the geometry database type for Oracle. Unlike other spatial
backends, no stored procedure is necessary and it\'s the same for all
geometry types.'
| def geo_db_type(self, f):
| return 'MDSYS.SDO_GEOMETRY'
|
'Returns the distance parameters given the value and the lookup type.
On Oracle, geometry columns with a geodetic coordinate system behave
implicitly like a geography column, and thus meters will be used as
the distance parameter on them.'
| def get_distance(self, f, value, lookup_type):
| if (not value):
return []
value = value[0]
if isinstance(value, Distance):
if f.geodetic(self.connection):
dist_param = value.m
else:
dist_param = getattr(value, Distance.unit_attname(f.units_name(self.connection)))
else:
dist_param = value
if ... |
'Provides a proper substitution value for Geometries that are not in the
SRID of the field. Specifically, this routine will substitute in the
SDO_CS.TRANSFORM() function call.'
| def get_geom_placeholder(self, f, value):
| if (value is None):
return 'NULL'
def transform_value(val, srid):
return (val.srid != srid)
if hasattr(value, 'expression'):
if transform_value(value, f.srid):
placeholder = ('%s(%%s, %s)' % (self.transform, f.srid))
else:
placeholder = '%s'
... |
'Returns the SQL WHERE clause for use in Oracle spatial SQL construction.'
| def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn):
| (alias, col, db_type) = lvalue
geo_col = ('%s.%s' % (qn(alias), qn(col)))
lookup_info = self.geometry_functions.get(lookup_type, False)
if lookup_info:
if isinstance(lookup_info, tuple):
(sdo_op, arg_type) = lookup_info
geom = value[0]
if (not isinstance(value... |
'Returns the spatial aggregate SQL template and function for the
given Aggregate instance.'
| def spatial_aggregate_sql(self, agg):
| agg_name = agg.__class__.__name__.lower()
if (agg_name == 'union'):
agg_name += 'agg'
if agg.is_extent:
sql_template = '%(function)s(%(field)s)'
else:
sql_template = '%(function)s(SDOAGGRTYPE(%(field)s,%(tolerance)s))'
sql_function = getattr(self, agg_name)
return ((self.... |
'Returns the name of the metadata column used to store the
the feature table name.'
| @classmethod
def table_name_col(cls):
| return 'table_name'
|
'Returns the name of the metadata column used to store the
the feature geometry column.'
| @classmethod
def geom_col_name(cls):
| return 'column_name'
|
'Return any spatial index creation SQL for the field.'
| def sql_indexes_for_field(self, model, f, style):
| from django.contrib.gis.db.models.fields import GeometryField
output = super(OracleCreation, self).sql_indexes_for_field(model, f, style)
if isinstance(f, GeometryField):
gqn = self.connection.ops.geo_quote_name
qn = self.connection.ops.quote_name
db_table = model._meta.db_table
... |
'Returns the database column type for the geometry field on
the spatial backend.'
| def geo_db_type(self, f):
| raise NotImplementedError
|
'Returns the distance parameters for the given geometry field,
lookup value, and lookup type.'
| def get_distance(self, f, value, lookup_type):
| raise NotImplementedError('Distance operations not available on this spatial backend.')
|
'Returns the placeholder for the given geometry field with the given
value. Depending on the spatial backend, the placeholder may contain a
stored procedure call to the transformation function of the spatial
backend.'
| def get_geom_placeholder(self, f, value):
| raise NotImplementedError
|
'Returns a GDAL SpatialReference object, if GDAL is installed.'
| @property
def srs(self):
| if gdal.HAS_GDAL:
if hasattr(self, '_srs'):
return self._srs.clone()
else:
try:
self._srs = gdal.SpatialReference(self.wkt)
return self.srs
except Exception as msg:
pass
try:
self._srs = g... |
'Returns a tuple of the ellipsoid parameters:
(semimajor axis, semiminor axis, and inverse flattening).'
| @property
def ellipsoid(self):
| if gdal.HAS_GDAL:
return self.srs.ellipsoid
else:
m = self.spheroid_regex.match(self.wkt)
if m:
return (float(m.group('major')), float(m.group('flattening')))
else:
return None
|
'Returns the projection name.'
| @property
def name(self):
| return self.srs.name
|
'Returns the spheroid name for this spatial reference.'
| @property
def spheroid(self):
| return self.srs['spheroid']
|
'Returns the datum for this spatial reference.'
| @property
def datum(self):
| return self.srs['datum']
|
'Is this Spatial Reference projected?'
| @property
def projected(self):
| if gdal.HAS_GDAL:
return self.srs.projected
else:
return self.wkt.startswith('PROJCS')
|
'Is this Spatial Reference local?'
| @property
def local(self):
| if gdal.HAS_GDAL:
return self.srs.local
else:
return self.wkt.startswith('LOCAL_CS')
|
'Is this Spatial Reference geographic?'
| @property
def geographic(self):
| if gdal.HAS_GDAL:
return self.srs.geographic
else:
return self.wkt.startswith('GEOGCS')
|
'Returns the linear units name.'
| @property
def linear_name(self):
| if gdal.HAS_GDAL:
return self.srs.linear_name
elif self.geographic:
return None
else:
m = self.units_regex.match(self.wkt)
return m.group('unit_name')
|
'Returns the linear units.'
| @property
def linear_units(self):
| if gdal.HAS_GDAL:
return self.srs.linear_units
elif self.geographic:
return None
else:
m = self.units_regex.match(self.wkt)
return m.group('unit')
|
'Returns the name of the angular units.'
| @property
def angular_name(self):
| if gdal.HAS_GDAL:
return self.srs.angular_name
elif self.projected:
return None
else:
m = self.units_regex.match(self.wkt)
return m.group('unit_name')
|
'Returns the angular units.'
| @property
def angular_units(self):
| if gdal.HAS_GDAL:
return self.srs.angular_units
elif self.projected:
return None
else:
m = self.units_regex.match(self.wkt)
return m.group('unit')
|
'Returns a tuple of the units and the name.'
| @property
def units(self):
| if (self.projected or self.local):
return (self.linear_units, self.linear_name)
elif self.geographic:
return (self.angular_units, self.angular_name)
else:
return (None, None)
|
'Class method used by GeometryField on initialization to
retrive the units on the given WKT, without having to use
any of the database fields.'
| @classmethod
def get_units(cls, wkt):
| if gdal.HAS_GDAL:
return gdal.SpatialReference(wkt).units
else:
m = cls.units_regex.match(wkt)
return (m.group('unit'), m.group('unit_name'))
|
'Class method used by GeometryField on initialization to
retrieve the `SPHEROID[..]` parameters from the given WKT.'
| @classmethod
def get_spheroid(cls, wkt, string=True):
| if gdal.HAS_GDAL:
srs = gdal.SpatialReference(wkt)
sphere_params = srs.ellipsoid
sphere_name = srs['spheroid']
else:
m = cls.spheroid_regex.match(wkt)
if m:
sphere_params = (float(m.group('major')), float(m.group('flattening')))
sphere_name = m.gro... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.