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
