def to_data(x) -> Data: """Convert a value to a Data. If the argument is a Data object, return it.""" if is_data_object(x): return x if is_dict(x): return gws.Data(x) return gws.Data()
def props_for(self, user): return gws.Data( rules=[ gws.Data( name=r.name, editable=r.editable, editor=r.editor, title=r.title, type=r.type, ) for r in self.rules ], geometryType=self.geometry_type, crs=self.geometry_crs, )
def test_update_stored_session(auth): user = auth.authenticate(auth.methods[0], gws.Data(login='******')) sess1 = auth.new_stored_session('test', auth.methods[0], user) sess1.set('foo', 'bar') auth.save_stored_session(sess1) sess2 = auth.find_stored_session(sess1.uid) assert sess2.get('foo') == 'bar'
def _read_object(self, val, spec): val = _ensure(val, dict) if not self.with_strict_mode: val = {k.lower(): v for k, v in val.items()} props = spec['props'] res = {} for prop_name, prop_key in props.items(): prop_val = val.get( prop_name if self.with_strict_mode else prop_name.lower()) self.push([prop_val, prop_name]) res[prop_name] = self._read_property(prop_val, prop_key) self.pop() unknown = [] for k in val: if k not in props: if self.with_internal_objects: res[k] = val[k] elif self.with_strict_mode: unknown.append(k) if unknown: raise Error( 'ERR_UNKNOWN_PROP', f"unknown keys: {_comma(unknown)}, expected: {_comma(props)}", val) return gws.Data(res)
def _new_request(self, shape): self._prepare_request_table() features = self.alkis.db.select( gws.SqlSelectArgs({ 'shape': shape, 'table': self.alkis.db.configure_table( gws.Data(name=self.alkis.index_schema + '.' + _INDEX_TABLE_NAME, )) })) if not features: return None request_id = _rand_id() data = [] for f in features: d = { a.name: a.value for a in f.attributes if a.name in self._data_fields } d['request_id'] = request_id d['selection'] = shape.transformed_to(self.alkis.crs).ewkb_hex d['ts'] = gws.lib.date.now() data.append(d) with self.alkis.db.connect() as conn: for d in data: conn.insert_one(self.request_table_name, 'request_id', d) return request_id
def configure(self): # with reqSize=1 MP will request the same tile multiple times # reqSize=4 is more efficient, however, reqSize=1 yields the first tile faster # which is crucial when browsing non-cached low resoltions # so, let's use 1 as default, overridable in the config # # @TODO make MP cache network requests self.grid.reqSize = self.grid.reqSize or 1 self.url = self.var('url') p = self.var('service', default=gws.Data()) self.service = Service(crs=gws.gis.crs.get(p.crs) or gws.gis.crs.get3857(), origin=p.origin, tile_size=p.tileSize, extent=p.extent) if not self.service.extent: if self.service.crs.srid == gws.gis.crs.c3857: self.service.extent = gws.gis.crs.c3857_extent else: raise gws.Error( f'service extent required for crs {self.service.crs.srid!r}' )
def configure(self): self.project = self.get_closest('gws.base.project') self.metadata = self.configure_metadata() self.root_layer_uid = self.var('rootLayer') self.supported_crs = [gws.gis.crs.require(s) for s in self.var('supportedCrs', default=[])] self.update_sequence = self.var('updateSequence') self.with_inspire_meta = self.var('withInspireMeta') self.with_strict_params = self.var('withStrictParams') self.templates = gws.base.template.bundle.create( self.root, items=self.var('templates'), defaults=self.default_templates, parent=self) self.layer_options = [] for cfg in self.var('layerConfig', default=[]): lo = LayerOptions() apply = cfg.applyTo or gws.Data() lo.uids = set(apply.uids or []) lo.level = apply.level lo.pattern = apply.pattern lo.enabled = cfg.enabled lo.layer_name = cfg.layerName lo.feature_name = cfg.featureName self.layer_options.append(lo)
def props_for(self, user): return gws.Data( uid=self.full_uid, attributes=self.attributes, shape=self.shape, style=self.style or (self.layer.style if self.layer else None), elements=self.elements, layerUid=self.layer.uid if self.layer else None, )
def default_metadata(self): return gws.Data( inspireDegreeOfConformity='notEvaluated', inspireMandatoryKeyword='humanCatalogueViewer', inspireResourceType='service', inspireSpatialDataServiceType='discovery', isoScope='dataset', isoSpatialRepresentationType='vector', )
def default_metadata(self): return gws.Data( inspireDegreeOfConformity='notEvaluated', inspireMandatoryKeyword='infoMapAccessService', inspireResourceType='service', inspireSpatialDataServiceType='view', isoScope='dataset', isoSpatialRepresentationType='vector', )
def props_for(self, user): return gws.Data( dataModel=self.data_model, mapSize=self.map_size, pageSize=self.page_size, qualityLevels=self.quality_levels, title=self.title, uid=self.uid, )
def make_features(name, geom_type, columns, crs, xy, rows, cols, gap): features = [] sx, sy = xy for r in range(rows): for c in range(cols): uid = r * cols + (c + 1) atts = [] for k, v in columns.items(): val = '' if v == 'int': val = uid * 100 if v == 'float': val = uid * 200.0 if v in ('varchar', 'text'): val = f"{name}/{uid}" if v == 'date': val = datetime.datetime( 2019, 1, 1) + datetime.timedelta(days=uid - 1) atts.append(gws.Attribute(name=k, value=val)) x = sx + c * gap y = sy + r * gap geom = None if geom_type == 'point': geom = {'type': 'Point', 'coordinates': [x, y]} if geom_type == 'square': w = h = gap / 2 geom = { 'type': 'Polygon', 'coordinates': [[ [x, y], [x + w, y], [x + w, y + h], [x, y + h], [x, y], ]] } features.append( gws.gis.feature.from_props( gws.Data(uid=uid, attributes=atts, shape={ 'crs': crs, 'geometry': geom } if geom else None))) return features
def props_for(self, user): return gws.Data( abstract=self.values.abstract or '', attribution=self.values.attribution or '', dateCreated=self.values.dateCreated, dateUpdated=self.values.dateUpdated, keywords=self.values.keywords or [], language=self.values.language or '', title=self.values.title or '', )
def __init__(self, root: gws.IRoot, rec): self.root = root self.uid = rec['uid'] self.user = self._get_user(rec) self.worker = rec['worker'] self.payload = gws.Data( gws.lib.json2.from_string(rec.get('payload', ''))) self.state = rec['state'] self.error = rec['error']
def render(self, tri, notify=None): fn = self.compile() ctx = self.prepare_context(tri.context) if isinstance(ctx, dict): ctx = gws.Data(ctx) try: return fn(ctx) except Exception as exc: gws.log.exception() raise gws.Error(f'py error: {exc!r} path={self.path!r}') from exc
def create( root: gws.IRoot, items: t.List[core.Config], parent: gws.INode, shared=False, defaults: t.Optional[t.List[core.Config]] = None, ) -> Object: cfg = gws.Data( items=items, defaults=defaults or [], ) return root.create_object(Object, cfg, parent, shared)
def props_for(self, user): return gws.Data( crs=self.crs.epsg, crsDef=self.crs.proj4text, coordinatePrecision=self.coordinate_precision, extent=self.extent, center=self.center, initResolution=self.init_resolution, layers=self.layers, resolutions=self.resolutions, title=self.title, )
def props_for(self, user): ico = self.values.icon if ico and isinstance(ico, icon.ParsedIcon): ico = icon.to_data_url(ico) else: # NB if icon is not parsed, don't give it back ico = '' return gws.Data( values=gws.merge(self.values, icon=ico), name=self.name or '', selector=self.selector or '', )
def shape_to_element(shape: gws.IShape, precision=0, axis: gws.Axis = gws.AXIS_XY, crs_format: gws.CrsFormat = gws.CrsFormat.URN, with_ns='gml') -> gws.XmlElement: """Convert a Shape to a GML3 geometry element.""" geom: shapely.geometry.base.BaseGeometry = getattr(shape, 'geom') srs = shape.crs.to_string(crs_format) ns = (with_ns + ':') if with_ns else '' opts = gws.Data(precision=precision, axis=axis, ns=ns) return xml2.tag(*_tag(geom, opts), srsName=srs)
def props_for(self, user): app_api = self.root.application.api actions = self.api.actions_for( user, app_api) if self.api else app_api.actions_for(user) return gws.Data( actions=list(actions.values()), client=self.client or self.root.application.client, description=self.description, map=self.map, metadata=self.metadata, overviewMap=self.overview_map, printer=self.printer, title=self.title, uid=self.uid, )
def _load_gekos_data(self): recs = [] for source in self.var('sources'): options = gws.Data(crs=self.crs, url=source.url, params=source.params, position=self.var('position')) gr = request.GekosRequest(options, source.instance, cache_lifetime=0) rs = gr.run() gws.log.info(f'loaded {len(rs)} records from {source.instance!r}') recs.extend(rs) return recs
def test_stored_session_expiration(auth): user = auth.authenticate(auth.methods[0], gws.Data(login='******')) dead = auth.new_stored_session('test', auth.methods[0], user) live = auth.new_stored_session('test', auth.methods[0], user) time.sleep(1) auth.save_stored_session(live) time.sleep(1) auth.save_stored_session(live) time.sleep(1) dead2 = auth.find_stored_session(dead.uid) live2 = auth.find_stored_session(live.uid) assert dead2 is None assert live2.uid == live.uid
def open_session(self, auth, req): if self.secure and not req.is_secure: return login_pass = _parse_header(req) if not login_pass: return user = auth.authenticate( self, gws.Data(username=login_pass[0], password=login_pass[1])) if user: return t.cast(manager.Object, auth).new_session('http-basic', method=self, user=user) # if the header is provided, it has to be correct raise error.LoginNotFound()
def config_from_source_layers(source_layers: t.List[gws.SourceLayer]): min_scale = max_scale = None for sl in source_layers: # if one of the layers has no scale range, the whole group has no range if not sl.scale_range: return None min_scale = min(sl.scale_range[0], min_scale or 1e20) max_scale = max(sl.scale_range[1], max_scale or 0) zoom = {} if min_scale is not None: zoom['minScale'] = min_scale if max_scale is not None: zoom['maxScale'] = max_scale return gws.Data(zoom) if zoom else None
def parse_args(argv): args = [] kwargs = {} key = None for a in argv: if a.startswith('--'): key = camelize(a[2:]) kwargs[key] = True elif a.startswith('-'): key = camelize(a[1:]) kwargs[key] = True elif key: kwargs[key] = a key = None else: args.append(a) return args, gws.Data(kwargs)
def test_destroy_stored_session(auth): user = auth.authenticate(auth.methods[0], gws.Data(login='******')) sess1 = auth.new_stored_session('test', auth.methods[0], user) auth.destroy_stored_session(sess1) sess2 = auth.find_stored_session(sess1.uid) assert sess2 is None
def service_link(self): if self.project: return gws.Data(url=self.service_url_path(self.project), scheme='OGC:WCS', function='search')
def web_request(): user = test.root().find( klass='gws.ext.auth.provider.system.Object').users['system'] return gws.Data(user=user)
def props_for(self, user): return gws.Data( options=self.options, elements=self.elements)
def props_for(self, user): return gws.Data(tag=self.var('tag'))