_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q264100 | Repo.find_matching_files | validation | def find_matching_files(self, includes):
"""
For various actions we need files that match patterns
"""
if len(includes) == 0:
return []
files = [f['relativepath'] for f in self.package['resources']]
includes = r'|'.join([fnmatch.translate(x) for x in inclu... | python | {
"resource": ""
} |
q264101 | Repo.run | validation | def run(self, cmd, *args):
"""
Run a specific command using the manager
"""
if self.manager is None:
raise Exception("Fatal internal error: Missing repository manager")
if cmd not in dir(self.manager):
raise Exception("Fatal internal error: Invalid command... | python | {
"resource": ""
} |
q264102 | Repo.get_resource | validation | def get_resource(self, p):
"""
Get metadata for a given file
"""
for r in self.package['resources']:
if r['relativepath'] == p:
r['localfullpath'] = os.path.join(self.rootdir, p)
return r
raise Exception("Invalid path") | python | {
"resource": ""
} |
q264103 | RepoManagerBase.lookup | validation | def lookup(self, username=None, reponame=None, key=None):
"""
Lookup all available repos
"""
if key is None:
key = self.key(username, reponame)
if key not in self.repos:
raise UnknownRepository()
return self.repos[key] | python | {
"resource": ""
} |
q264104 | RepoManagerBase.rootdir | validation | def rootdir(self, username, reponame, create=True):
"""
Working directory for the repo
"""
path = os.path.join(self.workspace,
'datasets',
username,
reponame)
if create:
try:
... | python | {
"resource": ""
} |
q264105 | RepoManagerBase.add | validation | def add(self, repo):
"""
Add repo to the internal lookup table...
"""
key = self.key(repo.username, repo.reponame)
repo.key = key
self.repos[key] = repo
return key | python | {
"resource": ""
} |
q264106 | lookup | validation | def lookup(username, reponame):
"""
Lookup a repo based on username reponame
"""
mgr = plugins_get_mgr()
# XXX This should be generalized to all repo managers.
repomgr = mgr.get(what='repomanager', name='git')
repo = repomgr.lookup(username=username,
reponame=re... | python | {
"resource": ""
} |
q264107 | shellcmd | validation | def shellcmd(repo, args):
"""
Run a shell command within the repo's context
Parameters
----------
repo: Repository object
args: Shell command
"""
with cd(repo.rootdir):
result = run(args)
return result | python | {
"resource": ""
} |
q264108 | datapackage_exists | validation | def datapackage_exists(repo):
"""
Check if the datapackage exists...
"""
datapath = os.path.join(repo.rootdir, "datapackage.json")
return os.path.exists(datapath) | python | {
"resource": ""
} |
q264109 | bootstrap_datapackage | validation | def bootstrap_datapackage(repo, force=False,
options=None, noinput=False):
"""
Create the datapackage file..
"""
print("Bootstrapping datapackage")
# get the directory
tsprefix = datetime.now().date().isoformat()
# Initial data package json
package = OrderedD... | python | {
"resource": ""
} |
q264110 | init | validation | def init(username, reponame, setup,
force=False, options=None,
noinput=False):
"""
Initialize an empty repository with datapackage.json
Parameters
----------
username: Name of the user
reponame: Name of the repo
setup: Specify the 'configuration' (git only, git+s3 backend... | python | {
"resource": ""
} |
q264111 | annotate_metadata_data | validation | def annotate_metadata_data(repo, task, patterns=["*"], size=0):
"""
Update metadata with the content of the files
"""
mgr = plugins_get_mgr()
keys = mgr.search('representation')['representation']
representations = [mgr.get_by_key('representation', k) for k in keys]
matching_files = repo.f... | python | {
"resource": ""
} |
q264112 | annotate_metadata_code | validation | def annotate_metadata_code(repo, files):
"""
Update metadata with the commit information
"""
package = repo.package
package['code'] = []
for p in files:
matching_files = glob2.glob("**/{}".format(p))
for f in matching_files:
absf = os.path.abspath(f)
prin... | python | {
"resource": ""
} |
q264113 | annotate_metadata_action | validation | def annotate_metadata_action(repo):
"""
Update metadata with the action history
"""
package = repo.package
print("Including history of actions")
with cd(repo.rootdir):
filename = ".dgit/log.json"
if os.path.exists(filename):
history = open(... | python | {
"resource": ""
} |
q264114 | annotate_metadata_platform | validation | def annotate_metadata_platform(repo):
"""
Update metadata host information
"""
print("Added platform information")
package = repo.package
mgr = plugins_get_mgr()
repomgr = mgr.get(what='instrumentation', name='platform')
package['platform'] = repomgr.get_metadata() | python | {
"resource": ""
} |
q264115 | annotate_metadata_dependencies | validation | def annotate_metadata_dependencies(repo):
"""
Collect information from the dependent repo's
"""
options = repo.options
if 'dependencies' not in options:
print("No dependencies")
return []
repos = []
dependent_repos = options['dependencies']
for d in dependent_repos:
... | python | {
"resource": ""
} |
q264116 | post | validation | def post(repo, args=[]):
"""
Post to metadata server
Parameters
----------
repo: Repository object (result of lookup)
"""
mgr = plugins_get_mgr()
keys = mgr.search(what='metadata')
keys = keys['metadata']
if len(keys) == 0:
return
# Incorporate pipeline informati... | python | {
"resource": ""
} |
q264117 | plugins_show | validation | def plugins_show(what=None, name=None, version=None, details=False):
"""
Show details of available plugins
Parameters
----------
what: Class of plugins e.g., backend
name: Name of the plugin e.g., s3
version: Version of the plugin
details: Show details be shown?
"""
global plug... | python | {
"resource": ""
} |
q264118 | PluginManager.discover_all_plugins | validation | def discover_all_plugins(self):
"""
Load all plugins from dgit extension
"""
for v in pkg_resources.iter_entry_points('dgit.plugins'):
m = v.load()
m.setup(self) | python | {
"resource": ""
} |
q264119 | PluginManager.register | validation | def register(self, what, obj):
"""
Registering a plugin
Params
------
what: Nature of the plugin (backend, instrumentation, repo)
obj: Instance of the plugin
"""
# print("Registering pattern", name, pattern)
name = obj.name
version = obj.v... | python | {
"resource": ""
} |
q264120 | PluginManager.search | validation | def search(self, what, name=None, version=None):
"""
Search for a plugin
"""
filtered = {}
# The search may for a scan (what is None) or
if what is None:
whats = list(self.plugins.keys())
elif what is not None:
if what not in self.plugins:... | python | {
"resource": ""
} |
q264121 | instantiate | validation | def instantiate(repo, validator_name=None, filename=None, rulesfiles=None):
"""
Instantiate the validation specification
"""
default_validators = repo.options.get('validator', {})
validators = {}
if validator_name is not None:
# Handle the case validator is specified..
if valid... | python | {
"resource": ""
} |
q264122 | validate | validation | def validate(repo,
validator_name=None,
filename=None,
rulesfiles=None,
args=[]):
"""
Validate the content of the files for consistency. Validators can
look as deeply as needed into the files. dgit treats them all as
black boxes.
Parameters
... | python | {
"resource": ""
} |
q264123 | LocalBackend.url_is_valid | validation | def url_is_valid(self, url):
"""
Check if a URL exists
"""
# Check if the file system path exists...
if url.startswith("file://"):
url = url.replace("file://","")
return os.path.exists(url) | python | {
"resource": ""
} |
q264124 | BasicMetadata.post | validation | def post(self, repo):
"""
Post to the metadata server
Parameters
----------
repo
"""
datapackage = repo.package
url = self.url
token = self.token
headers = {
'Authorization': 'Token {}'.format(token),
'Content-Ty... | python | {
"resource": ""
} |
q264125 | get_module_class | validation | def get_module_class(class_path):
"""
imports and returns module class from ``path.to.module.Class``
argument
"""
mod_name, cls_name = class_path.rsplit('.', 1)
try:
mod = import_module(mod_name)
except ImportError as ex:
raise EvoStreamException('Error importing module %s: ... | python | {
"resource": ""
} |
q264126 | find_executable_files | validation | def find_executable_files():
"""
Find max 5 executables that are responsible for this repo.
"""
files = glob.glob("*") + glob.glob("*/*") + glob.glob('*/*/*')
files = filter(lambda f: os.path.isfile(f), files)
executable = stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH
final = []
for filenam... | python | {
"resource": ""
} |
q264127 | auto_get_repo | validation | def auto_get_repo(autooptions, debug=False):
"""
Automatically get repo
Parameters
----------
autooptions: dgit.json content
"""
# plugin manager
pluginmgr = plugins_get_mgr()
# get the repo manager
repomgr = pluginmgr.get(what='repomanager', name='git')
repo = None
... | python | {
"resource": ""
} |
q264128 | get_files_to_commit | validation | def get_files_to_commit(autooptions):
"""
Look through the local directory to pick up files to check
"""
workingdir = autooptions['working-directory']
includes = autooptions['track']['includes']
excludes = autooptions['track']['excludes']
# transform glob patterns to regular expressions
... | python | {
"resource": ""
} |
q264129 | auto_add | validation | def auto_add(repo, autooptions, files):
"""
Cleanup the paths and add
"""
# Get the mappings and keys.
mapping = { ".": "" }
if (('import' in autooptions) and
('directory-mapping' in autooptions['import'])):
mapping = autooptions['import']['directory-mapping']
# Apply the lo... | python | {
"resource": ""
} |
q264130 | Api.pull_stream | validation | def pull_stream(self, uri, **kwargs):
"""
This will try to pull in a stream from an external source. Once a
stream has been successfully pulled it is assigned a 'local stream
name' which can be used to access the stream from the EMS.
:param uri: The URI of the external stream. C... | python | {
"resource": ""
} |
q264131 | Api.record | validation | def record(self, localStreamName, pathToFile, **kwargs):
"""
Records any inbound stream. The record command allows users to record
a stream that may not yet exist. When a new stream is brought into
the server, it is checked against a list of streams to be recorded.
Streams can b... | python | {
"resource": ""
} |
q264132 | Api.create_ingest_point | validation | def create_ingest_point(self, privateStreamName, publicStreamName):
"""
Creates an RTMP ingest point, which mandates that streams pushed into
the EMS have a target stream name which matches one Ingest Point
privateStreamName.
:param privateStreamName: The name that RTMP Target S... | python | {
"resource": ""
} |
q264133 | instantiate | validation | def instantiate(repo, name=None, filename=None):
"""
Instantiate the generator and filename specification
"""
default_transformers = repo.options.get('transformer', {})
# If a name is specified, then lookup the options from dgit.json
# if specfied. Otherwise it is initialized to an empty list ... | python | {
"resource": ""
} |
q264134 | GitRepoManager._run | validation | def _run(self, cmd):
"""
Helper function to run commands
Parameters
----------
cmd : list
Arguments to git command
"""
# This is here in case the .gitconfig is not accessible for
# some reason.
environ = os.environ.copy()
... | python | {
"resource": ""
} |
q264135 | GitRepoManager._run_generic_command | validation | def _run_generic_command(self, repo, cmd):
"""
Run a generic command within the repo. Assumes that you are
in the repo's root directory
"""
result = None
with cd(repo.rootdir):
# Dont use sh. It is not collecting the stdout of all
# child ... | python | {
"resource": ""
} |
q264136 | GitRepoManager.init | validation | def init(self, username, reponame, force, backend=None):
"""
Initialize a Git repo
Parameters
----------
username, reponame : Repo name is tuple (name, reponame)
force: force initialization of the repo even if exists
backend: backend that must be used for this (... | python | {
"resource": ""
} |
q264137 | GitRepoManager.delete | validation | def delete(self, repo, args=[]):
"""
Delete files from the repo
"""
result = None
with cd(repo.rootdir):
try:
cmd = ['rm'] + list(args)
result = {
'status': 'success',
'message': self._run(cmd)
... | python | {
"resource": ""
} |
q264138 | GitRepoManager.drop | validation | def drop(self, repo, args=[]):
"""
Cleanup the repo
"""
# Clean up the rootdir
rootdir = repo.rootdir
if os.path.exists(rootdir):
print("Cleaning repo directory: {}".format(rootdir))
shutil.rmtree(rootdir)
# Cleanup the local version of t... | python | {
"resource": ""
} |
q264139 | GitRepoManager.permalink | validation | def permalink(self, repo, path):
"""
Get the permalink to command that generated the dataset
"""
if not os.path.exists(path):
# print("Path does not exist", path)
return (None, None)
# Get this directory
cwd = os.getcwd()
# Find the ro... | python | {
"resource": ""
} |
q264140 | GitRepoManager.add_files | validation | def add_files(self, repo, files):
"""
Add files to the repo
"""
rootdir = repo.rootdir
for f in files:
relativepath = f['relativepath']
sourcepath = f['localfullpath']
if sourcepath is None:
# This can happen if the relative pat... | python | {
"resource": ""
} |
q264141 | Invoice.send | validation | def send(self, send_email=True):
"""Marks the invoice as sent in Holvi
If send_email is False then the invoice is *not* automatically emailed to the recipient
and your must take care of sending the invoice yourself.
"""
url = str(self.api.base_url + '{code}/status/').format(code... | python | {
"resource": ""
} |
q264142 | Invoice.to_holvi_dict | validation | def to_holvi_dict(self):
"""Convert our Python object to JSON acceptable to Holvi API"""
self._jsondata["items"] = []
for item in self.items:
self._jsondata["items"].append(item.to_holvi_dict())
self._jsondata["issue_date"] = self.issue_date.isoformat()
self._jsondata... | python | {
"resource": ""
} |
q264143 | api_call_action | validation | def api_call_action(func):
"""
API wrapper documentation
"""
def _inner(*args, **kwargs):
return func(*args, **kwargs)
_inner.__name__ = func.__name__
_inner.__doc__ = func.__doc__
return _inner | python | {
"resource": ""
} |
q264144 | Order.save | validation | def save(self):
"""Saves this order to Holvi, returns a tuple with the order itself and checkout_uri"""
if self.code:
raise HolviError("Orders cannot be updated")
send_json = self.to_holvi_dict()
send_json.update({
'pool': self.api.connection.pool
})
... | python | {
"resource": ""
} |
q264145 | untokenize | validation | def untokenize(tokens):
"""Return source code based on tokens.
This is like tokenize.untokenize(), but it preserves spacing between
tokens. So if the original soure code had multiple spaces between
some tokens or if escaped newlines were used, those things will be
reflected by untokenize().
""... | python | {
"resource": ""
} |
q264146 | init | validation | def init(globalvars=None, show=False):
"""
Load profile INI
"""
global config
profileini = getprofileini()
if os.path.exists(profileini):
config = configparser.ConfigParser()
config.read(profileini)
mgr = plugins_get_mgr()
mgr.update_configs(config)
if s... | python | {
"resource": ""
} |
q264147 | update | validation | def update(globalvars):
"""
Update the profile
"""
global config
profileini = getprofileini()
config = configparser.ConfigParser()
config.read(profileini)
defaults = {}
if globalvars is not None:
defaults = {a[0]: a[1] for a in globalvars }
# Generic variables to be ca... | python | {
"resource": ""
} |
q264148 | S3Backend.init_repo | validation | def init_repo(self, gitdir):
"""
Insert hook into the repo
"""
hooksdir = os.path.join(gitdir, 'hooks')
content = postreceive_template % {
'client': self.client,
'bucket': self.bucket,
's3cfg': self.s3cfg,
'prefix': self.prefix
... | python | {
"resource": ""
} |
q264149 | compute_sha256 | validation | def compute_sha256(filename):
"""
Try the library. If it doesnt work, use the command line..
"""
try:
h = sha256()
fd = open(filename, 'rb')
while True:
buf = fd.read(0x1000000)
if buf in [None, ""]:
break
h.update(buf.encode('u... | python | {
"resource": ""
} |
q264150 | run | validation | def run(cmd):
"""
Run a shell command
"""
cmd = [pipes.quote(c) for c in cmd]
cmd = " ".join(cmd)
cmd += "; exit 0"
# print("Running {} in {}".format(cmd, os.getcwd()))
try:
output = subprocess.check_output(cmd,
stderr=subprocess.STDOUT,
... | python | {
"resource": ""
} |
q264151 | get_tree | validation | def get_tree(gitdir="."):
"""
Get the commit history for a given dataset
"""
cmd = ["git", "log", "--all", "--branches", '--pretty=format:{ "commit": "%H", "abbreviated_commit": "%h", "tree": "%T", "abbreviated_tree": "%t", "parent": "%P", "abbreviated_parent": "%p", "refs": "%d", "encoding": "... | python | {
"resource": ""
} |
q264152 | get_diffs | validation | def get_diffs(history):
"""
Look at files and compute the diffs intelligently
"""
# First get all possible representations
mgr = plugins_get_mgr()
keys = mgr.search('representation')['representation']
representations = [mgr.get_by_key('representation', k) for k in keys]
for i in range... | python | {
"resource": ""
} |
q264153 | SSHClient.wait | validation | def wait(self, cmd, raise_on_error=True):
"""
Execute command and wait for it to finish. Proceed with caution because
if you run a command that causes a prompt this will hang
"""
_, stdout, stderr = self.exec_command(cmd)
stdout.channel.recv_exit_status()
output =... | python | {
"resource": ""
} |
q264154 | SSHClient.sudo | validation | def sudo(self, password=None):
"""
Enter sudo mode
"""
if self.username == 'root':
raise ValueError('Already root user')
password = self.validate_password(password)
stdin, stdout, stderr = self.exec_command('sudo su')
stdin.write("%s\n" % password)
... | python | {
"resource": ""
} |
q264155 | SSHClient.apt | validation | def apt(self, package_names, raise_on_error=False):
"""
Install specified packages using apt-get. -y options are
automatically used. Waits for command to finish.
Parameters
----------
package_names: list-like of str
raise_on_error: bool, default False
... | python | {
"resource": ""
} |
q264156 | SSHClient.pip | validation | def pip(self, package_names, raise_on_error=True):
"""
Install specified python packages using pip. -U option added
Waits for command to finish.
Parameters
----------
package_names: list-like of str
raise_on_error: bool, default True
If True then rais... | python | {
"resource": ""
} |
q264157 | SSHClient.pip_r | validation | def pip_r(self, requirements, raise_on_error=True):
"""
Install all requirements contained in the given file path
Waits for command to finish.
Parameters
----------
requirements: str
Path to requirements.txt
raise_on_error: bool, default True
... | python | {
"resource": ""
} |
q264158 | stitch_macro | validation | def stitch_macro(path, output_folder=None):
"""Create fiji-macros for stitching all channels and z-stacks for a well.
Parameters
----------
path : string
Well path.
output_folder : string
Folder to store images. If not given well path is used.
Returns
-------
output_fil... | python | {
"resource": ""
} |
q264159 | compress | validation | def compress(images, delete_tif=False, folder=None):
"""Lossless compression. Save images as PNG and TIFF tags to json. Can be
reversed with `decompress`. Will run in multiprocessing, where
number of workers is decided by ``leicaexperiment.experiment._pools``.
Parameters
----------
images : lis... | python | {
"resource": ""
} |
q264160 | compress_blocking | validation | def compress_blocking(image, delete_tif=False, folder=None, force=False):
"""Lossless compression. Save image as PNG and TIFF tags to json. Process
can be reversed with `decompress`.
Parameters
----------
image : string
TIF-image which should be compressed lossless.
delete_tif : bool
... | python | {
"resource": ""
} |
q264161 | _set_path | validation | def _set_path(self, path):
"Set self.path, self.dirname and self.basename."
import os.path
self.path = os.path.abspath(path)
self.dirname = os.path.dirname(path)
self.basename = os.path.basename(path) | python | {
"resource": ""
} |
q264162 | Experiment.images | validation | def images(self):
"List of paths to images."
tifs = _pattern(self._image_path, extension='tif')
pngs = _pattern(self._image_path, extension='png')
imgs = []
imgs.extend(glob(tifs))
imgs.extend(glob(pngs))
return imgs | python | {
"resource": ""
} |
q264163 | Experiment.image | validation | def image(self, well_row, well_column, field_row, field_column):
"""Get path of specified image.
Parameters
----------
well_row : int
Starts at 0. Same as --U in files.
well_column : int
Starts at 0. Same as --V in files.
field_row : int
... | python | {
"resource": ""
} |
q264164 | Experiment.well_images | validation | def well_images(self, well_row, well_column):
"""Get list of paths to images in specified well.
Parameters
----------
well_row : int
Starts at 0. Same as --V in files.
well_column : int
Starts at 0. Save as --U in files.
Returns
-------
... | python | {
"resource": ""
} |
q264165 | Experiment.stitch | validation | def stitch(self, folder=None):
"""Stitches all wells in experiment with ImageJ. Stitched images are
saved in experiment root.
Images which already exists are omitted stitching.
Parameters
----------
folder : string
Where to store stitched images. Defaults to... | python | {
"resource": ""
} |
q264166 | Experiment.compress | validation | def compress(self, delete_tif=False, folder=None):
"""Lossless compress all images in experiment to PNG. If folder is
omitted, images will not be moved.
Images which already exists in PNG are omitted.
Parameters
----------
folder : string
Where to store PNGs... | python | {
"resource": ""
} |
q264167 | Experiment.field_metadata | validation | def field_metadata(self, well_row=0, well_column=0,
field_row=0, field_column=0):
"""Get OME-XML metadata of given field.
Parameters
----------
well_row : int
Y well coordinate. Same as --V in files.
well_column : int
X well coordin... | python | {
"resource": ""
} |
q264168 | Experiment.stitch_coordinates | validation | def stitch_coordinates(self, well_row=0, well_column=0):
"""Get a list of stitch coordinates for the given well.
Parameters
----------
well_row : int
Y well coordinate. Same as --V in files.
well_column : int
X well coordinate. Same as --U in files.
... | python | {
"resource": ""
} |
q264169 | Droplets.create | validation | def create(self, name, region, size, image, ssh_keys=None,
backups=None, ipv6=None, private_networking=None, wait=True):
"""
Create a new droplet
Parameters
----------
name: str
Name of new droplet
region: str
slug for region (e.g.,... | python | {
"resource": ""
} |
q264170 | Droplets.get | validation | def get(self, id):
"""
Retrieve a droplet by id
Parameters
----------
id: int
droplet id
Returns
-------
droplet: DropletActions
"""
info = self._get_droplet_info(id)
return DropletActions(self.api, self, **info) | python | {
"resource": ""
} |
q264171 | DropletActions.restore | validation | def restore(self, image, wait=True):
"""
Restore this droplet with given image id
A Droplet restoration will rebuild an image using a backup image.
The image ID that is passed in must be a backup of the current Droplet
instance. The operation will leave any embedded SSH keys int... | python | {
"resource": ""
} |
q264172 | DropletActions.rebuild | validation | def rebuild(self, image, wait=True):
"""
Rebuild this droplet with given image id
Parameters
----------
image: int or str
int for image id and str for image slug
wait: bool, default True
Whether to block until the pending action is completed
... | python | {
"resource": ""
} |
q264173 | DropletActions.rename | validation | def rename(self, name, wait=True):
"""
Change the name of this droplet
Parameters
----------
name: str
New name for the droplet
wait: bool, default True
Whether to block until the pending action is completed
Raises
------
... | python | {
"resource": ""
} |
q264174 | DropletActions.change_kernel | validation | def change_kernel(self, kernel_id, wait=True):
"""
Change the kernel of this droplet
Parameters
----------
kernel_id: int
Can be retrieved from output of self.kernels()
wait: bool, default True
Whether to block until the pending action is complete... | python | {
"resource": ""
} |
q264175 | DropletActions.delete | validation | def delete(self, wait=True):
"""
Delete this droplet
Parameters
----------
wait: bool, default True
Whether to block until the pending action is completed
"""
resp = self.parent.delete(self.id)
if wait:
self.wait()
return r... | python | {
"resource": ""
} |
q264176 | DropletActions.wait | validation | def wait(self):
"""
wait for all actions to complete on a droplet
"""
interval_seconds = 5
while True:
actions = self.actions()
slept = False
for a in actions:
if a['status'] == 'in-progress':
# n.b. gevent w... | python | {
"resource": ""
} |
q264177 | DropletActions.connect | validation | def connect(self, interactive=False):
"""
Open SSH connection to droplet
Parameters
----------
interactive: bool, default False
If True then SSH client will prompt for password when necessary
and also print output to console
"""
from posei... | python | {
"resource": ""
} |
q264178 | RestAPI.send_request | validation | def send_request(self, kind, resource, url_components, **kwargs):
"""
Send a request to the REST API
Parameters
----------
kind: str, {get, delete, put, post, head}
resource: str
url_components: list or tuple to be appended to the request URL
Notes
... | python | {
"resource": ""
} |
q264179 | RestAPI.format_parameters | validation | def format_parameters(self, **kwargs):
"""
Properly formats array types
"""
req_data = {}
for k, v in kwargs.items():
if isinstance(v, (list, tuple)):
k = k + '[]'
req_data[k] = v
return req_data | python | {
"resource": ""
} |
q264180 | DigitalOceanAPI.format_request_url | validation | def format_request_url(self, resource, *args):
"""create request url for resource"""
return '/'.join((self.api_url, self.api_version, resource) +
tuple(str(x) for x in args)) | python | {
"resource": ""
} |
q264181 | Resource.send_request | validation | def send_request(self, kind, url_components, **kwargs):
"""
Send a request for this resource to the API
Parameters
----------
kind: str, {'get', 'delete', 'put', 'post', 'head'}
"""
return self.api.send_request(kind, self.resource_path, url_components,
... | python | {
"resource": ""
} |
q264182 | ResourceCollection.list | validation | def list(self, url_components=()):
"""
Send list request for all members of a collection
"""
resp = self.get(url_components)
return resp.get(self.result_key, []) | python | {
"resource": ""
} |
q264183 | MutableCollection.get | validation | def get(self, id, **kwargs):
"""
Get single unit of collection
"""
return (super(MutableCollection, self).get((id,), **kwargs)
.get(self.singular, None)) | python | {
"resource": ""
} |
q264184 | ImageActions.transfer | validation | def transfer(self, region):
"""
Transfer this image to given region
Parameters
----------
region: str
region slug to transfer to (e.g., sfo1, nyc1)
"""
action = self.post(type='transfer', region=region)['action']
return self.parent.get(action[... | python | {
"resource": ""
} |
q264185 | Images.get | validation | def get(self, id):
"""id or slug"""
info = super(Images, self).get(id)
return ImageActions(self.api, parent=self, **info) | python | {
"resource": ""
} |
q264186 | Keys.update | validation | def update(self, id, name):
"""id or fingerprint"""
return super(Keys, self).update(id, name=name) | python | {
"resource": ""
} |
q264187 | Domains.create | validation | def create(self, name, ip_address):
"""
Creates a new domain
Parameters
----------
name: str
new domain name
ip_address: str
IP address for the new domain
"""
return (self.post(name=name, ip_address=ip_address)
.get... | python | {
"resource": ""
} |
q264188 | Domains.records | validation | def records(self, name):
"""
Get a list of all domain records for the given domain name
Parameters
----------
name: str
domain name
"""
if self.get(name):
return DomainRecords(self.api, name) | python | {
"resource": ""
} |
q264189 | DomainRecords.rename | validation | def rename(self, id, name):
"""
Change the name of this domain record
Parameters
----------
id: int
domain record id
name: str
new name of record
"""
return super(DomainRecords, self).update(id, name=name)[self.singular] | python | {
"resource": ""
} |
q264190 | DomainRecords.get | validation | def get(self, id, **kwargs):
"""
Retrieve a single domain record given the id
"""
return super(DomainRecords, self).get(id, **kwargs) | python | {
"resource": ""
} |
q264191 | FogBugz.logon | validation | def logon(self, username, password):
"""
Logs the user on to FogBugz.
Returns None for a successful login.
"""
if self._token:
self.logoff()
try:
response = self.__makerequest(
'logon', email=username, password=password)
ex... | python | {
"resource": ""
} |
q264192 | chop | validation | def chop(list_, n):
"Chop list_ into n chunks. Returns a list."
# could look into itertools also, might be implemented there
size = len(list_)
each = size // n
if each == 0:
return [list_]
chopped = []
for i in range(n):
start = i * each
end = (i+1) * each
if ... | python | {
"resource": ""
} |
q264193 | get_first | validation | def get_first():
"""
return first droplet
"""
client = po.connect() # this depends on the DIGITALOCEAN_API_KEY envvar
all_droplets = client.droplets.list()
id = all_droplets[0]['id'] # I'm cheating because I only have one droplet
return client.droplets.get(id) | python | {
"resource": ""
} |
q264194 | take_snapshot | validation | def take_snapshot(droplet, name):
"""
Take a snapshot of a droplet
Parameters
----------
name: str
name for snapshot
"""
print "powering off"
droplet.power_off()
droplet.wait() # wait for pending actions to complete
print "taking snapshot"
droplet.take_snapshot(name)... | python | {
"resource": ""
} |
q264195 | ManagedResource.allowed_operations | validation | def allowed_operations(self):
"""Retrieves the allowed operations for this request."""
if self.slug is not None:
return self.meta.detail_allowed_operations
return self.meta.list_allowed_operations | python | {
"resource": ""
} |
q264196 | ManagedResource.assert_operations | validation | def assert_operations(self, *args):
"""Assets if the requested operations are allowed in this context."""
if not set(args).issubset(self.allowed_operations):
raise http.exceptions.Forbidden() | python | {
"resource": ""
} |
q264197 | ManagedResource.make_response | validation | def make_response(self, data=None):
"""Fills the response object from the passed data."""
if data is not None:
# Prepare the data for transmission.
data = self.prepare(data)
# Encode the data using a desired encoder.
self.response.write(data, serialize=Tr... | python | {
"resource": ""
} |
q264198 | ManagedResource.get | validation | def get(self, request, response):
"""Processes a `GET` request."""
# Ensure we're allowed to read the resource.
self.assert_operations('read')
# Delegate to `read` to retrieve the items.
items = self.read()
# if self.slug is not None and not items:
# # Reque... | python | {
"resource": ""
} |
q264199 | ManagedResource.post | validation | def post(self, request, response):
"""Processes a `POST` request."""
if self.slug is not None:
# Don't know what to do an item access.
raise http.exceptions.NotImplemented()
# Ensure we're allowed to create a resource.
self.assert_operations('create')
# ... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.