index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
5,833 | boto.storage_uri | exists | Returns True if the object exists or False if it doesn't | def exists(self, headers=None):
"""Returns True if the object exists or False if it doesn't"""
if not self.object_name:
raise InvalidUriError('exists on object-less URI (%s)' % self.uri)
bucket = self.get_bucket(headers)
key = bucket.get_key(self.object_name, headers=headers)
return bool(key)
| (self, headers=None) |
5,834 | boto.storage_uri | get_acl | returns a bucket's acl | def get_acl(self, validate=False, headers=None, version_id=None):
"""returns a bucket's acl"""
self._check_bucket_uri('get_acl')
bucket = self.get_bucket(validate, headers)
# This works for both bucket- and object- level ACLs (former passes
# key_name=None):
key_name = self.object_name or ''
if self.get_provider().name == 'aws':
version_id = version_id or self.version_id
acl = bucket.get_acl(key_name, headers, version_id)
else:
acl = bucket.get_acl(key_name, headers, generation=self.generation)
self.check_response(acl, 'acl', self.uri)
return acl
| (self, validate=False, headers=None, version_id=None) |
5,835 | boto.storage_uri | get_all_buckets | null | def get_all_buckets(self, headers=None):
conn = self.connect()
return conn.get_all_buckets(headers)
| (self, headers=None) |
5,836 | boto.storage_uri | get_all_keys | null | def get_all_keys(self, validate=False, headers=None, prefix=None):
bucket = self.get_bucket(validate, headers)
return bucket.get_all_keys(headers)
| (self, validate=False, headers=None, prefix=None) |
5,837 | boto.storage_uri | get_billing_config | null | def get_billing_config(self, headers=None):
self._check_bucket_uri('get_billing_config')
# billing is defined as a bucket param for GCS, but not for S3.
if self.scheme != 'gs':
raise ValueError('get_billing_config() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(False, headers)
return bucket.get_billing_config(headers)
| (self, headers=None) |
5,838 | boto.storage_uri | get_bucket | null | def get_bucket(self, validate=False, headers=None):
self._check_bucket_uri('get_bucket')
conn = self.connect()
bucket = conn.get_bucket(self.bucket_name, validate, headers)
self.check_response(bucket, 'bucket', self.uri)
return bucket
| (self, validate=False, headers=None) |
5,839 | boto.storage_uri | get_contents_as_string | null | def get_contents_as_string(self, validate=False, headers=None, cb=None,
num_cb=10, torrent=False, version_id=None):
self._check_object_uri('get_contents_as_string')
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
return key.get_contents_as_string(headers, cb, num_cb, torrent,
version_id)
| (self, validate=False, headers=None, cb=None, num_cb=10, torrent=False, version_id=None) |
5,840 | boto.storage_uri | get_contents_to_file | null | def get_contents_to_file(self, fp, headers=None, cb=None, num_cb=10,
torrent=False, version_id=None,
res_download_handler=None, response_headers=None,
hash_algs=None):
self._check_object_uri('get_contents_to_file')
key = self.get_key(None, headers)
self.check_response(key, 'key', self.uri)
if hash_algs:
key.get_contents_to_file(fp, headers, cb, num_cb, torrent,
version_id, res_download_handler,
response_headers,
hash_algs=hash_algs)
else:
key.get_contents_to_file(fp, headers, cb, num_cb, torrent,
version_id, res_download_handler,
response_headers)
| (self, fp, headers=None, cb=None, num_cb=10, torrent=False, version_id=None, res_download_handler=None, response_headers=None, hash_algs=None) |
5,841 | boto.storage_uri | get_contents_to_stream | null | def get_contents_to_stream(self, fp, headers=None, version_id=None):
self._check_object_uri('get_key')
self._warn_about_args('get_key', validate=False)
key = self.get_key(None, headers)
self.check_response(key, 'key', self.uri)
return key.get_contents_to_file(fp, headers, version_id=version_id)
| (self, fp, headers=None, version_id=None) |
5,842 | boto.storage_uri | get_cors | returns a bucket's CORS XML | def get_cors(self, validate=False, headers=None):
"""returns a bucket's CORS XML"""
self._check_bucket_uri('get_cors')
bucket = self.get_bucket(validate, headers)
cors = bucket.get_cors(headers)
self.check_response(cors, 'cors', self.uri)
return cors
| (self, validate=False, headers=None) |
5,843 | boto.storage_uri | get_def_acl | returns a bucket's default object acl | def get_def_acl(self, validate=False, headers=None):
"""returns a bucket's default object acl"""
self._check_bucket_uri('get_def_acl')
bucket = self.get_bucket(validate, headers)
acl = bucket.get_def_acl(headers)
self.check_response(acl, 'acl', self.uri)
return acl
| (self, validate=False, headers=None) |
5,844 | boto.storage_uri | get_encryption_config | Returns a GCS bucket's encryption configuration. | def get_encryption_config(self, validate=False, headers=None):
"""Returns a GCS bucket's encryption configuration."""
self._check_bucket_uri('get_encryption_config')
# EncryptionConfiguration is defined as a bucket param for GCS, but not
# for S3.
if self.scheme != 'gs':
raise ValueError('get_encryption_config() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(validate, headers)
return bucket.get_encryption_config(headers=headers)
| (self, validate=False, headers=None) |
5,845 | boto.storage_uri | get_key | null | def get_key(self, validate=False, headers=None, version_id=None):
self._check_object_uri('get_key')
bucket = self.get_bucket(validate, headers)
if self.get_provider().name == 'aws':
key = bucket.get_key(self.object_name, headers,
version_id=(version_id or self.version_id))
elif self.get_provider().name == 'google':
key = bucket.get_key(self.object_name, headers,
generation=self.generation)
self.check_response(key, 'key', self.uri)
return key
| (self, validate=False, headers=None, version_id=None) |
5,846 | boto.storage_uri | get_lifecycle_config | Returns a bucket's lifecycle configuration. | def get_lifecycle_config(self, validate=False, headers=None):
"""Returns a bucket's lifecycle configuration."""
self._check_bucket_uri('get_lifecycle_config')
bucket = self.get_bucket(validate, headers)
lifecycle_config = bucket.get_lifecycle_config(headers)
self.check_response(lifecycle_config, 'lifecycle', self.uri)
return lifecycle_config
| (self, validate=False, headers=None) |
5,847 | boto.storage_uri | get_location | null | def get_location(self, validate=False, headers=None):
self._check_bucket_uri('get_location')
bucket = self.get_bucket(validate, headers)
return bucket.get_location(headers)
| (self, validate=False, headers=None) |
5,848 | boto.storage_uri | get_logging_config | null | def get_logging_config(self, validate=False, headers=None, version_id=None):
self._check_bucket_uri('get_logging_config')
bucket = self.get_bucket(validate, headers)
return bucket.get_logging_config(headers=headers)
| (self, validate=False, headers=None, version_id=None) |
5,849 | boto.storage_uri | get_provider | null | def get_provider(self):
conn = self.connect()
provider = conn.provider
self.check_response(provider, 'provider', self.uri)
return provider
| (self) |
5,850 | boto.storage_uri | get_storage_class | null | def get_storage_class(self, validate=False, headers=None):
self._check_bucket_uri('get_storage_class')
# StorageClass is defined as a bucket and object param for GCS, but
# only as a key param for S3.
if self.scheme != 'gs':
raise ValueError('get_storage_class() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(validate, headers)
return bucket.get_storage_class(headers)
| (self, validate=False, headers=None) |
5,851 | boto.storage_uri | get_subresource | null | def get_subresource(self, subresource, validate=False, headers=None,
version_id=None):
self._check_bucket_uri('get_subresource')
bucket = self.get_bucket(validate, headers)
return bucket.get_subresource(subresource, self.object_name, headers,
version_id)
| (self, subresource, validate=False, headers=None, version_id=None) |
5,852 | boto.storage_uri | get_versioning_config | null | def get_versioning_config(self, headers=None):
self._check_bucket_uri('get_versioning_config')
bucket = self.get_bucket(False, headers)
return bucket.get_versioning_status(headers)
| (self, headers=None) |
5,853 | boto.storage_uri | get_website_config | null | def get_website_config(self, validate=False, headers=None):
self._check_bucket_uri('get_website_config')
bucket = self.get_bucket(validate, headers)
return bucket.get_website_configuration(headers)
| (self, validate=False, headers=None) |
5,854 | boto.storage_uri | has_version | null | def has_version(self):
return (issubclass(type(self), BucketStorageUri)
and ((self.version_id is not None)
or (self.generation is not None)))
| (self) |
5,855 | boto.storage_uri | is_cloud_uri | Returns True if this URI names a bucket or object. | def is_cloud_uri(self):
"""Returns True if this URI names a bucket or object."""
return True
| (self) |
5,856 | boto.storage_uri | is_file_uri | Returns True if this URI names a file or directory. | def is_file_uri(self):
"""Returns True if this URI names a file or directory."""
return False
| (self) |
5,857 | boto.storage_uri | is_stream | Returns True if this URI represents input/output stream. | def is_stream(self):
"""Returns True if this URI represents input/output stream."""
return False
| (self) |
5,858 | boto.storage_uri | list_bucket | null | def list_bucket(self, prefix='', delimiter='', headers=None,
all_versions=False):
self._check_bucket_uri('list_bucket')
bucket = self.get_bucket(headers=headers)
if all_versions:
return (v for v in bucket.list_versions(
prefix=prefix, delimiter=delimiter, headers=headers)
if not isinstance(v, DeleteMarker))
else:
return bucket.list(prefix=prefix, delimiter=delimiter,
headers=headers)
| (self, prefix='', delimiter='', headers=None, all_versions=False) |
5,859 | boto.storage_uri | list_grants | null | def list_grants(self, headers=None):
self._check_bucket_uri('list_grants ')
bucket = self.get_bucket(headers)
return bucket.list_grants(headers)
| (self, headers=None) |
5,860 | boto.storage_uri | names_bucket | Returns True if this URI names a bucket. | def names_bucket(self):
"""Returns True if this URI names a bucket."""
return bool(self.bucket_name) and bool(not self.object_name)
| (self) |
5,861 | boto.storage_uri | names_container |
Returns True if this URI names a directory or bucket. Will return
False for bucket subdirs; providing bucket subdir semantics needs to
be done by the caller (like gsutil does).
| def names_container(self):
"""
Returns True if this URI names a directory or bucket. Will return
False for bucket subdirs; providing bucket subdir semantics needs to
be done by the caller (like gsutil does).
"""
return bool(not self.object_name)
| (self) |
5,862 | boto.storage_uri | names_directory | Returns True if this URI names a directory. | def names_directory(self):
"""Returns True if this URI names a directory."""
return False
| (self) |
5,863 | boto.storage_uri | names_file | Returns True if this URI names a file. | def names_file(self):
"""Returns True if this URI names a file."""
return False
| (self) |
5,864 | boto.storage_uri | names_object | Returns True if this URI names an object. | def names_object(self):
"""Returns True if this URI names an object."""
return self.names_singleton()
| (self) |
5,865 | boto.storage_uri | names_provider | Returns True if this URI names a provider. | def names_provider(self):
"""Returns True if this URI names a provider."""
return bool(not self.bucket_name)
| (self) |
5,866 | boto.storage_uri | names_singleton | Returns True if this URI names a file or object. | def names_singleton(self):
"""Returns True if this URI names a file or object."""
return bool(self.object_name)
| (self) |
5,867 | boto.storage_uri | new_key | null | def new_key(self, validate=False, headers=None):
self._check_object_uri('new_key')
bucket = self.get_bucket(validate, headers)
return bucket.new_key(self.object_name)
| (self, validate=False, headers=None) |
5,868 | boto.storage_uri | set_acl | Sets or updates a bucket's ACL. | def set_acl(self, acl_or_str, key_name='', validate=False, headers=None,
version_id=None, if_generation=None, if_metageneration=None):
"""Sets or updates a bucket's ACL."""
self._check_bucket_uri('set_acl')
key_name = key_name or self.object_name or ''
bucket = self.get_bucket(validate, headers)
if self.generation:
bucket.set_acl(
acl_or_str, key_name, headers, generation=self.generation,
if_generation=if_generation, if_metageneration=if_metageneration)
else:
version_id = version_id or self.version_id
bucket.set_acl(acl_or_str, key_name, headers, version_id)
| (self, acl_or_str, key_name='', validate=False, headers=None, version_id=None, if_generation=None, if_metageneration=None) |
5,869 | boto.storage_uri | set_canned_acl | Sets or updates a bucket's acl to a predefined (canned) value. | def set_canned_acl(self, acl_str, validate=False, headers=None,
version_id=None):
"""Sets or updates a bucket's acl to a predefined (canned) value."""
self._check_object_uri('set_canned_acl')
self._warn_about_args('set_canned_acl', version_id=version_id)
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.set_canned_acl(acl_str, headers)
| (self, acl_str, validate=False, headers=None, version_id=None) |
5,870 | boto.storage_uri | set_contents_from_file | null | def set_contents_from_file(self, fp, headers=None, replace=True, cb=None,
num_cb=10, policy=None, md5=None, size=None,
rewind=False, res_upload_handler=None):
self._check_object_uri('set_contents_from_file')
key = self.new_key(headers=headers)
if self.scheme == 'gs':
result = key.set_contents_from_file(
fp, headers, replace, cb, num_cb, policy, md5, size=size,
rewind=rewind, res_upload_handler=res_upload_handler)
if res_upload_handler:
self._update_from_values(None, res_upload_handler.generation,
None, md5)
else:
self._warn_about_args('set_contents_from_file',
res_upload_handler=res_upload_handler)
result = key.set_contents_from_file(
fp, headers, replace, cb, num_cb, policy, md5, size=size,
rewind=rewind)
self._update_from_key(key)
return result
| (self, fp, headers=None, replace=True, cb=None, num_cb=10, policy=None, md5=None, size=None, rewind=False, res_upload_handler=None) |
5,871 | boto.storage_uri | set_contents_from_stream | null | def set_contents_from_stream(self, fp, headers=None, replace=True, cb=None,
policy=None, reduced_redundancy=False):
self._check_object_uri('set_contents_from_stream')
dst_key = self.new_key(False, headers)
result = dst_key.set_contents_from_stream(
fp, headers, replace, cb, policy=policy,
reduced_redundancy=reduced_redundancy)
self._update_from_key(dst_key)
return result
| (self, fp, headers=None, replace=True, cb=None, policy=None, reduced_redundancy=False) |
5,872 | boto.storage_uri | set_contents_from_string | null | def set_contents_from_string(self, s, headers=None, replace=True,
cb=None, num_cb=10, policy=None, md5=None,
reduced_redundancy=False):
self._check_object_uri('set_contents_from_string')
key = self.new_key(headers=headers)
if self.scheme == 'gs':
if reduced_redundancy:
sys.stderr.write('Warning: GCS does not support '
'reduced_redundancy; argument ignored by '
'set_contents_from_string')
result = key.set_contents_from_string(
s, headers, replace, cb, num_cb, policy, md5)
else:
result = key.set_contents_from_string(
s, headers, replace, cb, num_cb, policy, md5,
reduced_redundancy)
self._update_from_key(key)
return result
| (self, s, headers=None, replace=True, cb=None, num_cb=10, policy=None, md5=None, reduced_redundancy=False) |
5,873 | boto.storage_uri | set_cors | sets or updates a bucket's CORS XML | def set_cors(self, cors, validate=False, headers=None):
"""sets or updates a bucket's CORS XML"""
self._check_bucket_uri('set_cors ')
bucket = self.get_bucket(validate, headers)
if self.scheme == 's3':
bucket.set_cors(cors, headers)
else:
bucket.set_cors(cors.to_xml(), headers)
| (self, cors, validate=False, headers=None) |
5,874 | boto.storage_uri | set_def_acl | Sets or updates a bucket's default object ACL. | def set_def_acl(self, acl_or_str, validate=False, headers=None,
version_id=None):
"""Sets or updates a bucket's default object ACL."""
self._check_bucket_uri('set_def_acl')
self.get_bucket(validate, headers).set_def_acl(acl_or_str, headers)
| (self, acl_or_str, validate=False, headers=None, version_id=None) |
5,875 | boto.storage_uri | set_def_canned_acl | Sets or updates a bucket's default object acl to a predefined
(canned) value. | def set_def_canned_acl(self, acl_str, validate=False, headers=None,
version_id=None):
"""Sets or updates a bucket's default object acl to a predefined
(canned) value."""
self._check_bucket_uri('set_def_canned_acl ')
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.set_def_canned_acl(acl_str, headers, version_id)
| (self, acl_str, validate=False, headers=None, version_id=None) |
5,876 | boto.storage_uri | set_def_xml_acl | Sets or updates a bucket's default object ACL with an XML string. | def set_def_xml_acl(self, xmlstring, validate=False, headers=None):
"""Sets or updates a bucket's default object ACL with an XML string."""
self._check_bucket_uri('set_def_xml_acl')
self.get_bucket(validate, headers).set_def_xml_acl(xmlstring, headers)
| (self, xmlstring, validate=False, headers=None) |
5,877 | boto.storage_uri | set_encryption_config | Sets a GCS bucket's encryption configuration. | def set_encryption_config(self, default_kms_key_name=None, validate=False,
headers=None):
"""Sets a GCS bucket's encryption configuration."""
self._check_bucket_uri('set_encryption_config')
bucket = self.get_bucket(validate, headers)
bucket.set_encryption_config(default_kms_key_name=default_kms_key_name,
headers=headers)
| (self, default_kms_key_name=None, validate=False, headers=None) |
5,878 | boto.storage_uri | set_metadata | null | def set_metadata(self, metadata_plus, metadata_minus, preserve_acl,
headers=None):
return self.get_key(False).set_remote_metadata(metadata_plus,
metadata_minus,
preserve_acl,
headers=headers)
| (self, metadata_plus, metadata_minus, preserve_acl, headers=None) |
5,879 | boto.storage_uri | set_storage_class | Updates a bucket's storage class. | def set_storage_class(self, storage_class, validate=False, headers=None):
"""Updates a bucket's storage class."""
self._check_bucket_uri('set_storage_class')
# StorageClass is defined as a bucket and object param for GCS, but
# only as a key param for S3.
if self.scheme != 'gs':
raise ValueError('set_storage_class() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(validate, headers)
bucket.set_storage_class(storage_class, headers)
| (self, storage_class, validate=False, headers=None) |
5,880 | boto.storage_uri | set_subresource | null | def set_subresource(self, subresource, value, validate=False, headers=None,
version_id=None):
self._check_bucket_uri('set_subresource')
bucket = self.get_bucket(validate, headers)
bucket.set_subresource(subresource, value, self.object_name, headers,
version_id)
| (self, subresource, value, validate=False, headers=None, version_id=None) |
5,881 | boto.storage_uri | set_website_config | null | def set_website_config(self, main_page_suffix=None, error_key=None,
validate=False, headers=None):
self._check_bucket_uri('set_website_config')
bucket = self.get_bucket(validate, headers)
if not (main_page_suffix or error_key):
bucket.delete_website_configuration(headers)
else:
bucket.configure_website(main_page_suffix, error_key, headers)
| (self, main_page_suffix=None, error_key=None, validate=False, headers=None) |
5,882 | boto.storage_uri | set_xml_acl | Sets or updates a bucket's ACL with an XML string. | def set_xml_acl(self, xmlstring, key_name='', validate=False, headers=None,
version_id=None, if_generation=None, if_metageneration=None):
"""Sets or updates a bucket's ACL with an XML string."""
self._check_bucket_uri('set_xml_acl')
key_name = key_name or self.object_name or ''
bucket = self.get_bucket(validate, headers)
if self.generation:
bucket.set_xml_acl(
xmlstring, key_name, headers, generation=self.generation,
if_generation=if_generation, if_metageneration=if_metageneration)
else:
version_id = version_id or self.version_id
bucket.set_xml_acl(xmlstring, key_name, headers,
version_id=version_id)
| (self, xmlstring, key_name='', validate=False, headers=None, version_id=None, if_generation=None, if_metageneration=None) |
5,883 | boto.pyami.config | Config | null | class Config(object):
def __init__(self, path=None, fp=None, do_load=True):
self._parser = ConfigParser({'working_dir': '/mnt/pyami',
'debug': '0'})
if do_load:
if path:
self.load_from_path(path)
elif fp:
self.readfp(fp)
else:
self.read(BotoConfigLocations)
if "AWS_CREDENTIAL_FILE" in os.environ:
full_path = expanduser(os.environ['AWS_CREDENTIAL_FILE'])
try:
self.load_credential_file(full_path)
except IOError:
warnings.warn('Unable to load AWS_CREDENTIAL_FILE (%s)' % full_path)
def __setstate__(self, state):
# There's test that verify that (transitively) a Config
# object can be pickled. Now that we're storing a _parser
# attribute and relying on __getattr__ to proxy requests,
# we need to implement setstate to ensure we don't get
# into recursive loops when looking up _parser when
# this object is unpickled.
self._parser = state['_parser']
def __getattr__(self, name):
return getattr(self._parser, name)
def has_option(self, *args, **kwargs):
return self._parser.has_option(*args, **kwargs)
def load_credential_file(self, path):
"""Load a credential file as is setup like the Java utilities"""
c_data = StringIO()
c_data.write("[Credentials]\n")
for line in open(path, "r").readlines():
c_data.write(line.replace("AWSAccessKeyId", "aws_access_key_id").replace("AWSSecretKey", "aws_secret_access_key"))
c_data.seek(0)
self.readfp(c_data)
def load_from_path(self, path):
file = open(path)
for line in file.readlines():
match = re.match("^#import[\s\t]*([^\s^\t]*)[\s\t]*$", line)
if match:
extended_file = match.group(1)
(dir, file) = os.path.split(path)
self.load_from_path(os.path.join(dir, extended_file))
self.read(path)
def save_option(self, path, section, option, value):
"""
Write the specified Section.Option to the config file specified by path.
Replace any previous value. If the path doesn't exist, create it.
Also add the option the the in-memory config.
"""
config = ConfigParser()
config.read(path)
if not config.has_section(section):
config.add_section(section)
config.set(section, option, value)
fp = open(path, 'w')
config.write(fp)
fp.close()
if not self.has_section(section):
self.add_section(section)
self.set(section, option, value)
def save_user_option(self, section, option, value):
self.save_option(UserConfigPath, section, option, value)
def save_system_option(self, section, option, value):
self.save_option(BotoConfigPath, section, option, value)
def get_instance(self, name, default=None):
try:
val = self.get('Instance', name)
except (NoOptionError, NoSectionError):
val = default
return val
def get_user(self, name, default=None):
try:
val = self.get('User', name)
except (NoOptionError, NoSectionError):
val = default
return val
def getint_user(self, name, default=0):
try:
val = self.getint('User', name)
except (NoOptionError, NoSectionError):
val = default
return val
def get_value(self, section, name, default=None):
return self.get(section, name, default)
def get(self, section, name, default=None):
try:
return self._parser.get(section, name)
except (NoOptionError, NoSectionError):
return default
def getint(self, section, name, default=0):
try:
return self._parser.getint(section, name)
except (NoOptionError, NoSectionError):
return int(default)
def getfloat(self, section, name, default=0.0):
try:
return self._parser.getfloat(section, name)
except (NoOptionError, NoSectionError):
return float(default)
def getbool(self, section, name, default=False):
if self.has_option(section, name):
val = self.get(section, name)
if val.lower() == 'true':
val = True
else:
val = False
else:
val = default
return val
def setbool(self, section, name, value):
if value:
self.set(section, name, 'true')
else:
self.set(section, name, 'false')
def dump(self):
s = StringIO()
self.write(s)
print(s.getvalue())
def dump_safe(self, fp=None):
if not fp:
fp = StringIO()
for section in self.sections():
fp.write('[%s]\n' % section)
for option in self.options(section):
if option == 'aws_secret_access_key':
fp.write('%s = xxxxxxxxxxxxxxxxxx\n' % option)
else:
fp.write('%s = %s\n' % (option, self.get(section, option)))
def dump_to_sdb(self, domain_name, item_name):
from boto.compat import json
sdb = boto.connect_sdb()
domain = sdb.lookup(domain_name)
if not domain:
domain = sdb.create_domain(domain_name)
item = domain.new_item(item_name)
item.active = False
for section in self.sections():
d = {}
for option in self.options(section):
d[option] = self.get(section, option)
item[section] = json.dumps(d)
item.save()
def load_from_sdb(self, domain_name, item_name):
from boto.compat import json
sdb = boto.connect_sdb()
domain = sdb.lookup(domain_name)
item = domain.get_item(item_name)
for section in item.keys():
if not self.has_section(section):
self.add_section(section)
d = json.loads(item[section])
for attr_name in d.keys():
attr_value = d[attr_name]
if attr_value is None:
attr_value = 'None'
if isinstance(attr_value, bool):
self.setbool(section, attr_name, attr_value)
else:
self.set(section, attr_name, attr_value)
| (path=None, fp=None, do_load=True) |
5,884 | boto.pyami.config | __getattr__ | null | def __getattr__(self, name):
return getattr(self._parser, name)
| (self, name) |
5,885 | boto.pyami.config | __init__ | null | def __init__(self, path=None, fp=None, do_load=True):
self._parser = ConfigParser({'working_dir': '/mnt/pyami',
'debug': '0'})
if do_load:
if path:
self.load_from_path(path)
elif fp:
self.readfp(fp)
else:
self.read(BotoConfigLocations)
if "AWS_CREDENTIAL_FILE" in os.environ:
full_path = expanduser(os.environ['AWS_CREDENTIAL_FILE'])
try:
self.load_credential_file(full_path)
except IOError:
warnings.warn('Unable to load AWS_CREDENTIAL_FILE (%s)' % full_path)
| (self, path=None, fp=None, do_load=True) |
5,886 | boto.pyami.config | __setstate__ | null | def __setstate__(self, state):
# There's test that verify that (transitively) a Config
# object can be pickled. Now that we're storing a _parser
# attribute and relying on __getattr__ to proxy requests,
# we need to implement setstate to ensure we don't get
# into recursive loops when looking up _parser when
# this object is unpickled.
self._parser = state['_parser']
| (self, state) |
5,887 | boto.pyami.config | dump | null | def dump(self):
s = StringIO()
self.write(s)
print(s.getvalue())
| (self) |
5,888 | boto.pyami.config | dump_safe | null | def dump_safe(self, fp=None):
if not fp:
fp = StringIO()
for section in self.sections():
fp.write('[%s]\n' % section)
for option in self.options(section):
if option == 'aws_secret_access_key':
fp.write('%s = xxxxxxxxxxxxxxxxxx\n' % option)
else:
fp.write('%s = %s\n' % (option, self.get(section, option)))
| (self, fp=None) |
5,889 | boto.pyami.config | dump_to_sdb | null | def dump_to_sdb(self, domain_name, item_name):
from boto.compat import json
sdb = boto.connect_sdb()
domain = sdb.lookup(domain_name)
if not domain:
domain = sdb.create_domain(domain_name)
item = domain.new_item(item_name)
item.active = False
for section in self.sections():
d = {}
for option in self.options(section):
d[option] = self.get(section, option)
item[section] = json.dumps(d)
item.save()
| (self, domain_name, item_name) |
5,890 | boto.pyami.config | get | null | def get(self, section, name, default=None):
try:
return self._parser.get(section, name)
except (NoOptionError, NoSectionError):
return default
| (self, section, name, default=None) |
5,891 | boto.pyami.config | get_instance | null | def get_instance(self, name, default=None):
try:
val = self.get('Instance', name)
except (NoOptionError, NoSectionError):
val = default
return val
| (self, name, default=None) |
5,892 | boto.pyami.config | get_user | null | def get_user(self, name, default=None):
try:
val = self.get('User', name)
except (NoOptionError, NoSectionError):
val = default
return val
| (self, name, default=None) |
5,893 | boto.pyami.config | get_value | null | def get_value(self, section, name, default=None):
return self.get(section, name, default)
| (self, section, name, default=None) |
5,894 | boto.pyami.config | getbool | null | def getbool(self, section, name, default=False):
if self.has_option(section, name):
val = self.get(section, name)
if val.lower() == 'true':
val = True
else:
val = False
else:
val = default
return val
| (self, section, name, default=False) |
5,895 | boto.pyami.config | getfloat | null | def getfloat(self, section, name, default=0.0):
try:
return self._parser.getfloat(section, name)
except (NoOptionError, NoSectionError):
return float(default)
| (self, section, name, default=0.0) |
5,896 | boto.pyami.config | getint | null | def getint(self, section, name, default=0):
try:
return self._parser.getint(section, name)
except (NoOptionError, NoSectionError):
return int(default)
| (self, section, name, default=0) |
5,897 | boto.pyami.config | getint_user | null | def getint_user(self, name, default=0):
try:
val = self.getint('User', name)
except (NoOptionError, NoSectionError):
val = default
return val
| (self, name, default=0) |
5,898 | boto.pyami.config | has_option | null | def has_option(self, *args, **kwargs):
return self._parser.has_option(*args, **kwargs)
| (self, *args, **kwargs) |
5,899 | boto.pyami.config | load_credential_file | Load a credential file as is setup like the Java utilities | def load_credential_file(self, path):
"""Load a credential file as is setup like the Java utilities"""
c_data = StringIO()
c_data.write("[Credentials]\n")
for line in open(path, "r").readlines():
c_data.write(line.replace("AWSAccessKeyId", "aws_access_key_id").replace("AWSSecretKey", "aws_secret_access_key"))
c_data.seek(0)
self.readfp(c_data)
| (self, path) |
5,900 | boto.pyami.config | load_from_path | null | def load_from_path(self, path):
file = open(path)
for line in file.readlines():
match = re.match("^#import[\s\t]*([^\s^\t]*)[\s\t]*$", line)
if match:
extended_file = match.group(1)
(dir, file) = os.path.split(path)
self.load_from_path(os.path.join(dir, extended_file))
self.read(path)
| (self, path) |
5,901 | boto.pyami.config | load_from_sdb | null | def load_from_sdb(self, domain_name, item_name):
from boto.compat import json
sdb = boto.connect_sdb()
domain = sdb.lookup(domain_name)
item = domain.get_item(item_name)
for section in item.keys():
if not self.has_section(section):
self.add_section(section)
d = json.loads(item[section])
for attr_name in d.keys():
attr_value = d[attr_name]
if attr_value is None:
attr_value = 'None'
if isinstance(attr_value, bool):
self.setbool(section, attr_name, attr_value)
else:
self.set(section, attr_name, attr_value)
| (self, domain_name, item_name) |
5,902 | boto.pyami.config | save_option |
Write the specified Section.Option to the config file specified by path.
Replace any previous value. If the path doesn't exist, create it.
Also add the option the the in-memory config.
| def save_option(self, path, section, option, value):
"""
Write the specified Section.Option to the config file specified by path.
Replace any previous value. If the path doesn't exist, create it.
Also add the option the the in-memory config.
"""
config = ConfigParser()
config.read(path)
if not config.has_section(section):
config.add_section(section)
config.set(section, option, value)
fp = open(path, 'w')
config.write(fp)
fp.close()
if not self.has_section(section):
self.add_section(section)
self.set(section, option, value)
| (self, path, section, option, value) |
5,903 | boto.pyami.config | save_system_option | null | def save_system_option(self, section, option, value):
self.save_option(BotoConfigPath, section, option, value)
| (self, section, option, value) |
5,904 | boto.pyami.config | save_user_option | null | def save_user_option(self, section, option, value):
self.save_option(UserConfigPath, section, option, value)
| (self, section, option, value) |
5,905 | boto.pyami.config | setbool | null | def setbool(self, section, name, value):
if value:
self.set(section, name, 'true')
else:
self.set(section, name, 'false')
| (self, section, name, value) |
5,906 | boto.storage_uri | FileStorageUri |
StorageUri subclass that handles files in the local file system.
Callers should instantiate this class by calling boto.storage_uri().
See file/README about how we map StorageUri operations onto a file system.
| class FileStorageUri(StorageUri):
"""
StorageUri subclass that handles files in the local file system.
Callers should instantiate this class by calling boto.storage_uri().
See file/README about how we map StorageUri operations onto a file system.
"""
delim = os.sep
def __init__(self, object_name, debug, is_stream=False):
"""Instantiate a FileStorageUri from a path name.
@type object_name: string
@param object_name: object name
@type debug: boolean
@param debug: whether to enable debugging on this StorageUri
After instantiation the components are available in the following
fields: uri, scheme, bucket_name (always blank for this "anonymous"
bucket), object_name.
"""
self.scheme = 'file'
self.bucket_name = ''
self.object_name = object_name
self.uri = 'file://' + object_name
self.debug = debug
self.stream = is_stream
def clone_replace_name(self, new_name):
"""Instantiate a FileStorageUri from the current FileStorageUri,
but replacing the object_name.
@type new_name: string
@param new_name: new object name
"""
return FileStorageUri(new_name, self.debug, self.stream)
def is_file_uri(self):
"""Returns True if this URI names a file or directory."""
return True
def is_cloud_uri(self):
"""Returns True if this URI names a bucket or object."""
return False
def names_container(self):
"""Returns True if this URI names a directory or bucket."""
return self.names_directory()
def names_singleton(self):
"""Returns True if this URI names a file (or stream) or object."""
return not self.names_container()
def names_directory(self):
"""Returns True if this URI names a directory."""
if self.stream:
return False
return os.path.isdir(self.object_name)
def names_provider(self):
"""Returns True if this URI names a provider."""
return False
def names_bucket(self):
"""Returns True if this URI names a bucket."""
return False
def names_file(self):
"""Returns True if this URI names a file."""
return self.names_singleton()
def names_object(self):
"""Returns True if this URI names an object."""
return False
def is_stream(self):
"""Returns True if this URI represents input/output stream.
"""
return bool(self.stream)
def close(self):
"""Closes the underlying file.
"""
self.get_key().close()
def exists(self, _headers_not_used=None):
"""Returns True if the file exists or False if it doesn't"""
# The _headers_not_used parameter is ignored. It is only there to ensure
# that this method's signature is identical to the exists method on the
# BucketStorageUri class.
return os.path.exists(self.object_name)
| (object_name, debug, is_stream=False) |
5,907 | boto.storage_uri | __init__ | Instantiate a FileStorageUri from a path name.
@type object_name: string
@param object_name: object name
@type debug: boolean
@param debug: whether to enable debugging on this StorageUri
After instantiation the components are available in the following
fields: uri, scheme, bucket_name (always blank for this "anonymous"
bucket), object_name.
| def __init__(self, object_name, debug, is_stream=False):
"""Instantiate a FileStorageUri from a path name.
@type object_name: string
@param object_name: object name
@type debug: boolean
@param debug: whether to enable debugging on this StorageUri
After instantiation the components are available in the following
fields: uri, scheme, bucket_name (always blank for this "anonymous"
bucket), object_name.
"""
self.scheme = 'file'
self.bucket_name = ''
self.object_name = object_name
self.uri = 'file://' + object_name
self.debug = debug
self.stream = is_stream
| (self, object_name, debug, is_stream=False) |
5,915 | boto.storage_uri | clone_replace_name | Instantiate a FileStorageUri from the current FileStorageUri,
but replacing the object_name.
@type new_name: string
@param new_name: new object name
| def clone_replace_name(self, new_name):
"""Instantiate a FileStorageUri from the current FileStorageUri,
but replacing the object_name.
@type new_name: string
@param new_name: new object name
"""
return FileStorageUri(new_name, self.debug, self.stream)
| (self, new_name) |
5,916 | boto.storage_uri | close | Closes the underlying file.
| def close(self):
"""Closes the underlying file.
"""
self.get_key().close()
| (self) |
5,918 | boto.storage_uri | delete_key | null | def delete_key(self, validate=False, headers=None, version_id=None,
mfa_token=None):
self._check_object_uri('delete_key')
bucket = self.get_bucket(validate, headers)
return bucket.delete_key(self.object_name, headers, version_id,
mfa_token)
| (self, validate=False, headers=None, version_id=None, mfa_token=None) |
5,920 | boto.storage_uri | exists | Returns True if the file exists or False if it doesn't | def exists(self, _headers_not_used=None):
"""Returns True if the file exists or False if it doesn't"""
# The _headers_not_used parameter is ignored. It is only there to ensure
# that this method's signature is identical to the exists method on the
# BucketStorageUri class.
return os.path.exists(self.object_name)
| (self, _headers_not_used=None) |
5,926 | boto.storage_uri | get_key | null | def get_key(self, validate=False, headers=None, version_id=None):
self._check_object_uri('get_key')
bucket = self.get_bucket(validate, headers)
key = bucket.get_key(self.object_name, headers, version_id)
self.check_response(key, 'key', self.uri)
return key
| (self, validate=False, headers=None, version_id=None) |
5,928 | boto.storage_uri | is_cloud_uri | Returns True if this URI names a bucket or object. | def is_cloud_uri(self):
"""Returns True if this URI names a bucket or object."""
return False
| (self) |
5,929 | boto.storage_uri | is_file_uri | Returns True if this URI names a file or directory. | def is_file_uri(self):
"""Returns True if this URI names a file or directory."""
return True
| (self) |
5,930 | boto.storage_uri | is_stream | Returns True if this URI represents input/output stream.
| def is_stream(self):
"""Returns True if this URI represents input/output stream.
"""
return bool(self.stream)
| (self) |
5,932 | boto.storage_uri | names_bucket | Returns True if this URI names a bucket. | def names_bucket(self):
"""Returns True if this URI names a bucket."""
return False
| (self) |
5,933 | boto.storage_uri | names_container | Returns True if this URI names a directory or bucket. | def names_container(self):
"""Returns True if this URI names a directory or bucket."""
return self.names_directory()
| (self) |
5,934 | boto.storage_uri | names_directory | Returns True if this URI names a directory. | def names_directory(self):
"""Returns True if this URI names a directory."""
if self.stream:
return False
return os.path.isdir(self.object_name)
| (self) |
5,935 | boto.storage_uri | names_file | Returns True if this URI names a file. | def names_file(self):
"""Returns True if this URI names a file."""
return self.names_singleton()
| (self) |
5,936 | boto.storage_uri | names_object | Returns True if this URI names an object. | def names_object(self):
"""Returns True if this URI names an object."""
return False
| (self) |
5,937 | boto.storage_uri | names_provider | Returns True if this URI names a provider. | def names_provider(self):
"""Returns True if this URI names a provider."""
return False
| (self) |
5,938 | boto.storage_uri | names_singleton | Returns True if this URI names a file (or stream) or object. | def names_singleton(self):
"""Returns True if this URI names a file (or stream) or object."""
return not self.names_container()
| (self) |
5,940 | boto.exception | InvalidUriError | Exception raised when URI is invalid. | class InvalidUriError(Exception):
"""Exception raised when URI is invalid."""
def __init__(self, message):
super(InvalidUriError, self).__init__(message)
self.message = message
| (message) |
5,941 | boto.exception | __init__ | null | def __init__(self, message):
super(InvalidUriError, self).__init__(message)
self.message = message
| (self, message) |
5,942 | boto | NullHandler | null | class NullHandler(logging.Handler):
def emit(self, record):
pass
| (level=0) |
5,945 | logging | _at_fork_reinit | null | def _at_fork_reinit(self):
self.lock._at_fork_reinit()
| (self) |
5,949 | logging | createLock |
Acquire a thread lock for serializing access to the underlying I/O.
| def createLock(self):
"""
Acquire a thread lock for serializing access to the underlying I/O.
"""
self.lock = threading.RLock()
_register_at_fork_reinit_lock(self)
| (self) |
5,950 | boto | emit | null | def emit(self, record):
pass
| (self, record) |
5,955 | logging | handle |
Conditionally emit the specified logging record.
Emission depends on filters which may have been added to the handler.
Wrap the actual emission of the record with acquisition/release of
the I/O thread lock. Returns whether the filter passed the record for
emission.
| def handle(self, record):
"""
Conditionally emit the specified logging record.
Emission depends on filters which may have been added to the handler.
Wrap the actual emission of the record with acquisition/release of
the I/O thread lock. Returns whether the filter passed the record for
emission.
"""
rv = self.filter(record)
if rv:
self.acquire()
try:
self.emit(record)
finally:
self.release()
return rv
| (self, record) |
5,964 | boto | connect_autoscale |
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
:rtype: :class:`boto.ec2.autoscale.AutoScaleConnection`
:return: A connection to Amazon's Auto Scaling Service
:type use_block_device_types bool
:param use_block_device_types: Specifies whether to return described Launch Configs with block device mappings containing
block device types, or a list of old style block device mappings (deprecated). This defaults to false for compatability
with the old incorrect style.
| def connect_autoscale(aws_access_key_id=None, aws_secret_access_key=None,
**kwargs):
"""
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
:rtype: :class:`boto.ec2.autoscale.AutoScaleConnection`
:return: A connection to Amazon's Auto Scaling Service
:type use_block_device_types bool
:param use_block_device_types: Specifies whether to return described Launch Configs with block device mappings containing
block device types, or a list of old style block device mappings (deprecated). This defaults to false for compatability
with the old incorrect style.
"""
from boto.ec2.autoscale import AutoScaleConnection
return AutoScaleConnection(aws_access_key_id, aws_secret_access_key,
**kwargs)
| (aws_access_key_id=None, aws_secret_access_key=None, **kwargs) |
5,965 | boto | connect_awslambda |
Connect to AWS Lambda
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
rtype: :class:`boto.awslambda.layer1.AWSLambdaConnection`
:return: A connection to the AWS Lambda service
| def connect_awslambda(aws_access_key_id=None,
aws_secret_access_key=None,
**kwargs):
"""
Connect to AWS Lambda
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
rtype: :class:`boto.awslambda.layer1.AWSLambdaConnection`
:return: A connection to the AWS Lambda service
"""
from boto.awslambda.layer1 import AWSLambdaConnection
return AWSLambdaConnection(
aws_access_key_id=aws_access_key_id,
aws_secret_access_key=aws_secret_access_key,
**kwargs
)
| (aws_access_key_id=None, aws_secret_access_key=None, **kwargs) |
5,966 | boto | connect_beanstalk |
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
:rtype: :class:`boto.beanstalk.layer1.Layer1`
:return: A connection to Amazon's Elastic Beanstalk service
| def connect_beanstalk(aws_access_key_id=None,
aws_secret_access_key=None,
**kwargs):
"""
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
:rtype: :class:`boto.beanstalk.layer1.Layer1`
:return: A connection to Amazon's Elastic Beanstalk service
"""
from boto.beanstalk.layer1 import Layer1
return Layer1(aws_access_key_id, aws_secret_access_key, **kwargs)
| (aws_access_key_id=None, aws_secret_access_key=None, **kwargs) |
Subsets and Splits