INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
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. | 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... |
Try to push a local stream to an external destination. The pushed stream can only use the RTMP RTSP or MPEG - TS unicast/ multicast protocol. | def push_stream(self, uri, **kwargs):
"""
Try to push a local stream to an external destination. The pushed
stream can only use the RTMP, RTSP or MPEG-TS unicast/multicast
protocol.
:param uri: The URI of the external stream. Can be RTMP, RTSP or
unicast/multicast (d... |
Create an HTTP Live Stream ( HLS ) out of an existing H. 264/ AAC stream. HLS is used to stream live feeds to iOS devices such as iPhones and iPads. | def create_hls_stream(self, localStreamNames, targetFolder, **kwargs):
"""
Create an HTTP Live Stream (HLS) out of an existing H.264/AAC stream.
HLS is used to stream live feeds to iOS devices such as iPhones and
iPads.
:param localStreamNames: The stream(s) that will be used as... |
Create an HDS ( HTTP Dynamic Streaming ) stream out of an existing H. 264/ AAC stream. HDS is used to stream standard MP4 media over regular HTTP connections. | def create_hds_stream(self, localStreamNames, targetFolder, **kwargs):
"""
Create an HDS (HTTP Dynamic Streaming) stream out of an existing
H.264/AAC stream. HDS is used to stream standard MP4 media over
regular HTTP connections.
:param localStreamNames: The stream(s) that will ... |
Create a Microsoft Smooth Stream ( MSS ) out of an existing H. 264/ AAC stream. Smooth Streaming was developed by Microsoft to compete with other adaptive streaming technologies. | def create_mss_stream(self, localStreamNames, targetFolder, **kwargs):
"""
Create a Microsoft Smooth Stream (MSS) out of an existing H.264/AAC
stream. Smooth Streaming was developed by Microsoft to compete with
other adaptive streaming technologies.
:param localStreamNames: The ... |
Create Dynamic Adaptive Streaming over HTTP ( DASH ) out of an existing H. 264/ AAC stream. DASH was developed by the Moving Picture Experts Group ( MPEG ) to establish a standard for HTTP adaptive - bitrate streaming that would be accepted by multiple vendors and facilitate interoperability. | def create_dash_stream(self, localStreamNames, targetFolder, **kwargs):
"""
Create Dynamic Adaptive Streaming over HTTP (DASH) out of an existing
H.264/AAC stream. DASH was developed by the Moving Picture Experts
Group (MPEG) to establish a standard for HTTP adaptive-bitrate
stre... |
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. | 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... |
Changes the compression characteristics of an audio and/ or video stream. Allows you to change the resolution of a source stream change the bitrate of a stream change a VP8 or MPEG2 stream into H. 264 and much more. Allow users to create overlays on the final stream as well as crop streams. | def transcode(self, source, destinations, **kwargs):
"""
Changes the compression characteristics of an audio and/or video
stream. Allows you to change the resolution of a source stream, change
the bitrate of a stream, change a VP8 or MPEG2 stream into H.264 and
much more. Allow u... |
Allows you to create secondary name ( s ) for internal streams. Once an alias is created the localstreamname cannot be used to request playback of that stream. Once an alias is used ( requested by a client ) the alias is removed. Aliases are designed to be used to protect/ hide your source streams. | def add_stream_alias(self, localStreamName, aliasName, **kwargs):
"""
Allows you to create secondary name(s) for internal streams. Once an
alias is created the localstreamname cannot be used to request
playback of that stream. Once an alias is used (requested by a client)
the ali... |
Creates secondary name ( s ) for group names. Once an alias is created the group name cannot be used to request HTTP playback of that stream. Once an alias is used ( requested by a client ) the alias is removed. Aliases are designed to be used to protect/ hide your source streams. | def add_group_name_alias(self, groupName, aliasName):
"""
Creates secondary name(s) for group names. Once an alias is created the
group name cannot be used to request HTTP playback of that stream. Once
an alias is used (requested by a client) the alias is removed. Aliases
are des... |
Creates an RTMP ingest point which mandates that streams pushed into the EMS have a target stream name which matches one Ingest Point privateStreamName. | 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... |
Starts a WebRTC signalling client to an ERS ( Evostream Rendezvous Server ). | def start_web_rtc(self, ersip, ersport, roomId):
"""
Starts a WebRTC signalling client to an ERS (Evostream Rendezvous
Server).
:param ersip: IP address (xx.yy.zz.xx) of ERS.
:type ersip: str
:param ersport: IP port of ERS.
:type ersport: int
:param roo... |
Instantiate the generator and filename specification | 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 ... |
Materialize queries/ other content within the repo. | def transform(repo,
name=None,
filename=None,
force=False,
args=[]):
"""
Materialize queries/other content within the repo.
Parameters
----------
repo: Repository object
name: Name of transformer, if any. If none, then all transformers sp... |
Helper function to run commands | 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()
... |
Run a generic command within the repo. Assumes that you are in the repo s root directory | 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 ... |
Initialize a Git repo | 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 (... |
Clone a URL | def clone(self, url, backend=None):
"""
Clone a URL
Parameters
----------
url : URL of the repo. Supports s3://, git@, http://
"""
# s3://bucket/git/username/repo.git
username = self.username
reponame = url.split("/")[-1] # with git
rep... |
Delete files from the repo | 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)
... |
Cleanup the repo | 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... |
Get the permalink to command that generated the dataset | 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... |
Add files to the repo | 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... |
Paramers: --------- | def config(self, what='get', params=None):
"""
Paramers:
---------
workspace: Directory to store the dataset repositories
email:
"""
if what == 'get':
return {
'name': 'git',
'nature': 'repomanager',
'va... |
Creates the base set of attributes invoice has/ needs | def _init_empty(self):
"""Creates the base set of attributes invoice has/needs"""
self._jsondata = {
"code": None,
"currency": "EUR",
"subject": "",
"due_date": (datetime.datetime.now().date() + datetime.timedelta(days=14)).isoformat(),
"issue_... |
Marks the invoice as sent in Holvi | 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... |
Convert our Python object to JSON acceptable to Holvi API | 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... |
Saves this invoice to Holvi returns the created/ updated invoice | def save(self):
"""Saves this invoice to Holvi, returns the created/updated invoice"""
if not self.items:
raise HolviError("No items")
if not self.subject:
raise HolviError("No subject")
send_json = self.to_holvi_dict()
if self.code:
url = str(... |
Returns the: class: PluginSource for the current module or the given module. The module can be provided by name ( in which case an import will be attempted ) or as a module object. | def get_plugin_source(module=None, stacklevel=None):
"""Returns the :class:`PluginSource` for the current module or the given
module. The module can be provided by name (in which case an import
will be attempted) or as a module object.
If no plugin source can be discovered, the return value from this ... |
Returns a sorted list of all plugins that are available in this plugin source. This can be useful to automatically discover plugins that are available and is usually used together with: meth: load_plugin. | def list_plugins(self):
"""Returns a sorted list of all plugins that are available in this
plugin source. This can be useful to automatically discover plugins
that are available and is usually used together with
:meth:`load_plugin`.
"""
rv = []
for _, modname, is... |
This automatically loads a plugin by the given name from the current source and returns the module. This is a convenient alternative to the import statement and saves you from invoking __import__ or a similar function yourself. | def load_plugin(self, name):
"""This automatically loads a plugin by the given name from the
current source and returns the module. This is a convenient
alternative to the import statement and saves you from invoking
``__import__`` or a similar function yourself.
:param name: t... |
This function locates a resource inside the plugin and returns a byte stream to the contents of it. If the resource cannot be loaded an: exc: IOError will be raised. Only plugins that are real Python packages can contain resources. Plain old Python modules do not allow this for obvious reasons. | def open_resource(self, plugin, filename):
"""This function locates a resource inside the plugin and returns
a byte stream to the contents of it. If the resource cannot be
loaded an :exc:`IOError` will be raised. Only plugins that are
real Python packages can contain resources. Plain ... |
API wrapper documentation | 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 |
Transmit a series of bytes: param message: a list of bytes to send: return: None | def tx(self, message):
"""
Transmit a series of bytes
:param message: a list of bytes to send
:return: None
"""
message = message if isinstance(message, list) else [message]
length = len(message)
length_high_byte = (length & 0xff00) >> 8
length_lo... |
Receive a series of bytes that have been verified: return: a series of bytes as a tuple or None if empty | def rx(self):
"""
Receive a series of bytes that have been verified
:return: a series of bytes as a tuple or None if empty
"""
if not self._threaded:
self.run()
try:
return tuple(self._messages.pop(0))
except IndexError:
return... |
Parses the incoming data and determines if it is valid. Valid data gets placed into self. _messages: return: None | def _parse_raw_data(self):
"""
Parses the incoming data and determines if it is valid. Valid
data gets placed into self._messages
:return: None
"""
if self._START_OF_FRAME in self._raw and self._END_OF_FRAME in self._raw:
while self._raw[0] != self._START_OF... |
Calculates a fletcher16 checksum for the list of bytes: param data: a list of bytes that comprise the message: return: | def _fletcher16_checksum(self, data):
"""
Calculates a fletcher16 checksum for the list of bytes
:param data: a list of bytes that comprise the message
:return:
"""
sum1 = 0
sum2 = 0
for i, b in enumerate(data):
sum1 += b
sum1 &= 0... |
Removes any escape characters from the message: param raw_message: a list of bytes containing the un - processed data: return: a message that has the escaped characters appropriately un - escaped | def _remove_esc_chars(self, raw_message):
"""
Removes any escape characters from the message
:param raw_message: a list of bytes containing the un-processed data
:return: a message that has the escaped characters appropriately un-escaped
"""
message = []
escape_ne... |
Receives the serial data into the self. _raw buffer: return: | def run(self):
"""
Receives the serial data into the self._raw buffer
:return:
"""
run_once = True
while run_once or self._threaded:
waiting = self._port.in_waiting
if waiting > 0:
temp = [int(c) for c in self._port.read(waiting)]
... |
Saves this order to Holvi returns a tuple with the order itself and checkout_uri | 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
})
... |
Return source code based on tokens. | 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().
""... |
Load profile INI | 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... |
Update the profile | 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... |
Insert hook into the repo | 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
... |
Try the library. If it doesnt work use the command line.. | 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... |
Run a shell command | 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,
... |
Log all repo actions to. dgit/ log. json | def log_repo_action(func):
"""
Log all repo actions to .dgit/log.json
"""
def _inner(*args, **kwargs):
result = func(*args, **kwargs)
log_action(func, result, *args, **kwargs)
return result
_inner.__name__ = func.__name__
_inner.__doc__ = fun... |
Get the commit history for a given dataset | 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": "... |
Look at files and compute the diffs intelligently | 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... |
Parameters ---------- new_pwd: str Directory to change to relative: bool default True If True then the given directory is treated as relative to the current directory | def chdir(self, new_pwd, relative=True):
"""
Parameters
----------
new_pwd: str,
Directory to change to
relative: bool, default True
If True then the given directory is treated as relative to the
current directory
"""
if new_pwd... |
Proceed with caution if you run a command that causes a prompt and then try to read/ print the stdout it s going to block forever | def exec_command(self, cmd):
"""
Proceed with caution, if you run a command that causes a prompt and then
try to read/print the stdout it's going to block forever
Returns
-------
(stdin, stdout, stderr)
"""
if self.pwd is not None:
cmd = 'cd %... |
Execute command and wait for it to finish. Proceed with caution because if you run a command that causes a prompt this will hang | 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 =... |
Enter sudo mode | 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)
... |
Install specified packages using apt - get. - y options are automatically used. Waits for command to finish. | 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
... |
Install specified python packages using pip. - U option added Waits for command to finish. | 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... |
Install all requirements contained in the given file path Waits for command to finish. | 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
... |
Parameters ---------- token: str default None Assumes you have GITHUB_TOKEN in envvar if None | def git(self, username, repo, alias=None, token=None):
"""
Parameters
----------
token: str, default None
Assumes you have GITHUB_TOKEN in envvar if None
https://github.com/blog/1270-easier-builds-and-deployments-using-git-
over-https-and-oauth
"""
... |
Create fiji - macros for stitching all channels and z - stacks for a well. | 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... |
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. | 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... |
Lossless compression. Save image as PNG and TIFF tags to json. Process can be reversed with decompress. | 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
... |
Reverse compression from tif to png and save them in original format ( ome. tif ). TIFF - tags are gotten from json - files named the same as given images. | def decompress(images, delete_png=False, delete_json=False, folder=None):
"""Reverse compression from tif to png and save them in original format
(ome.tif). TIFF-tags are gotten from json-files named the same as given
images.
Parameters
----------
images : list of filenames
Image to de... |
Returns the two numbers found behind -- [ A - Z ] in path. If several matches are found the last one is returned. | def attribute(path, name):
"""Returns the two numbers found behind --[A-Z] in path. If several matches
are found, the last one is returned.
Parameters
----------
path : string
String with path of file/folder to get attribute from.
name : string
Name of attribute to get. Should b... |
Returns the two numbers found behind -- [ A - Z ] in path. If several matches are found the last one is returned. | def attribute_as_str(path, name):
"""Returns the two numbers found behind --[A-Z] in path. If several matches
are found, the last one is returned.
Parameters
----------
path : string
String with path of file/folder to get attribute from.
name : string
Name of attribute to get. S... |
Get attributes from path based on format -- [ A - Z ]. Returns namedtuple with upper case attributes equal to what found in path ( string ) and lower case as int. If path holds several occurrences of same character only the last one is kept. | def attributes(path):
"""Get attributes from path based on format --[A-Z]. Returns namedtuple
with upper case attributes equal to what found in path (string) and lower
case as int. If path holds several occurrences of same character, only the
last one is kept.
>>> attrs = attributes('/folder/fi... |
Returns globbing pattern for name1/ name2/../ lastname + -- * or name1/ name2/../ lastname + extension if parameter extension it set. | def _pattern(*names, **kwargs):
"""Returns globbing pattern for name1/name2/../lastname + '--*' or
name1/name2/../lastname + extension if parameter `extension` it set.
Parameters
----------
names : strings
Which path to join. Example: _pattern('path', 'to', 'experiment') will
return... |
Set self. path self. dirname and self. basename. | 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) |
List of paths to images. | 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 |
Path to { ScanningTemplate } name. xml of experiment. | def scanning_template(self):
"Path to {ScanningTemplate}name.xml of experiment."
tmpl = glob(_pattern(self.path, _additional_data, _scanning_template,
extension='*.xml'))
if tmpl:
return tmpl[0]
else:
return '' |
All well rows in experiment. Equivalent to -- U in files. | def well_rows(self, well_row, well_column):
"""All well rows in experiment. Equivalent to --U in files.
Returns
-------
list of ints
"""
return list(set([attribute(img, 'u') for img in self.images])) |
Get path of specified image. | 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
... |
Get list of paths to images in specified well. | 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
-------
... |
Field columns for given well. Equivalent to -- X in files. | def field_columns(self, well_row, well_column):
"""Field columns for given well. Equivalent to --X in files.
Parameters
----------
well_row : int
Starts at 0. Same as --V in files.
well_column : int
Starts at 0. Same as --U in files.
Returns
... |
Stitches all wells in experiment with ImageJ. Stitched images are saved in experiment root. | 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... |
Lossless compress all images in experiment to PNG. If folder is omitted images will not be moved. | 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... |
Get OME - XML metadata of given field. | 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... |
Get a list of stitch coordinates for the given well. | 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.
... |
Create a new droplet | 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.,... |
Retrieve a droplet by id | 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) |
Retrieve a droplet by name ( return first if duplicated ) | def by_name(self, name):
"""
Retrieve a droplet by name (return first if duplicated)
Parameters
----------
name: str
droplet name
Returns
-------
droplet: DropletActions
"""
for d in self.list():
if d['name'] == na... |
Change the size of this droplet ( must be powered off ) | def resize(self, size, wait=True):
"""
Change the size of this droplet (must be powered off)
Parameters
----------
size: str
size slug, e.g., 512mb
wait: bool, default True
Whether to block until the pending action is completed
"""
... |
Restore this droplet with given image id | 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... |
Rebuild this droplet with given image id | 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
... |
Change the name of this droplet | 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
------
... |
Change the kernel of this droplet | 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... |
Take a snapshot of this droplet ( must be powered off ) | def take_snapshot(self, name, wait=True):
"""
Take a snapshot of this droplet (must be powered off)
Parameters
----------
name: str
Name of the snapshot
wait: bool, default True
Whether to block until the pending action is completed
"""
... |
Delete this droplet | 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... |
wait for all actions to complete on a droplet | 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... |
Public ip_address | def ip_address(self):
"""
Public ip_address
"""
ip = None
for eth in self.networks['v4']:
if eth['type'] == 'public':
ip = eth['ip_address']
break
if ip is None:
raise ValueError("No public IP found")
return ... |
Private ip_address | def private_ip(self):
"""
Private ip_address
"""
ip = None
for eth in self.networks['v4']:
if eth['type'] == 'private':
ip = eth['ip_address']
break
if ip is None:
raise ValueError("No private IP found")
retu... |
Open SSH connection to droplet | 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... |
Send a request to the REST API | 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
... |
Properly formats array types | 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 |
create request url for resource | 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)) |
Send a request for this resource to the API | 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,
... |
Send list request for all members of a collection | 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, []) |
Get single unit of collection | def get(self, id, **kwargs):
"""
Get single unit of collection
"""
return (super(MutableCollection, self).get((id,), **kwargs)
.get(self.singular, None)) |
Transfer this image to given region | 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[... |
id or slug | def get(self, id):
"""id or slug"""
info = super(Images, self).get(id)
return ImageActions(self.api, parent=self, **info) |
id or fingerprint | def update(self, id, name):
"""id or fingerprint"""
return super(Keys, self).update(id, name=name) |
Creates a new domain | 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... |
Get a list of all domain records for the given domain name | 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) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.