_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q224700 | Twython.get_authentication_tokens | train | def get_authentication_tokens(self, callback_url=None, force_login=False,
screen_name=''):
"""Returns a dict including an authorization URL, ``auth_url``, to
direct a user to
:param callback_url: (optional) Url the user is returned to after
... | python | {
"resource": ""
} |
q224701 | Twython.obtain_access_token | train | def obtain_access_token(self):
"""Returns an OAuth 2 access token to make OAuth 2 authenticated
read-only calls.
:rtype: string
"""
if self.oauth_version != 2:
raise TwythonError('This method can only be called when your \
OAuth version... | python | {
"resource": ""
} |
q224702 | Twython.construct_api_url | train | def construct_api_url(api_url, **params):
"""Construct a Twitter API url, encoded, with parameters
:param api_url: URL of the Twitter API endpoint you are attempting
to construct
:param \*\*params: Parameters that are accepted by Twitter for the
endpoint you're requesting
... | python | {
"resource": ""
} |
q224703 | Twython.cursor | train | def cursor(self, function, return_pages=False, **params):
"""Returns a generator for results that match a specified query.
:param function: Instance of a Twython function
(Twython.get_home_timeline, Twython.search)
:param \*\*params: Extra parameters to send with your request
(u... | python | {
"resource": ""
} |
q224704 | TwythonStreamer._request | train | def _request(self, url, method='GET', params=None):
"""Internal stream request handling"""
self.connected = True
retry_counter = 0
method = method.lower()
func = getattr(self.client, method)
params, _ = _transparent_params(params)
def _send(retry_counter):
... | python | {
"resource": ""
} |
q224705 | LibrariesManager.optimize | train | def optimize(self):
"""Sort algorithm implementations by speed.
"""
# load benchmarks results
with open(LIBRARIES_FILE, 'r') as f:
libs_data = json.load(f)
# optimize
for alg, libs_names in libs_data.items():
libs = self.get_libs(alg)
i... | python | {
"resource": ""
} |
q224706 | LibrariesManager.clone | train | def clone(self):
"""Clone library manager prototype
"""
obj = self.__class__()
obj.libs = deepcopy(self.libs)
return obj | python | {
"resource": ""
} |
q224707 | Base.normalized_distance | train | def normalized_distance(self, *sequences):
"""Get distance from 0 to 1
"""
return float(self.distance(*sequences)) / self.maximum(*sequences) | python | {
"resource": ""
} |
q224708 | Base.external_answer | train | def external_answer(self, *sequences):
"""Try to get answer from known external libraries.
"""
# if this feature disabled
if not getattr(self, 'external', False):
return
# all external libs doesn't support test_func
if hasattr(self, 'test_func') and self.test_... | python | {
"resource": ""
} |
q224709 | Base._ident | train | def _ident(*elements):
"""Return True if all sequences are equal.
"""
try:
# for hashable elements
return len(set(elements)) == 1
except TypeError:
# for unhashable elements
for e1, e2 in zip(elements, elements[1:]):
if e1 !... | python | {
"resource": ""
} |
q224710 | Base._get_sequences | train | def _get_sequences(self, *sequences):
"""Prepare sequences.
qval=None: split text by words
qval=1: do not split sequences. For text this is mean comparing by letters.
qval>1: split sequences by q-grams
"""
# by words
if not self.qval:
return [s.split(... | python | {
"resource": ""
} |
q224711 | Base._get_counters | train | def _get_counters(self, *sequences):
"""Prepare sequences and convert it to Counters.
"""
# already Counters
if all(isinstance(s, Counter) for s in sequences):
return sequences
return [Counter(s) for s in self._get_sequences(*sequences)] | python | {
"resource": ""
} |
q224712 | Base._count_counters | train | def _count_counters(self, counter):
"""Return all elements count from Counter
"""
if getattr(self, 'as_set', False):
return len(set(counter))
else:
return sum(counter.values()) | python | {
"resource": ""
} |
q224713 | make_inst2 | train | def make_inst2():
"""creates example data set 2"""
I,d = multidict({1:45, 2:20, 3:30 , 4:30}) # demand
J,M = multidict({1:35, 2:50, 3:40}) # capacity
c = {(1,1):8, (1,2):9, (1,3):14 , # {(customer,factory) : cost<float>}
(2,1):6, (2,2):12, (2,3):9 ,
(3,1):10, (... | python | {
"resource": ""
} |
q224714 | VRPconshdlr.addCuts | train | def addCuts(self, checkonly):
"""add cuts if necessary and return whether model is feasible"""
cutsadded = False
edges = []
x = self.model.data
for (i, j) in x:
if self.model.getVal(x[i, j]) > .5:
if i != V[0] and j != V[0]:
edges.a... | python | {
"resource": ""
} |
q224715 | distCEIL2D | train | def distCEIL2D(x1,y1,x2,y2):
"""returns smallest integer not less than the distance of two points"""
xdiff = x2 - x1
ydiff = y2 - y1
return int(math.ceil(math.sqrt(xdiff*xdiff + ydiff*ydiff))) | python | {
"resource": ""
} |
q224716 | read_atsplib | train | def read_atsplib(filename):
"basic function for reading a ATSP problem on the TSPLIB format"
"NOTE: only works for explicit matrices"
if filename[-3:] == ".gz":
f = gzip.open(filename, 'r')
data = f.readlines()
else:
f = open(filename, 'r')
data = f.readlines()
for ... | python | {
"resource": ""
} |
q224717 | multidict | train | def multidict(D):
'''creates a multidictionary'''
keys = list(D.keys())
if len(keys) == 0:
return [[]]
try:
N = len(D[keys[0]])
islist = True
except:
N = 1
islist = False
dlist = [dict() for d in range(N)]
for k in keys:
if islist:
... | python | {
"resource": ""
} |
q224718 | register_plugin_module | train | def register_plugin_module(mod):
"""Find plugins in given module"""
for k, v in load_plugins_from_module(mod).items():
if k:
if isinstance(k, (list, tuple)):
k = k[0]
global_registry[k] = v | python | {
"resource": ""
} |
q224719 | register_plugin_dir | train | def register_plugin_dir(path):
"""Find plugins in given directory"""
import glob
for f in glob.glob(path + '/*.py'):
for k, v in load_plugins_from_module(f).items():
if k:
global_registry[k] = v | python | {
"resource": ""
} |
q224720 | UserParameter.describe | train | def describe(self):
"""Information about this parameter"""
desc = {
'name': self.name,
'description': self.description,
# the Parameter might not have a type at all
'type': self.type or 'unknown',
}
for attr in ['min', 'max', 'allowed', 'de... | python | {
"resource": ""
} |
q224721 | UserParameter.validate | train | def validate(self, value):
"""Does value meet parameter requirements?"""
if self.type is not None:
value = coerce(self.type, value)
if self.min is not None and value < self.min:
raise ValueError('%s=%s is less than %s' % (self.name, value,
... | python | {
"resource": ""
} |
q224722 | LocalCatalogEntry.describe | train | def describe(self):
"""Basic information about this entry"""
if isinstance(self._plugin, list):
pl = [p.name for p in self._plugin]
elif isinstance(self._plugin, dict):
pl = {k: classname(v) for k, v in self._plugin.items()}
else:
pl = self._plugin if ... | python | {
"resource": ""
} |
q224723 | LocalCatalogEntry.get | train | def get(self, **user_parameters):
"""Instantiate the DataSource for the given parameters"""
plugin, open_args = self._create_open_args(user_parameters)
data_source = plugin(**open_args)
data_source.catalog_object = self._catalog
data_source.name = self.name
data_source.de... | python | {
"resource": ""
} |
q224724 | YAMLFileCatalog._load | train | def _load(self, reload=False):
"""Load text of fcatalog file and pass to parse
Will do nothing if autoreload is off and reload is not explicitly
requested
"""
if self.autoreload or reload:
# First, we load from YAML, failing if syntax errors are found
opt... | python | {
"resource": ""
} |
q224725 | YAMLFileCatalog.parse | train | def parse(self, text):
"""Create entries from catalog text
Normally the text comes from the file at self.path via the ``_load()``
method, but could be explicitly set instead. A copy of the text is
kept in attribute ``.text`` .
Parameters
----------
text : str
... | python | {
"resource": ""
} |
q224726 | YAMLFileCatalog.name_from_path | train | def name_from_path(self):
"""If catalog is named 'catalog' take name from parent directory"""
name = os.path.splitext(os.path.basename(self.path))[0]
if name == 'catalog':
name = os.path.basename(os.path.dirname(self.path))
return name.replace('.', '_') | python | {
"resource": ""
} |
q224727 | ServerSourceHandler.get | train | def get(self):
"""
Access one source's info.
This is for direct access to an entry by name for random access, which
is useful to the client when the whole catalog has not first been
listed and pulled locally (e.g., in the case of pagination).
"""
head = self.requ... | python | {
"resource": ""
} |
q224728 | CatSelector.preprocess | train | def preprocess(cls, cat):
"""Function to run on each cat input"""
if isinstance(cat, str):
cat = intake.open_catalog(cat)
return cat | python | {
"resource": ""
} |
q224729 | CatSelector.expand_nested | train | def expand_nested(self, cats):
"""Populate widget with nested catalogs"""
down = '│'
right = '└──'
def get_children(parent):
return [e() for e in parent._entries.values() if e._container == 'catalog']
if len(cats) == 0:
return
cat = cats[0]
... | python | {
"resource": ""
} |
q224730 | CatSelector.collapse_nested | train | def collapse_nested(self, cats, max_nestedness=10):
"""
Collapse any items that are nested under cats.
`max_nestedness` acts as a fail-safe to prevent infinite looping.
"""
children = []
removed = set()
nestedness = max_nestedness
old = list(self.widget.o... | python | {
"resource": ""
} |
q224731 | CatSelector.remove_selected | train | def remove_selected(self, *args):
"""Remove the selected catalog - allow the passing of arbitrary
args so that buttons work. Also remove any nested catalogs."""
self.collapse_nested(self.selected)
self.remove(self.selected) | python | {
"resource": ""
} |
q224732 | PersistStore.add | train | def add(self, key, source):
"""Add the persisted source to the store under the given key
key : str
The unique token of the un-persisted, original source
source : DataSource instance
The thing to add to the persisted catalogue, referring to persisted
data
... | python | {
"resource": ""
} |
q224733 | PersistStore.get_tok | train | def get_tok(self, source):
"""Get string token from object
Strings are assumed to already be a token; if source or entry, see
if it is a persisted thing ("original_tok" is in its metadata), else
generate its own token.
"""
if isinstance(source, str):
return s... | python | {
"resource": ""
} |
q224734 | PersistStore.remove | train | def remove(self, source, delfiles=True):
"""Remove a dataset from the persist store
source : str or DataSource or Lo
If a str, this is the unique ID of the original source, which is
the key of the persisted dataset within the store. If a source,
can be either the ori... | python | {
"resource": ""
} |
q224735 | PersistStore.backtrack | train | def backtrack(self, source):
"""Given a unique key in the store, recreate original source"""
key = self.get_tok(source)
s = self[key]()
meta = s.metadata['original_source']
cls = meta['cls']
args = meta['args']
kwargs = meta['kwargs']
cls = import_name(cls... | python | {
"resource": ""
} |
q224736 | PersistStore.refresh | train | def refresh(self, key):
"""Recreate and re-persist the source for the given unique ID"""
s0 = self[key]
s = self.backtrack(key)
s.persist(**s0.metadata['persist_kwargs']) | python | {
"resource": ""
} |
q224737 | SourceSelector.cats | train | def cats(self, cats):
"""Set sources from a list of cats"""
sources = []
for cat in coerce_to_list(cats):
sources.extend([entry for entry in cat._entries.values() if entry._container != 'catalog'])
self.items = sources | python | {
"resource": ""
} |
q224738 | main | train | def main(argv=None):
''' Execute the "intake" command line program.
'''
from intake.cli.bootstrap import main as _main
return _main('Intake Catalog CLI', subcommands.all, argv or sys.argv) | python | {
"resource": ""
} |
q224739 | DataSource._load_metadata | train | def _load_metadata(self):
"""load metadata only if needed"""
if self._schema is None:
self._schema = self._get_schema()
self.datashape = self._schema.datashape
self.dtype = self._schema.dtype
self.shape = self._schema.shape
self.npartitions = s... | python | {
"resource": ""
} |
q224740 | DataSource.yaml | train | def yaml(self, with_plugin=False):
"""Return YAML representation of this data-source
The output may be roughly appropriate for inclusion in a YAML
catalog. This is a best-effort implementation
Parameters
----------
with_plugin: bool
If True, create a "plugin... | python | {
"resource": ""
} |
q224741 | DataSource.discover | train | def discover(self):
"""Open resource and populate the source attributes."""
self._load_metadata()
return dict(datashape=self.datashape,
dtype=self.dtype,
shape=self.shape,
npartitions=self.npartitions,
metadata=self... | python | {
"resource": ""
} |
q224742 | DataSource.read_chunked | train | def read_chunked(self):
"""Return iterator over container fragments of data source"""
self._load_metadata()
for i in range(self.npartitions):
yield self._get_partition(i) | python | {
"resource": ""
} |
q224743 | DataSource.read_partition | train | def read_partition(self, i):
"""Return a part of the data corresponding to i-th partition.
By default, assumes i should be an integer between zero and npartitions;
override for more complex indexing schemes.
"""
self._load_metadata()
if i < 0 or i >= self.npartitions:
... | python | {
"resource": ""
} |
q224744 | DataSource.plot | train | def plot(self):
"""
Returns a hvPlot object to provide a high-level plotting API.
To display in a notebook, be sure to run ``intake.output_notebook()``
first.
"""
try:
from hvplot import hvPlot
except ImportError:
raise ImportError("The in... | python | {
"resource": ""
} |
q224745 | DataSource.persist | train | def persist(self, ttl=None, **kwargs):
"""Save data from this source to local persistent storage"""
from ..container import container_map
from ..container.persist import PersistStore
import time
if 'original_tok' in self.metadata:
raise ValueError('Cannot persist a so... | python | {
"resource": ""
} |
q224746 | DataSource.export | train | def export(self, path, **kwargs):
"""Save this data for sharing with other people
Creates a copy of the data in a format appropriate for its container,
in the location specified (which can be remote, e.g., s3). Returns
a YAML representation of this saved dataset, so that it can be put
... | python | {
"resource": ""
} |
q224747 | load_user_catalog | train | def load_user_catalog():
"""Return a catalog for the platform-specific user Intake directory"""
cat_dir = user_data_dir()
if not os.path.isdir(cat_dir):
return Catalog()
else:
return YAMLFilesCatalog(cat_dir) | python | {
"resource": ""
} |
q224748 | load_global_catalog | train | def load_global_catalog():
"""Return a catalog for the environment-specific Intake directory"""
cat_dir = global_data_dir()
if not os.path.isdir(cat_dir):
return Catalog()
else:
return YAMLFilesCatalog(cat_dir) | python | {
"resource": ""
} |
q224749 | global_data_dir | train | def global_data_dir():
"""Return the global Intake catalog dir for the current environment"""
prefix = False
if VIRTUALENV_VAR in os.environ:
prefix = os.environ[VIRTUALENV_VAR]
elif CONDA_VAR in os.environ:
prefix = sys.prefix
elif which('conda'):
# conda exists but is not a... | python | {
"resource": ""
} |
q224750 | load_combo_catalog | train | def load_combo_catalog():
"""Load a union of the user and global catalogs for convenience"""
user_dir = user_data_dir()
global_dir = global_data_dir()
desc = 'Generated from data packages found on your intake search path'
cat_dirs = []
if os.path.isdir(user_dir):
cat_dirs.append(user_dir... | python | {
"resource": ""
} |
q224751 | Catalog.from_dict | train | def from_dict(cls, entries, **kwargs):
"""
Create Catalog from the given set of entries
Parameters
----------
entries : dict-like
A mapping of name:entry which supports dict-like functionality,
e.g., is derived from ``collections.abc.Mapping``.
kw... | python | {
"resource": ""
} |
q224752 | Catalog.reload | train | def reload(self):
"""Reload catalog if sufficient time has passed"""
if time.time() - self.updated > self.ttl:
self.force_reload() | python | {
"resource": ""
} |
q224753 | Catalog.filter | train | def filter(self, func):
"""Create a Catalog of a subset of entries based on a condition
Note that, whatever specific class this is performed on, the return
instance is a Catalog. The entries are passed unmodified, so they
will still reference the original catalog instance and include it... | python | {
"resource": ""
} |
q224754 | Catalog.walk | train | def walk(self, sofar=None, prefix=None, depth=2):
"""Get all entries in this catalog and sub-catalogs
Parameters
----------
sofar: dict or None
Within recursion, use this dict for output
prefix: list of str or None
Names of levels already visited
... | python | {
"resource": ""
} |
q224755 | Catalog.serialize | train | def serialize(self):
"""
Produce YAML version of this catalog.
Note that this is not the same as ``.yaml()``, which produces a YAML
block referring to this catalog.
"""
import yaml
output = {"metadata": self.metadata, "sources": {},
"name": self... | python | {
"resource": ""
} |
q224756 | Catalog.save | train | def save(self, url, storage_options=None):
"""
Output this catalog to a file as YAML
Parameters
----------
url : str
Location to save to, perhaps remote
storage_options : dict
Extra arguments for the file-system
"""
from dask.bytes... | python | {
"resource": ""
} |
q224757 | Entries.reset | train | def reset(self):
"Clear caches to force a reload."
self._page_cache.clear()
self._direct_lookup_cache.clear()
self._page_offset = 0
self.complete = self._catalog.page_size is None | python | {
"resource": ""
} |
q224758 | Entries.cached_items | train | def cached_items(self):
"""
Iterate over items that are already cached. Perform no requests.
"""
for item in six.iteritems(self._page_cache):
yield item
for item in six.iteritems(self._direct_lookup_cache):
yield item | python | {
"resource": ""
} |
q224759 | RemoteCatalog._get_http_args | train | def _get_http_args(self, params):
"""
Return a copy of the http_args
Adds auth headers and 'source_id', merges in params.
"""
# Add the auth headers to any other headers
headers = self.http_args.get('headers', {})
if self.auth is not None:
auth_header... | python | {
"resource": ""
} |
q224760 | RemoteCatalog._load | train | def _load(self):
"""Fetch metadata from remote. Entries are fetched lazily."""
# This will not immediately fetch any sources (entries). It will lazily
# fetch sources from the server in paginated blocks when this Catalog
# is iterated over. It will fetch specific sources when they are
... | python | {
"resource": ""
} |
q224761 | nice_join | train | def nice_join(seq, sep=", ", conjunction="or"):
''' Join together sequences of strings into English-friendly phrases using
a conjunction when appropriate.
Args:
seq (seq[str]) : a sequence of strings to nicely join
sep (str, optional) : a sequence delimiter to use (default: ", ")
... | python | {
"resource": ""
} |
q224762 | output_notebook | train | def output_notebook(inline=True, logo=False):
"""
Load the notebook extension
Parameters
----------
inline : boolean (optional)
Whether to inline JS code or load it from a CDN
logo : boolean (optional)
Whether to show the logo(s)
"""
try:
import hvplot
except... | python | {
"resource": ""
} |
q224763 | open_catalog | train | def open_catalog(uri=None, **kwargs):
"""Create a Catalog object
Can load YAML catalog files, connect to an intake server, or create any
arbitrary Catalog subclass instance. In the general case, the user should
supply ``driver=`` with a value from the plugins registry which has a
container type of ... | python | {
"resource": ""
} |
q224764 | RemoteDataFrame._persist | train | def _persist(source, path, **kwargs):
"""Save dataframe to local persistent store
Makes a parquet dataset out of the data using dask.dataframe.to_parquet.
This then becomes a data entry in the persisted datasets catalog.
Parameters
----------
source: a DataSource instan... | python | {
"resource": ""
} |
q224765 | save_conf | train | def save_conf(fn=None):
"""Save current configuration to file as YAML
If not given, uses current config directory, ``confdir``, which can be
set by INTAKE_CONF_DIR.
"""
if fn is None:
fn = cfile()
try:
os.makedirs(os.path.dirname(fn))
except (OSError, IOError):
pass
... | python | {
"resource": ""
} |
q224766 | load_conf | train | def load_conf(fn=None):
"""Update global config from YAML file
If fn is None, looks in global config directory, which is either defined
by the INTAKE_CONF_DIR env-var or is ~/.intake/ .
"""
if fn is None:
fn = cfile()
if os.path.isfile(fn):
with open(fn) as f:
try:
... | python | {
"resource": ""
} |
q224767 | intake_path_dirs | train | def intake_path_dirs(path):
"""Return a list of directories from the intake path.
If a string, perhaps taken from an environment variable, then the
list of paths will be split on the character ":" for posix of ";" for
windows. Protocol indicators ("protocol://") will be ignored.
"""
if isinstan... | python | {
"resource": ""
} |
q224768 | load_env | train | def load_env():
"""Analyse enviroment variables and update conf accordingly"""
# environment variables take precedence over conf file
for key, envvar in [['cache_dir', 'INTAKE_CACHE_DIR'],
['catalog_path', 'INTAKE_PATH'],
['persist_path', 'INTAKE_PERSIST_PATH'... | python | {
"resource": ""
} |
q224769 | Description.source | train | def source(self, source):
"""When the source gets updated, update the pane object"""
BaseView.source.fset(self, source)
if self.main_pane:
self.main_pane.object = self.contents
self.label_pane.object = self.label | python | {
"resource": ""
} |
q224770 | Description.contents | train | def contents(self):
"""String representation of the source's description"""
if not self._source:
return ' ' * 100 # HACK - make sure that area is big
contents = self.source.describe()
return pretty_describe(contents) | python | {
"resource": ""
} |
q224771 | _get_parts_of_format_string | train | def _get_parts_of_format_string(resolved_string, literal_texts, format_specs):
"""
Inner function of reverse_format, returns the resolved value for each
field in pattern.
"""
_text = resolved_string
bits = []
if literal_texts[-1] != '' and _text.endswith(literal_texts[-1]):
_text = ... | python | {
"resource": ""
} |
q224772 | reverse_formats | train | def reverse_formats(format_string, resolved_strings):
"""
Reverse the string method format for a list of strings.
Given format_string and resolved_strings, for each resolved string
find arguments that would give
``format_string.format(**arguments) == resolved_string``.
Each item in the output ... | python | {
"resource": ""
} |
q224773 | reverse_format | train | def reverse_format(format_string, resolved_string):
"""
Reverse the string method format.
Given format_string and resolved_string, find arguments that would
give ``format_string.format(**arguments) == resolved_string``
Parameters
----------
format_string : str
Format template strin... | python | {
"resource": ""
} |
q224774 | path_to_glob | train | def path_to_glob(path):
"""
Convert pattern style paths to glob style paths
Returns path if path is not str
Parameters
----------
path : str
Path to data optionally containing format_strings
Returns
-------
glob : str
Path with any format strings replaced with *
... | python | {
"resource": ""
} |
q224775 | path_to_pattern | train | def path_to_pattern(path, metadata=None):
"""
Remove source information from path when using chaching
Returns None if path is not str
Parameters
----------
path : str
Path to data optionally containing format_strings
metadata : dict, optional
Extra arguments to the class, c... | python | {
"resource": ""
} |
q224776 | get_partition | train | def get_partition(url, headers, source_id, container, partition):
"""Serializable function for fetching a data source partition
Parameters
----------
url: str
Server address
headers: dict
HTTP header parameters
source_id: str
ID of the source in the server's cache (uniqu... | python | {
"resource": ""
} |
q224777 | flatten | train | def flatten(iterable):
"""Flatten an arbitrarily deep list"""
# likely not used
iterable = iter(iterable)
while True:
try:
item = next(iterable)
except StopIteration:
break
if isinstance(item, six.string_types):
yield item
continue... | python | {
"resource": ""
} |
q224778 | clamp | train | def clamp(value, lower=0, upper=sys.maxsize):
"""Clamp float between given range"""
return max(lower, min(upper, value)) | python | {
"resource": ""
} |
q224779 | expand_templates | train | def expand_templates(pars, context, return_left=False, client=False,
getenv=True, getshell=True):
"""
Render variables in context into the set of parameters with jinja2.
For variables that are not strings, nothing happens.
Parameters
----------
pars: dict
values ar... | python | {
"resource": ""
} |
q224780 | merge_pars | train | def merge_pars(params, user_inputs, spec_pars, client=False, getenv=True,
getshell=True):
"""Produce open arguments by merging various inputs
This function is called in the context of a catalog entry, when finalising
the arguments for instantiating the corresponding data source.
The thr... | python | {
"resource": ""
} |
q224781 | coerce | train | def coerce(dtype, value):
"""
Convert a value to a specific type.
If the value is already the given type, then the original value is
returned. If the value is None, then the default value given by the
type constructor is returned. Otherwise, the type constructor converts
and returns the value.
... | python | {
"resource": ""
} |
q224782 | open_remote | train | def open_remote(url, entry, container, user_parameters, description, http_args,
page_size=None, auth=None, getenv=None, getshell=None):
"""Create either local direct data source or remote streamed source"""
from intake.container import container_map
if url.startswith('intake://'):
ur... | python | {
"resource": ""
} |
q224783 | RemoteSequenceSource._persist | train | def _persist(source, path, encoder=None):
"""Save list to files using encoding
encoder : None or one of str|json|pickle
None is equivalent to str
"""
import posixpath
from dask.bytes import open_files
import dask
import pickle
import json
... | python | {
"resource": ""
} |
q224784 | CatalogEntry._ipython_display_ | train | def _ipython_display_(self):
"""Display the entry as a rich object in an IPython session."""
contents = self.describe()
display({ # noqa: F821
'application/json': contents,
'text/plain': pretty_describe(contents)
}, metadata={
'application/json': {'ro... | python | {
"resource": ""
} |
q224785 | autodiscover | train | def autodiscover(path=None, plugin_prefix='intake_'):
"""Scan for Intake plugin packages and return a dict of plugins.
This function searches path (or sys.path) for packages with names that
start with plugin_prefix. Those modules will be imported and scanned for
subclasses of intake.source.base.Plugin... | python | {
"resource": ""
} |
q224786 | load_plugins_from_module | train | def load_plugins_from_module(module_name):
"""Imports a module and returns dictionary of discovered Intake plugins.
Plugin classes are instantiated and added to the dictionary, keyed by the
name attribute of the plugin object.
"""
plugins = {}
try:
if module_name.endswith('.py'):
... | python | {
"resource": ""
} |
q224787 | CSVSource._set_pattern_columns | train | def _set_pattern_columns(self, path_column):
"""Get a column of values for each field in pattern
"""
try:
# CategoricalDtype allows specifying known categories when
# creating objects. It was added in pandas 0.21.0.
from pandas.api.types import CategoricalDtyp... | python | {
"resource": ""
} |
q224788 | CSVSource._path_column | train | def _path_column(self):
"""Set ``include_path_column`` in csv_kwargs and returns path column name
"""
path_column = self._csv_kwargs.get('include_path_column')
if path_column is None:
# if path column name is not set by user, set to a unique string to
# avoid con... | python | {
"resource": ""
} |
q224789 | CSVSource._open_dataset | train | def _open_dataset(self, urlpath):
"""Open dataset using dask and use pattern fields to set new columns
"""
import dask.dataframe
if self.pattern is None:
self._dataframe = dask.dataframe.read_csv(
urlpath, storage_options=self._storage_options,
... | python | {
"resource": ""
} |
q224790 | Search.do_search | train | def do_search(self, arg=None):
"""Do search and close panel"""
new_cats = []
for cat in self.cats:
new_cat = cat.search(self.inputs.text,
depth=self.inputs.depth)
if len(list(new_cat)) > 0:
new_cats.append(new_cat)
... | python | {
"resource": ""
} |
q224791 | RemoteArray._persist | train | def _persist(source, path, component=None, storage_options=None,
**kwargs):
"""Save array to local persistent store
Makes a parquet dataset out of the data using zarr.
This then becomes a data entry in the persisted datasets catalog.
Only works locally for the moment.
... | python | {
"resource": ""
} |
q224792 | DefinedPlots.source | train | def source(self, source):
"""When the source gets updated, update the the options in the selector"""
BaseView.source.fset(self, source)
if self.select:
self.select.options = self.options | python | {
"resource": ""
} |
q224793 | get_file | train | def get_file(f, decoder, read):
"""Serializable function to take an OpenFile object and read lines"""
with f as f:
if decoder is None:
return list(f)
else:
d = f.read() if read else f
out = decoder(d)
if isinstance(out, (tuple, list)):
... | python | {
"resource": ""
} |
q224794 | BaseAuth.get_case_insensitive | train | def get_case_insensitive(self, dictionary, key, default=None):
"""Case-insensitive search of a dictionary for key.
Returns the value if key match is found, otherwise default.
"""
lower_key = key.lower()
for k, v in dictionary.items():
if lower_key == k.lower():
... | python | {
"resource": ""
} |
q224795 | FileSelector.url | train | def url(self):
"""Path to local catalog file"""
return os.path.join(self.path, self.main.value[0]) | python | {
"resource": ""
} |
q224796 | FileSelector.validate | train | def validate(self, arg=None):
"""Check that inputted path is valid - set validator accordingly"""
if os.path.isdir(self.path):
self.validator.object = None
else:
self.validator.object = ICONS['error'] | python | {
"resource": ""
} |
q224797 | CatAdder.add_cat | train | def add_cat(self, arg=None):
"""Add cat and close panel"""
try:
self.done_callback(self.cat)
self.visible = False
except Exception as e:
self.validator.object = ICONS['error']
raise e | python | {
"resource": ""
} |
q224798 | CatAdder.tab_change | train | def tab_change(self, event):
"""When tab changes remove error, and enable widget if on url tab"""
self.remove_error()
if event.new == 1:
self.widget.disabled = False | python | {
"resource": ""
} |
q224799 | CatGUI.callback | train | def callback(self, cats):
"""When a catalog is selected, enable widgets that depend on that condition
and do done_callback"""
enable = bool(cats)
if not enable:
# close search if it is visible
self.search.visible = False
enable_widget(self.search_widget, e... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.