def __init__( self, fetcher=None, # type: Optional[Fetcher] namespaces=None, # type: Optional[Dict[Text, Text]] fileuri=None, # type: Optional[Text] copyfrom=None, # type: Optional[LoadingOptions] schemas=None, # type: Optional[List[Text]] original_doc=None, # type: Optional[Any] ): # type: (...) -> None self.idx = {} # type: Dict[Text, Text] self.fileuri = fileuri # type: Optional[Text] self.namespaces = namespaces self.schemas = schemas self.original_doc = original_doc if copyfrom is not None: self.idx = copyfrom.idx if fetcher is None: fetcher = copyfrom.fetcher if fileuri is None: self.fileuri = copyfrom.fileuri if namespaces is None: self.namespaces = copyfrom.namespaces if namespaces is None: schemas = copyfrom.schemas if fetcher is None: import requests from cachecontrol.wrapper import CacheControl from cachecontrol.caches import FileCache from schema_salad.ref_resolver import DefaultFetcher if "HOME" in os.environ: session = CacheControl( requests.Session(), cache=FileCache( os.path.join(os.environ["HOME"], ".cache", "salad")), ) elif "TMPDIR" in os.environ: session = CacheControl( requests.Session(), cache=FileCache( os.path.join(os.environ["TMPDIR"], ".cache", "salad")), ) else: session = CacheControl(requests.Session(), cache=FileCache("/tmp", ".cache", "salad")) self.fetcher = DefaultFetcher({}, session) # type: Fetcher else: self.fetcher = fetcher self.vocab = _vocab self.rvocab = _rvocab if namespaces is not None: self.vocab = self.vocab.copy() self.rvocab = self.rvocab.copy() for k, v in iteritems(namespaces): self.vocab[k] = v self.rvocab[v] = k
def __init__(self, fetcher=None, namespaces=None, fileuri=None, copyfrom=None, schemas=None): if copyfrom is not None: self.idx = copyfrom.idx if fetcher is None: fetcher = copyfrom.fetcher if fileuri is None: fileuri = copyfrom.fileuri if namespaces is None: namespaces = copyfrom.namespaces if namespaces is None: schemas = copyfrom.schemas else: self.idx = {} if fetcher is None: import os import requests from cachecontrol.wrapper import CacheControl from cachecontrol.caches import FileCache from schema_salad.ref_resolver import DefaultFetcher if "HOME" in os.environ: session = CacheControl(requests.Session(), cache=FileCache( os.path.join( os.environ["HOME"], ".cache", "salad"))) elif "TMPDIR" in os.environ: session = CacheControl(requests.Session(), cache=FileCache( os.path.join( os.environ["TMPDIR"], ".cache", "salad"))) else: session = CacheControl(requests.Session(), cache=FileCache("/tmp", ".cache", "salad")) self.fetcher = DefaultFetcher({}, session) else: self.fetcher = fetcher self.fileuri = fileuri self.vocab = _vocab self.rvocab = _rvocab self.namespaces = namespaces self.schemas = schemas if namespaces is not None: self.vocab = self.vocab.copy() self.rvocab = self.rvocab.copy() for k, v in iteritems(namespaces): self.vocab[k] = v self.rvocab[v] = k
def test_cache_control_sets_sort_query(): for bool_ in (True, False): sess = CacheControl(Session(), mock.Mock(spec=DictCache), sort_query=bool_) assert sess.adapters['http://'].sort_query == bool_ assert sess.adapters['http://'].controller.sort_query == bool_
def __init__(self, ctx, schemagraph=None, foreign_properties=None, idx=None, cache=None, session=None): # type: (Loader.ContextType, rdflib.Graph, Set[unicode], Dict[unicode, Union[List, Dict[unicode, Any], unicode]], Dict[unicode, Any], requests.sessions.Session) -> None normalize = lambda url: urlparse.urlsplit(url).geturl() if idx is not None: self.idx = idx else: self.idx = NormDict(normalize) self.ctx = {} # type: Loader.ContextType if schemagraph is not None: self.graph = schemagraph else: self.graph = rdflib.graph.Graph() if foreign_properties is not None: self.foreign_properties = foreign_properties else: self.foreign_properties = set() if cache is not None: self.cache = cache else: self.cache = {} self.session = None # type: requests.sessions.Session if session is not None: self.session = session else: self.session = CacheControl(requests.Session(), cache=FileCache( os.path.join( os.environ["HOME"], ".cache", "salad"))) self.url_fields = None # type: Set[unicode] self.scoped_ref_fields = None # type: Dict[unicode, int] self.vocab_fields = None # type: Set[unicode] self.identifiers = None # type: Set[unicode] self.identity_links = None # type: Set[unicode] self.standalone = None # type: Set[unicode] self.nolinkcheck = None # type: Set[unicode] self.vocab = {} # type: Dict[unicode, unicode] self.rvocab = {} # type: Dict[unicode, unicode] self.idmap = None # type: Dict[unicode, Any] self.mapPredicate = None # type: Dict[unicode, unicode] self.type_dsl_fields = None # type: Set[unicode] self.add_context(ctx)
def __init__( self, fetcher: Optional[Fetcher] = None, namespaces: Optional[Dict[str, str]] = None, schemas: Optional[Dict[str, str]] = None, fileuri: Optional[str] = None, copyfrom: Optional["LoadingOptions"] = None, original_doc: Optional[Any] = None, ) -> None: """Create a LoadingOptions object.""" self.idx: Dict[str, Dict[str, Any]] = {} self.fileuri: Optional[str] = fileuri self.namespaces = namespaces self.schemas = schemas self.original_doc = original_doc if copyfrom is not None: self.idx = copyfrom.idx if fetcher is None: fetcher = copyfrom.fetcher if fileuri is None: self.fileuri = copyfrom.fileuri if namespaces is None: self.namespaces = copyfrom.namespaces if schemas is None: self.schemas = copyfrom.schemas if fetcher is None: import requests from cachecontrol.caches import FileCache from cachecontrol.wrapper import CacheControl root = pathlib.Path(os.environ.get("HOME", tempfile.gettempdir())) session = CacheControl( requests.Session(), cache=FileCache(root / ".cache" / "salad"), ) self.fetcher: Fetcher = DefaultFetcher({}, session) else: self.fetcher = fetcher self.vocab = _vocab self.rvocab = _rvocab if namespaces is not None: self.vocab = self.vocab.copy() self.rvocab = self.rvocab.copy() for k, v in namespaces.items(): self.vocab[k] = v self.rvocab[v] = k
def __init__( self, fetcher=None, # type: Optional[Fetcher] namespaces=None, # type: Optional[Dict[str, str]] schemas=None, # type: Optional[Dict[str, str]] fileuri=None, # type: Optional[str] copyfrom=None, # type: Optional[LoadingOptions] original_doc=None, # type: Optional[Any] ): # type: (...) -> None self.idx = {} # type: Dict[str, Dict[str, Any]] self.fileuri = fileuri # type: Optional[str] self.namespaces = namespaces self.schemas = schemas self.original_doc = original_doc if copyfrom is not None: self.idx = copyfrom.idx if fetcher is None: fetcher = copyfrom.fetcher if fileuri is None: self.fileuri = copyfrom.fileuri if namespaces is None: self.namespaces = copyfrom.namespaces if schemas is None: self.schemas = copyfrom.schemas if fetcher is None: import requests from cachecontrol.caches import FileCache from cachecontrol.wrapper import CacheControl root = pathlib.Path(os.environ.get("HOME", tempfile.gettempdir())) session = CacheControl( requests.Session(), cache=FileCache(root / ".cache" / "salad"), ) self.fetcher: Fetcher = DefaultFetcher({}, session) else: self.fetcher = fetcher self.vocab = _vocab self.rvocab = _rvocab if namespaces is not None: self.vocab = self.vocab.copy() self.rvocab = self.rvocab.copy() for k, v in namespaces.items(): self.vocab[k] = v self.rvocab[v] = k
def __init__(self): session = requests.Session() if not self.__class__._cache: if self.backend == "RedisCache": pool = redis.ConnectionPool(host=self.redis_host, port=self.redis_port, db=0) r = redis.Redis(connection_pool=pool) self.__class__._cache = RedisCache(r) elif self.backend == "FileCache": self.__class__._cache = FileCache(self.file_cache_path) else: self.__class__._cache = DictCache() session = CacheControl(session, heuristic=DefaultHeuristic(self.expire_after), cache=self.__class__._cache) super(CachedRemoteResource, self).__init__(session)
def __init__( self, ctx: ContextType, schemagraph: Optional[Graph] = None, foreign_properties: Optional[Set[str]] = None, idx: Optional[IdxType] = None, cache: Optional[CacheType] = None, session: Optional[requests.sessions.Session] = None, fetcher_constructor: Optional[FetcherCallableType] = None, skip_schemas: Optional[bool] = None, url_fields: Optional[Set[str]] = None, allow_attachments: Optional[AttachmentsType] = None, doc_cache: Union[str, bool] = True, ) -> None: self.idx = (NormDict(lambda url: urllib.parse.urlsplit(url).geturl()) if idx is None else idx) # type: IdxType self.ctx = {} # type: ContextType self.graph = schemagraph if schemagraph is not None else Graph() self.foreign_properties = (set(foreign_properties) if foreign_properties is not None else set()) self.cache = cache if cache is not None else {} self.skip_schemas = skip_schemas if skip_schemas is not None else False if session is None: if doc_cache is False: self.session = requests.Session() elif doc_cache is True: if "HOME" in os.environ: self.session = CacheControl( requests.Session(), cache=FileCache( os.path.join(os.environ["HOME"], ".cache", "salad")), ) elif "TMP" in os.environ: self.session = CacheControl( requests.Session(), cache=FileCache( os.path.join(os.environ["TMP"], ".cache", "salad")), ) else: self.session = CacheControl( requests.Session(), cache=FileCache(os.path.join("/tmp", ".cache", "salad")), ) elif isinstance(doc_cache, str): self.session = CacheControl(requests.Session(), cache=FileCache(doc_cache)) else: self.session = session self.fetcher_constructor = (fetcher_constructor if fetcher_constructor is not None else DefaultFetcher) self.fetcher = self.fetcher_constructor(self.cache, self.session) self.fetch_text = self.fetcher.fetch_text self.check_exists = self.fetcher.check_exists self.url_fields = (set() if url_fields is None else set(url_fields) ) # type: Set[str] self.scoped_ref_fields = {} # type: Dict[str, int] self.vocab_fields = set() # type: Set[str] self.identifiers = [] # type: List[str] self.identity_links = set() # type: Set[str] self.standalone = None # type: Optional[Set[str]] self.nolinkcheck = set() # type: Set[str] self.vocab = {} # type: Dict[str, str] self.rvocab = {} # type: Dict[str, str] self.idmap = {} # type: Dict[str, str] self.mapPredicate = {} # type: Dict[str, str] self.type_dsl_fields = set() # type: Set[str] self.subscopes = {} # type: Dict[str, str] self.secondaryFile_dsl_fields = set() # type: Set[str] self.allow_attachments = allow_attachments self.add_context(ctx)
def __init__( self, ctx, # type: ContextType schemagraph=None, # type: rdflib.graph.Graph foreign_properties=None, # type: Set[Text] idx=None, # type: Dict[Text, Union[CommentedMap, CommentedSeq, Text, None]] cache=None, # type: Dict[Text, Any] session=None, # type: requests.sessions.Session fetcher_constructor=None, # type: Callable[[Dict[Text, Text], requests.sessions.Session], Fetcher] skip_schemas=None # type: bool ): # type: (...) -> None normalize = lambda url: urllib.parse.urlsplit(url).geturl() if idx is not None: self.idx = idx else: self.idx = NormDict(normalize) self.ctx = {} # type: ContextType if schemagraph is not None: self.graph = schemagraph else: self.graph = rdflib.graph.Graph() if foreign_properties is not None: self.foreign_properties = foreign_properties else: self.foreign_properties = set() if cache is not None: self.cache = cache else: self.cache = {} if skip_schemas is not None: self.skip_schemas = skip_schemas else: self.skip_schemas = False if session is None: if "HOME" in os.environ: self.session = CacheControl(requests.Session(), cache=FileCache( os.path.join( os.environ["HOME"], ".cache", "salad"))) elif "TMP" in os.environ: self.session = CacheControl(requests.Session(), cache=FileCache( os.path.join( os.environ["TMP"], ".cache", "salad"))) else: self.session = CacheControl(requests.Session(), cache=FileCache( "/tmp", ".cache", "salad")) else: self.session = session if fetcher_constructor is not None: self.fetcher_constructor = fetcher_constructor else: self.fetcher_constructor = DefaultFetcher self.fetcher = self.fetcher_constructor(self.cache, self.session) self.fetch_text = self.fetcher.fetch_text self.check_exists = self.fetcher.check_exists self.url_fields = set() # type: Set[Text] self.scoped_ref_fields = {} # type: Dict[Text, int] self.vocab_fields = set() # type: Set[Text] self.identifiers = [] # type: List[Text] self.identity_links = set() # type: Set[Text] self.standalone = None # type: Optional[Set[Text]] self.nolinkcheck = set() # type: Set[Text] self.vocab = {} # type: Dict[Text, Text] self.rvocab = {} # type: Dict[Text, Text] self.idmap = {} # type: Dict[Text, Any] self.mapPredicate = {} # type: Dict[Text, Text] self.type_dsl_fields = set() # type: Set[Text] self.add_context(ctx)
def use_wrapper(): print('Using helper') sess = CacheControl(Session()) return sess