def __check_gp(self): gp_keys = r.keys('fragments:*:gp') for gpk in gp_keys: stored_gp = GraphPattern(r.smembers(gpk)) mapping = stored_gp.mapping(self._graph_pattern) if mapping: return gpk.split(':')[1], mapping return None
def _load(self): super(FragmentSink, self)._load() self._fragment_id = self._dict_fields['fragment_id'] self._graph_pattern = GraphPattern(r.smembers('fragments:{}:gp'.format(self._fragment_id))) mapping = self._dict_fields.get('mapping', None) if mapping is not None: mapping = eval(mapping) self._dict_fields['mapping'] = mapping preferred_labels = self._dict_fields.get('preferred_labels', None) if preferred_labels is not None: preferred_labels = eval(preferred_labels) self._dict_fields['preferred_labels'] = preferred_labels try: del self._dict_fields['fragment_id'] except KeyError: pass
Copyright (C) 2015 Center for Open Middleware. #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# """ from sdh.curator.actions.core.utils import GraphPattern __author__ = 'Fernando Serena' gp1 = GraphPattern() gp1.add('?a scm:hasBranch ?b') gp2 = GraphPattern() gp2.add('?s a scm:Repository') gp2.add('?s scm:hasBranch ?b') gp2.add('?b doap:name ?n') mapping = gp2.mapping(gp1) print mapping
def __init__(self): super(FragmentSink, self).__init__() self._graph_pattern = GraphPattern() self._variables_dict = {} self._preferred_labels = [] self._fragment_id = None
class FragmentSink(DeliverySink): __metaclass__ = ABCMeta def __init__(self): super(FragmentSink, self).__init__() self._graph_pattern = GraphPattern() self._variables_dict = {} self._preferred_labels = [] self._fragment_id = None @staticmethod def _n3(action, elm): return elm.n3(action.request.pattern.namespace_manager) def _build_graph_pattern(self, action, v_labels=None): variables = set(action.request.pattern.subjects(RDF.type, CURATOR.Variable)) if v_labels is not None: self._variables_dict = v_labels.copy() for i, v in enumerate(variables): labels = list(action.request.pattern.objects(v, CURATOR.label)) preferred_label = labels.pop() if len(labels) == 1 else '' label = preferred_label if preferred_label.startswith('?') else '?v{}'.format(i) self._variables_dict[v] = label if preferred_label: self._preferred_labels.append(str(preferred_label)) for v in self._variables_dict.keys(): v_in = action.request.pattern.subject_predicates(v) for (s, pr) in v_in: s_part = self._variables_dict[s] if s in self._variables_dict else self._n3(action, s) self._graph_pattern.add(u'{} {} {}'.format(s_part, self._n3(action, pr), self._variables_dict[v])) v_out = action.request.pattern.predicate_objects(v) for (pr, o) in [_ for _ in v_out if _[1] != CURATOR.Variable and not _[0].startswith(CURATOR)]: o_part = self._variables_dict[o] if o in self._variables_dict else ( '"{}"'.format(o) if isinstance(o, Literal) else self._n3(action, o)) p_part = self._n3(action, pr) if pr != RDF.type else 'a' self._graph_pattern.add(u'{} {} {}'.format(self._variables_dict[v], p_part, o_part)) def __check_gp(self): gp_keys = r.keys('fragments:*:gp') for gpk in gp_keys: stored_gp = GraphPattern(r.smembers(gpk)) mapping = stored_gp.mapping(self._graph_pattern) if mapping: return gpk.split(':')[1], mapping return None @abstractmethod def _save(self, action): super(FragmentSink, self)._save(action) self._build_graph_pattern(action) fragment_mapping = self.__check_gp() exists = fragment_mapping is not None if not exists: self._fragment_id = str(uuid()) self._pipe.sadd('fragments', self._fragment_id) self._pipe.sadd('fragments:{}:gp'.format(self._fragment_id), *self._graph_pattern) mapping = {str(k): str(k) for k in self._variables_dict.values()} else: self._fragment_id, mapping = fragment_mapping if r.get('fragments:{}:on_demand'.format(self._fragment_id)) is not None: self._pipe.delete('fragments:{}:sync'.format(self._fragment_id)) self._pipe.hset(self._request_key, 'mapping', mapping) self._pipe.hset(self._request_key, 'preferred_labels', self._preferred_labels) self._pipe.sadd('fragments:{}:requests'.format(self._fragment_id), self._request_id) self._pipe.hset('{}'.format(self._request_key), 'fragment_id', self._fragment_id) self._pipe.hset('{}'.format(self._request_key), 'pattern', ' . '.join(self._graph_pattern)) self._dict_fields['mapping'] = mapping if not exists: log.info('Request {} has started a new fragment collection: {}'.format(self._request_id, self._fragment_id)) else: log.info('Request {} is going to re-use fragment {}'.format(self._request_id, self._fragment_id)) n_fragment_reqs = r.scard('fragments:{}:requests'.format(self._fragment_id)) log.info('Fragment {} is supporting {} more requests'.format(self._fragment_id, n_fragment_reqs)) @property def ready(self): return self.backed @abstractmethod def _remove(self, pipe): self._fragment_id = r.hget('{}'.format(self._request_key), 'fragment_id') pipe.srem('fragments:{}:requests'.format(self._fragment_id), self._request_id) super(FragmentSink, self)._remove(pipe) @abstractmethod def _load(self): super(FragmentSink, self)._load() self._fragment_id = self._dict_fields['fragment_id'] self._graph_pattern = GraphPattern(r.smembers('fragments:{}:gp'.format(self._fragment_id))) mapping = self._dict_fields.get('mapping', None) if mapping is not None: mapping = eval(mapping) self._dict_fields['mapping'] = mapping preferred_labels = self._dict_fields.get('preferred_labels', None) if preferred_labels is not None: preferred_labels = eval(preferred_labels) self._dict_fields['preferred_labels'] = preferred_labels try: del self._dict_fields['fragment_id'] except KeyError: pass @property def backed(self): return self.fragment_updated_on is not None # and self.fragment_on_demand is None @property def fragment_id(self): return self._fragment_id def map(self, v): if self.mapping is not None: return self.mapping.get(v, v) return v @property def fragment_updated_on(self): return r.get('fragments:{}:updated'.format(self._fragment_id)) @property def fragment_on_demand(self): return r.get('fragments:{}:on_demand'.format(self._fragment_id)) @property def is_pulling(self): return r.get('fragments:{}:pulling'.format(self._fragment_id)) is not None @property def fragment_contexts(self): return r.smembers('fragments:{}:contexts'.format(self._fragment_id)) @property def gp(self): return self._graph_pattern