text_prompt
stringlengths 157
13.1k
| code_prompt
stringlengths 7
19.8k
⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def compile_swagger_schema(schema_dir, resource_listing):
"""Build a SwaggerSchema from various files. :param schema_dir: the directory schema files live inside :type schema_dir: string :returns: a SwaggerSchema object """
|
mapping = build_schema_mapping(schema_dir, resource_listing)
resource_validators = ingest_resources(mapping, schema_dir)
endpoints = list(build_swagger_12_endpoints(resource_listing, mapping))
return SwaggerSchema(endpoints, resource_validators)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_bravado_core_config(settings):
"""Create a configuration dict for bravado_core based on pyramid_swagger settings. :param settings: pyramid registry settings with configuration for building a swagger schema :type settings: dict :returns: config dict suitable for passing into bravado_core.spec.Spec.from_dict(..) :rtype: dict """
|
# Map pyramid_swagger config key -> bravado_core config key
config_keys = {
'pyramid_swagger.enable_request_validation': 'validate_requests',
'pyramid_swagger.enable_response_validation': 'validate_responses',
'pyramid_swagger.enable_swagger_spec_validation': 'validate_swagger_spec',
'pyramid_swagger.use_models': 'use_models',
'pyramid_swagger.user_formats': 'formats',
'pyramid_swagger.include_missing_properties': 'include_missing_properties',
}
configs = {
'use_models': False
}
bravado_core_configs_from_pyramid_swagger_configs = {
bravado_core_key: settings[pyramid_swagger_key]
for pyramid_swagger_key, bravado_core_key in iteritems(config_keys)
if pyramid_swagger_key in settings
}
if bravado_core_configs_from_pyramid_swagger_configs:
warnings.warn(
message='Configs {old_configs} are deprecated, please use {new_configs} instead.'.format(
old_configs=', '.join(k for k, v in sorted(iteritems(config_keys))),
new_configs=', '.join(
'{}{}'.format(BRAVADO_CORE_CONFIG_PREFIX, v)
for k, v in sorted(iteritems(config_keys))
),
),
category=DeprecationWarning,
)
configs.update(bravado_core_configs_from_pyramid_swagger_configs)
configs.update({
key.replace(BRAVADO_CORE_CONFIG_PREFIX, ''): value
for key, value in iteritems(settings)
if key.startswith(BRAVADO_CORE_CONFIG_PREFIX)
})
return configs
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ingest_resources(mapping, schema_dir):
"""Consume the Swagger schemas and produce a queryable datastructure. :param mapping: Map from resource name to filepath of its api declaration :type mapping: dict :param schema_dir: the directory schema files live inside :type schema_dir: string :returns: A list of mapping from :class:`RequestMatcher` to :class:`ValidatorMap` """
|
ingested_resources = []
for name, filepath in iteritems(mapping):
try:
ingested_resources.append(load_schema(filepath))
# If we have trouble reading any files, raise a more user-friendly
# error.
except IOError:
raise ApiDeclarationNotFoundError(
'No api declaration found at {0}. Attempted to load the `{1}` '
'resource relative to the schema_directory `{2}`. Perhaps '
'your resource name and API declaration file do not '
'match?'.format(filepath, name, schema_dir)
)
return ingested_resources
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_array(self, infile, var_name):
"""Directly return a numpy array for a given variable name"""
|
file_handle = self.read_cdf(infile)
try:
# return the data array
return file_handle.variables[var_name][:]
except KeyError:
print("Cannot find variable: {0}".format(var_name))
raise KeyError
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_ma_array(self, infile, var_name):
"""Create a masked array based on cdf's FillValue"""
|
file_obj = self.read_cdf(infile)
# .data is not backwards compatible to old scipy versions, [:] is
data = file_obj.variables[var_name][:]
# load numpy if available
try:
import numpy as np
except Exception:
raise ImportError("numpy is required to return masked arrays.")
if hasattr(file_obj.variables[var_name], "_FillValue"):
# return masked array
fill_val = file_obj.variables[var_name]._FillValue
retval = np.ma.masked_where(data == fill_val, data)
else:
# generate dummy mask which is always valid
retval = np.ma.array(data)
return retval
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def digest(self,data=None):
""" Method digest is redefined to return keyed MAC value instead of just digest. """
|
if data is not None:
self.update(data)
b=create_string_buffer(256)
size=c_size_t(256)
if libcrypto.EVP_DigestSignFinal(self.ctx,b,pointer(size))<=0:
raise DigestError('SignFinal')
self.digest_finalized=True
return b.raw[:size.value]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def bytes(num, check_result=False):
""" Returns num bytes of cryptographically strong pseudo-random bytes. If checkc_result is True, raises error if PRNG is not seeded enough """
|
if num <= 0:
raise ValueError("'num' should be > 0")
buf = create_string_buffer(num)
result = libcrypto.RAND_bytes(buf, num)
if check_result and result == 0:
raise RandError("Random Number Generator not seeded sufficiently")
return buf.raw[:num]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(dotted, shortname, longname):
""" Creates new OID in the database @param dotted - dotted-decimal representation of new OID @param shortname - short name for new OID @param longname - long name for new OID @returns Oid object corresponding to new OID This function should be used with exreme care. Whenever possible, it is better to add new OIDs via OpenSSL configuration file Results of calling this function twice for same OIDor for Oid alredy in database are undefined """
|
if pyver > 2:
dotted = dotted.encode('ascii')
shortname = shortname.encode('utf-8')
longname = longname.encode('utf-8')
nid = libcrypto.OBJ_create(dotted, shortname, longname)
if nid == 0:
raise LibCryptoError("Problem adding new OID to the database")
return Oid(nid)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
|
def dotted(self):
" Returns dotted-decimal reperesentation "
obj = libcrypto.OBJ_nid2obj(self.nid)
buf = create_string_buffer(256)
libcrypto.OBJ_obj2txt(buf, 256, obj, 1)
if pyver == 2:
return buf.value
else:
return buf.value.decode('ascii')
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fromobj(obj):
""" Creates an OID object from the pointer to ASN1_OBJECT c structure. This method intended for internal use for submodules which deal with libcrypto ASN1 parsing functions, such as x509 or CMS """
|
nid = libcrypto.OBJ_obj2nid(obj)
if nid == 0:
buf = create_string_buffer(80)
dotted_len = libcrypto.OBJ_obj2txt(buf, 80, obj, 1)
dotted = buf[:dotted_len]
oid = create(dotted, dotted, dotted)
else:
oid = Oid(nid)
return oid
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _password_callback(c):
""" Converts given user function or string to C password callback function, passable to openssl. IF function is passed, it would be called upon reading or writing PEM format private key with one argument which is True if we are writing key and should verify passphrase and false if we are reading """
|
if c is None:
return PW_CALLBACK_FUNC(0)
if callable(c):
if pyver ==2 :
def __cb(buf, length, rwflag, userdata):
pwd = c(rwflag)
cnt = min(len(pwd),length)
memmove(buf,pwd, cnt)
return cnt
else:
def __cb(buf, length, rwflag, userdata):
pwd = c(rwflag).encode("utf-8")
cnt = min(len(pwd),length)
memmove(buf,pwd, cnt)
return cnt
else:
if pyver > 2:
c=c.encode("utf-8")
def __cb(buf,length,rwflag,userdata):
cnt=min(len(c),length)
memmove(buf,c,cnt)
return cnt
return PW_CALLBACK_FUNC(__cb)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def verify(self, digest, signature, **kwargs):
""" Verifies given signature on given digest Returns True if Ok, False if don't match Keyword arguments allows to set algorithm-specific parameters """
|
ctx = libcrypto.EVP_PKEY_CTX_new(self.key, None)
if ctx is None:
raise PKeyError("Initailizing verify context")
if libcrypto.EVP_PKEY_verify_init(ctx) < 1:
raise PKeyError("verify_init")
self._configure_context(ctx, kwargs)
ret = libcrypto.EVP_PKEY_verify(ctx, signature, len(signature), digest,
len(digest))
if ret < 0:
raise PKeyError("Signature verification")
libcrypto.EVP_PKEY_CTX_free(ctx)
return ret > 0
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def exportpub(self, format="PEM"):
""" Returns public key as PEM or DER structure. """
|
bio = Membio()
if format == "PEM":
retcode = libcrypto.PEM_write_bio_PUBKEY(bio.bio, self.key)
else:
retcode = libcrypto.i2d_PUBKEY_bio(bio.bio, self.key)
if retcode == 0:
raise PKeyError("error serializing public key")
return str(bio)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def exportpriv(self, format="PEM", password=None, cipher=None):
""" Returns private key as PEM or DER Structure. If password and cipher are specified, encrypts key on given password, using given algorithm. Cipher must be an ctypescrypto.cipher.CipherType object Password can be either string or function with one argument, which returns password. It is called with argument True, which means, that we are encrypting key, and password should be verified (requested twice from user, for example). """
|
bio = Membio()
if cipher is None:
evp_cipher = None
else:
evp_cipher = cipher.cipher
if format == "PEM":
ret = libcrypto.PEM_write_bio_PrivateKey(bio.bio, self.key,
evp_cipher, None, 0,
_password_callback(password),
None)
if ret ==0:
raise PKeyError("error serializing private key")
return str(bio)
else:
ret = libcrypto.i2d_PKCS8PrivateKey_bio(bio.bio, self.key,
evp_cipher, None, 0,
_password_callback(password),
None)
if ret ==0:
raise PKeyError("error serializing private key")
return bintype(bio)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _configure_context(ctx, opts, skip=()):
""" Configures context of public key operations @param ctx - context to configure @param opts - dictionary of options (from kwargs of calling function) @param skip - list of options which shouldn't be passed to context """
|
for oper in opts:
if oper in skip:
continue
if isinstance(oper,chartype):
op = oper.encode("ascii")
else:
op = oper
if isinstance(opts[oper],chartype):
value = opts[oper].encode("ascii")
elif isinstance(opts[oper],bintype):
value = opts[oper]
else:
if pyver == 2:
value = str(opts[oper])
else:
value = str(opts[oper]).encode('ascii')
ret = libcrypto.EVP_PKEY_CTX_ctrl_str(ctx, op, value)
if ret == -2:
raise PKeyError("Parameter %s is not supported by key" % oper)
if ret < 1:
raise PKeyError("Error setting parameter %s" % oper)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read(self, length=None):
""" Reads data from readble BIO. For test purposes. @param length - if specifed, limits amount of data read. If not BIO is read until end of buffer """
|
if not length is None:
if not isinstance(length, inttype) :
raise TypeError("length to read should be number")
buf = create_string_buffer(length)
readbytes = libcrypto.BIO_read(self.bio, buf, length)
if readbytes == -2:
raise NotImplementedError("Function is not supported by" +
"this BIO")
if readbytes == -1:
raise IOError
if readbytes == 0:
return b""
return buf.raw[:readbytes]
else:
buf = create_string_buffer(1024)
out = b""
readbytes = 1
while readbytes > 0:
readbytes = libcrypto.BIO_read(self.bio, buf, 1024)
if readbytes == -2:
raise NotImplementedError("Function is not supported by " +
"this BIO")
if readbytes == -1:
raise IOError
if readbytes > 0:
out += buf.raw[:readbytes]
return out
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write(self, data):
""" Writes data to writable bio. For test purposes """
|
if pyver == 2:
if isinstance(data, unicode):
data = data.encode("utf-8")
else:
data = str(data)
else:
if not isinstance(data, bytes):
data=str(data).encode("utf-8")
written = libcrypto.BIO_write(self.bio, data, len(data))
if written == -2:
raise NotImplementedError("Function not supported by this BIO")
if written < len(data):
raise IOError("Not all data were successfully written")
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def CMS(data, format="PEM"):
""" Factory function to create CMS objects from received messages. Parses CMS data and returns either SignedData or EnvelopedData object. format argument can be either "PEM" or "DER". It determines object type from the contents of received CMS structure. """
|
bio = Membio(data)
if format == "PEM":
ptr = libcrypto.PEM_read_bio_CMS(bio.bio, None, None, None)
else:
ptr = libcrypto.d2i_CMS_bio(bio.bio, None)
if ptr is None:
raise CMSError("Error parsing CMS data")
typeoid = Oid(libcrypto.OBJ_obj2nid(libcrypto.CMS_get0_type(ptr)))
if typeoid.shortname() == "pkcs7-signedData":
return SignedData(ptr)
elif typeoid.shortname() == "pkcs7-envelopedData":
return EnvelopedData(ptr)
elif typeoid.shortname() == "pkcs7-encryptedData":
return EncryptedData(ptr)
else:
raise NotImplementedError("cannot handle "+typeoid.shortname())
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pem(self):
""" Serialize in PEM format """
|
bio = Membio()
if not libcrypto.PEM_write_bio_CMS(bio.bio, self.ptr):
raise CMSError("writing CMS to PEM")
return str(bio)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(data, cert, pkey, flags=Flags.BINARY, certs=None):
""" Creates SignedData message by signing data with pkey and certificate. @param data - data to sign @param cert - signer's certificate @param pkey - pkey object with private key to sign @param flags - OReed combination of Flags constants @param certs - list of X509 objects to include into CMS """
|
if not pkey.cansign:
raise ValueError("Specified keypair has no private part")
if cert.pubkey != pkey:
raise ValueError("Certificate doesn't match public key")
bio = Membio(data)
if certs is not None and len(certs) > 0:
certstack_obj = StackOfX509(certs) # keep reference to prevent immediate __del__ call
certstack = certstack_obj.ptr
else:
certstack = None
ptr = libcrypto.CMS_sign(cert.cert, pkey.key, certstack, bio.bio, flags)
if ptr is None:
raise CMSError("signing message")
return SignedData(ptr)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sign(self, cert, pkey, digest_type=None, data=None, flags=Flags.BINARY):
""" Adds another signer to already signed message @param cert - signer's certificate @param pkey - signer's private key @param digest_type - message digest to use as DigestType object (if None - default for key would be used) @param data - data to sign (if detached and Flags.REUSE_DIGEST is not specified) @param flags - ORed combination of Flags consants """
|
if not pkey.cansign:
raise ValueError("Specified keypair has no private part")
if cert.pubkey != pkey:
raise ValueError("Certificate doesn't match public key")
if libcrypto.CMS_add1_signer(self.ptr, cert.cert, pkey.key,
digest_type.digest, flags) is None:
raise CMSError("adding signer")
if flags & Flags.REUSE_DIGEST == 0:
if data is not None:
bio = Membio(data)
biodata = bio.bio
else:
biodata = None
res = libcrypto.CMS_final(self.ptr, biodata, None, flags)
if res <= 0:
raise CMSError("Cannot finalize CMS")
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def verify(self, store, flags, data=None, certs=None):
""" Verifies signature under CMS message using trusted cert store @param store - X509Store object with trusted certs @param flags - OR-ed combination of flag consants @param data - message data, if messge has detached signature param certs - list of certificates to use during verification If Flags.NOINTERN is specified, these are only sertificates to search for signing certificates @returns True if signature valid, False otherwise """
|
bio = None
if data != None:
bio_obj = Membio(data)
bio = bio_obj.bio
if certs is not None and len(certs) > 0:
certstack_obj = StackOfX509(certs) # keep reference to prevent immediate __del__ call
certstack = certstack_obj.ptr
else:
certstack = None
res = libcrypto.CMS_verify(self.ptr, certstack, store.store, bio,
None, flags)
return res > 0
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def signers(self):
""" Return list of signer's certificates """
|
signerlist = libcrypto.CMS_get0_signers(self.ptr)
if signerlist is None:
raise CMSError("Cannot get signers")
return StackOfX509(ptr=signerlist, disposable=False)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def data(self):
""" Returns signed data if present in the message """
|
# Check if signatire is detached
if self.detached:
return None
bio = Membio()
if not libcrypto.CMS_verify(self.ptr, None, None, None, bio.bio,
Flags.NO_VERIFY):
raise CMSError("extract data")
return str(bio)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def certs(self):
""" List of the certificates contained in the structure """
|
certstack = libcrypto.CMS_get1_certs(self.ptr)
if certstack is None:
raise CMSError("getting certs")
return StackOfX509(ptr=certstack, disposable=True)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(recipients, data, cipher, flags=0):
""" Creates and encrypts message @param recipients - list of X509 objects @param data - contents of the message @param cipher - CipherType object @param flags - flag """
|
recp = StackOfX509(recipients)
bio = Membio(data)
cms_ptr = libcrypto.CMS_encrypt(recp.ptr, bio.bio, cipher.cipher,
flags)
if cms_ptr is None:
raise CMSError("encrypt EnvelopedData")
return EnvelopedData(cms_ptr)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(data, cipher, key, flags=0):
""" Creates an EncryptedData message. @param data data to encrypt @param cipher cipher.CipherType object represening required cipher type @param key - byte array used as simmetic key @param flags - OR-ed combination of Flags constant """
|
bio = Membio(data)
ptr = libcrypto.CMS_EncryptedData_encrypt(bio.bio, cipher.cipher,
key, len(key), flags)
if ptr is None:
raise CMSError("encrypt data")
return EncryptedData(ptr)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def decrypt(self, key, flags=0):
""" Decrypts encrypted data message @param key - symmetic key to decrypt @param flags - OR-ed combination of Flags constant """
|
bio = Membio()
if libcrypto.CMS_EncryptedData_decrypt(self.ptr, key, len(key), None,
bio.bio, flags) <= 0:
raise CMSError("decrypt data")
return str(bio)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def name(self):
""" Returns name of the digest """
|
if not hasattr(self, 'digest_name'):
self.digest_name = Oid(libcrypto.EVP_MD_type(self.digest)
).longname()
return self.digest_name
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update(self, data, length=None):
""" Hashes given byte string @param data - string to hash @param length - if not specifed, entire string is hashed, otherwise only first length bytes """
|
if self.digest_finalized:
raise DigestError("No updates allowed")
if not isinstance(data, bintype):
raise TypeError("A byte string is expected")
if length is None:
length = len(data)
elif length > len(data):
raise ValueError("Specified length is greater than length of data")
result = libcrypto.EVP_DigestUpdate(self.ctx, c_char_p(data), length)
if result != 1:
raise DigestError("Unable to update digest")
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def digest(self, data=None):
""" Finalizes digest operation and return digest value Optionally hashes more data before finalizing """
|
if self.digest_finalized:
return self.digest_out.raw[:self.digest_size]
if data is not None:
self.update(data)
self.digest_out = create_string_buffer(256)
length = c_long(0)
result = libcrypto.EVP_DigestFinal_ex(self.ctx, self.digest_out,
byref(length))
if result != 1:
raise DigestError("Unable to finalize digest")
self.digest_finalized = True
return self.digest_out.raw[:self.digest_size]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def copy(self):
""" Creates copy of the digest CTX to allow to compute digest while being able to hash more data """
|
new_digest = Digest(self.digest_type)
libcrypto.EVP_MD_CTX_copy(new_digest.ctx, self.ctx)
return new_digest
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _clean_ctx(self):
""" Clears and deallocates context """
|
try:
if self.ctx is not None:
libcrypto.EVP_MD_CTX_free(self.ctx)
del self.ctx
except AttributeError:
pass
self.digest_out = None
self.digest_finalized = False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def hexdigest(self, data=None):
""" Returns digest in the hexadecimal form. For compatibility with hashlib """
|
from base64 import b16encode
if pyver == 2:
return b16encode(self.digest(data))
else:
return b16encode(self.digest(data)).decode('us-ascii')
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _X509__asn1date_to_datetime(asn1date):
""" Converts openssl ASN1_TIME object to python datetime.datetime """
|
bio = Membio()
libcrypto.ASN1_TIME_print(bio.bio, asn1date)
pydate = datetime.strptime(str(bio), "%b %d %H:%M:%S %Y %Z")
return pydate.replace(tzinfo=utc)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find(self, oid):
""" Return list of extensions with given Oid """
|
if not isinstance(oid, Oid):
raise TypeError("Need crytypescrypto.oid.Oid as argument")
found = []
index = -1
end = len(self)
while True:
index = libcrypto.X509_get_ext_by_NID(self.cert.cert, oid.nid,
index)
if index >= end or index < 0:
break
found.append(self[index])
return found
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find_critical(self, crit=True):
""" Return list of critical extensions (or list of non-cricital, if optional second argument is False """
|
if crit:
flag = 1
else:
flag = 0
found = []
end = len(self)
index = -1
while True:
index = libcrypto.X509_get_ext_by_critical(self.cert.cert, flag,
index)
if index >= end or index < 0:
break
found.append(self[index])
return found
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pem(self):
""" Returns PEM represntation of the certificate """
|
bio = Membio()
if libcrypto.PEM_write_bio_X509(bio.bio, self.cert) == 0:
raise X509Error("error serializing certificate")
return str(bio)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def serial(self):
""" Serial number of certificate as integer """
|
asnint = libcrypto.X509_get_serialNumber(self.cert)
bio = Membio()
libcrypto.i2a_ASN1_INTEGER(bio.bio, asnint)
return int(str(bio), 16)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_cert(self, cert):
""" Explicitely adds certificate to set of trusted in the store @param cert - X509 object to add """
|
if not isinstance(cert, X509):
raise TypeError("cert should be X509")
libcrypto.X509_STORE_add_cert(self.store, cert.cert)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def setpurpose(self, purpose):
""" Sets certificate purpose which verified certificate should match @param purpose - number from 1 to 9 or standard strind defined in Openssl possible strings - sslcient,sslserver, nssslserver, smimesign,i smimeencrypt, crlsign, any, ocsphelper """
|
if isinstance(purpose, str):
purp_no = libcrypto.X509_PURPOSE_get_by_sname(purpose)
if purp_no <= 0:
raise X509Error("Invalid certificate purpose '%s'" % purpose)
elif isinstance(purpose, int):
purp_no = purpose
if libcrypto.X509_STORE_set_purpose(self.store, purp_no) <= 0:
raise X509Error("cannot set purpose")
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def settime(self, time):
""" Set point in time used to check validity of certificates for Time can be either python datetime object or number of seconds sinse epoch """
|
if isinstance(time, datetime) or isinstance(time,
datetime.date):
seconds = int(time.strftime("%s"))
elif isinstance(time, int):
seconds = time
else:
raise TypeError("datetime.date, datetime.datetime or integer " +
"is required as time argument")
raise NotImplementedError
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def append(self, value):
""" Adds certificate to stack """
|
if not self.need_free:
raise ValueError("Stack is read-only")
if not isinstance(value, X509):
raise TypeError('StackOfX509 can contain only X509 objects')
sk_push(self.ptr, libcrypto.X509_dup(value.cert))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(curve, data):
""" Creates EC keypair from the just secret key and curve name @param curve - name of elliptic curve @param num - byte array or long number representing key """
|
ec_key = libcrypto.EC_KEY_new_by_curve_name(curve.nid)
if ec_key is None:
raise PKeyError("EC_KEY_new_by_curvename")
group = libcrypto.EC_KEY_get0_group(ec_key)
if group is None:
raise PKeyError("EC_KEY_get0_group")
libcrypto.EC_GROUP_set_asn1_flag(group, 1)
raw_key = libcrypto.BN_new()
if isinstance(data, int):
libcrypto.BN_hex2bn(byref(raw_key), hex(data))
else:
if raw_key is None:
raise PKeyError("BN_new")
if libcrypto.BN_bin2bn(data, len(data), raw_key) is None:
raise PKeyError("BN_bin2bn")
ctx = libcrypto.BN_CTX_new()
if ctx is None:
raise PKeyError("BN_CTX_new")
order = libcrypto.BN_new()
if order is None:
raise PKeyError("BN_new")
priv_key = libcrypto.BN_new()
if priv_key is None:
raise PKeyError("BN_new")
if libcrypto.EC_GROUP_get_order(group, order, ctx) <= 0:
raise PKeyError("EC_GROUP_get_order")
if libcrypto.BN_nnmod(priv_key, raw_key, order, ctx) <= 0:
raise PKeyError("BN_nnmod")
if libcrypto.EC_KEY_set_private_key(ec_key, priv_key) <= 0:
raise PKeyError("EC_KEY_set_private_key")
pub_key = libcrypto.EC_POINT_new(group)
if pub_key is None:
raise PKeyError("EC_POINT_new")
if libcrypto.EC_POINT_mul(group, pub_key, priv_key, None, None, ctx) <= 0:
raise PKeyError("EC_POINT_mul")
if libcrypto.EC_KEY_set_public_key(ec_key, pub_key) <= 0:
raise PKeyError("EC_KEY_set_public_key")
libcrypto.BN_free(raw_key)
libcrypto.BN_free(order)
libcrypto.BN_free(priv_key)
libcrypto.BN_CTX_free(ctx)
pkey = libcrypto.EVP_PKEY_new()
if pkey is None:
raise PKeyError("EVP_PKEY_new")
if libcrypto.EVP_PKEY_set1_EC_KEY(pkey, ec_key) <= 0:
raise PKeyError("EVP_PKEY_set1_EC_KEY")
libcrypto.EC_KEY_free(ec_key)
return PKey(ptr=pkey, cansign=True)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def new(algname, key, encrypt=True, iv=None):
""" Returns new cipher object ready to encrypt-decrypt data @param algname - string algorithm name like in opemssl command line @param key - binary string representing ciher key @param encrypt - if True (default) cipher would be initialized for encryption, otherwise - for decrypton @param iv - initialization vector """
|
ciph_type = CipherType(algname)
return Cipher(ciph_type, key, iv, encrypt)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def padding(self, padding=True):
""" Sets padding mode of the cipher """
|
padding_flag = 1 if padding else 0
libcrypto.EVP_CIPHER_CTX_set_padding(self.ctx, padding_flag)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def finish(self):
""" Finalizes processing. If some data are kept in the internal state, they would be processed and returned. """
|
if self.cipher_finalized:
raise CipherError("Cipher operation is already completed")
outbuf = create_string_buffer(self.block_size)
self.cipher_finalized = True
outlen = c_int(0)
result = libcrypto.EVP_CipherFinal_ex(self.ctx, outbuf, byref(outlen))
if result == 0:
self._clean_ctx()
raise CipherError("Unable to finalize cipher")
if outlen.value > 0:
return outbuf.raw[:int(outlen.value)]
else:
return b""
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _clean_ctx(self):
""" Cleans up cipher ctx and deallocates it """
|
try:
if self.ctx is not None:
self.__ctxcleanup(self.ctx)
libcrypto.EVP_CIPHER_CTX_free(self.ctx)
del self.ctx
except AttributeError:
pass
self.cipher_finalized = True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_default(eng, algorithms=0xFFFF):
""" Sets specified engine as default for all algorithms, supported by it For compatibility with 0.2.x if string is passed instead of engine, attempts to load engine with this id """
|
if not isinstance(eng,Engine):
eng=Engine(eng)
global default
libcrypto.ENGINE_set_default(eng.ptr, c_int(algorithms))
default = eng
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def from_keyed_iterable(iterable, key, filter_func=None):
"""Construct a dictionary out of an iterable, using an attribute name as the key. Optionally provide a filter function, to determine what should be kept in the dictionary."""
|
generated = {}
for element in iterable:
try:
k = getattr(element, key)
except AttributeError:
raise RuntimeError("{} does not have the keyed attribute: {}".format(
element, key
))
if filter_func is None or filter_func(element):
if k in generated:
generated[k] += [element]
else:
generated[k] = [element]
return generated
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def subtract_by_key(dict_a, dict_b):
"""given two dicts, a and b, this function returns c = a - b, where a - b is defined as the key difference between a and b. e.g., {1:None, 2:3, 3:"yellow", 4:True} - {2:4, 1:"green"} = {3:"yellow", 4:True} """
|
difference_dict = {}
for key in dict_a:
if key not in dict_b:
difference_dict[key] = dict_a[key]
return difference_dict
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def winnow_by_keys(dct, keys=None, filter_func=None):
"""separates a dict into has-keys and not-has-keys pairs, using either a list of keys or a filtering function."""
|
has = {}
has_not = {}
for key in dct:
key_passes_check = False
if keys is not None:
key_passes_check = key in keys
elif filter_func is not None:
key_passes_check = filter_func(key)
if key_passes_check:
has[key] = dct[key]
else:
has_not[key] = dct[key]
return WinnowedResult(has, has_not)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def flat_map(iterable, func):
"""func must take an item and return an interable that contains that item. this is flatmap in the classic mode"""
|
results = []
for element in iterable:
result = func(element)
if len(result) > 0:
results.extend(result)
return results
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def product(sequence, initial=1):
"""like the built-in sum, but for multiplication."""
|
if not isinstance(sequence, collections.Iterable):
raise TypeError("'{}' object is not iterable".format(type(sequence).__name__))
return reduce(operator.mul, sequence, initial)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def date_from_string(string, format_string=None):
"""Runs through a few common string formats for datetimes, and attempts to coerce them into a datetime. Alternatively, format_string can provide either a single string to attempt or an iterable of strings to attempt."""
|
if isinstance(format_string, str):
return datetime.datetime.strptime(string, format_string).date()
elif format_string is None:
format_string = [
"%Y-%m-%d",
"%m-%d-%Y",
"%m/%d/%Y",
"%d/%m/%Y",
]
for format in format_string:
try:
return datetime.datetime.strptime(string, format).date()
except ValueError:
continue
raise ValueError("Could not produce date from string: {}".format(string))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def to_datetime(plain_date, hours=0, minutes=0, seconds=0, ms=0):
"""given a datetime.date, gives back a datetime.datetime"""
|
# don't mess with datetimes
if isinstance(plain_date, datetime.datetime):
return plain_date
return datetime.datetime(
plain_date.year,
plain_date.month,
plain_date.day,
hours,
minutes,
seconds,
ms,
)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_containing_period(cls, *periods):
"""Given a bunch of TimePeriods, return a TimePeriod that most closely contains them."""
|
if any(not isinstance(period, TimePeriod) for period in periods):
raise TypeError("periods must all be TimePeriods: {}".format(periods))
latest = datetime.datetime.min
earliest = datetime.datetime.max
for period in periods:
# the best we can do to conain None is None!
if period._latest is None:
latest = None
elif latest is not None and period._latest > latest:
latest = period._latest
if period._earliest is None:
earliest = None
elif earliest is not None and period._earliest < earliest:
earliest = period._earliest
return TimePeriod(earliest, latest)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_user_password(env, param, force=False):
""" Allows the user to print the credential for a particular keyring entry to the screen """
|
username = utils.assemble_username(env, param)
if not utils.confirm_credential_display(force):
return
# Retrieve the credential from the keychain
password = password_get(username)
if password:
return (username, password)
else:
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def password_get(username=None):
""" Retrieves a password from the keychain based on the environment and configuration parameter pair. If this fails, None is returned. """
|
password = keyring.get_password('supernova', username)
if password is None:
split_username = tuple(username.split(':'))
msg = ("Couldn't find a credential for {0}:{1}. You need to set one "
"with: supernova-keyring -s {0} {1}").format(*split_username)
raise LookupError(msg)
else:
return password.encode('ascii')
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_user_password(environment, parameter, password):
""" Sets a user's password in the keyring storage """
|
username = '%s:%s' % (environment, parameter)
return password_set(username, password)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def password_set(username=None, password=None):
""" Stores a password in a keychain for a particular environment and configuration parameter pair. """
|
result = keyring.set_password('supernova', username, password)
# NOTE: keyring returns None when the storage is successful. That's weird.
if result is None:
return True
else:
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def prep_shell_environment(nova_env, nova_creds):
""" Appends new variables to the current shell environment temporarily. """
|
new_env = {}
for key, value in prep_nova_creds(nova_env, nova_creds):
if type(value) == six.binary_type:
value = value.decode()
new_env[key] = value
return new_env
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def prep_nova_creds(nova_env, nova_creds):
""" Finds relevant config options in the supernova config and cleans them up for novaclient. """
|
try:
raw_creds = dict(nova_creds.get('DEFAULT', {}), **nova_creds[nova_env])
except KeyError:
msg = "{0} was not found in your supernova configuration "\
"file".format(nova_env)
raise KeyError(msg)
proxy_re = re.compile(r"(^http_proxy|^https_proxy)")
creds = []
for param, value in raw_creds.items():
if not proxy_re.match(param):
param = param.upper()
if not hasattr(value, 'startswith'):
continue
# Get values from the keyring if we find a USE_KEYRING constant
if value.startswith("USE_KEYRING"):
username, credential = pull_env_credential(nova_env, param,
value)
else:
credential = value.strip("\"'")
# Make sure we got something valid from the configuration file or
# the keyring
if not credential:
raise LookupError("No matching credentials found in keyring")
creds.append((param, credential))
return creds
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_config(config_file_override=False):
""" Pulls the supernova configuration file and reads it """
|
supernova_config = get_config_file(config_file_override)
supernova_config_dir = get_config_directory(config_file_override)
if not supernova_config and not supernova_config_dir:
raise Exception("Couldn't find a valid configuration file to parse")
nova_creds = ConfigObj()
# Can we successfully read the configuration file?
if supernova_config:
try:
nova_creds.merge(ConfigObj(supernova_config))
except:
raise("There's an error in your configuration file")
if supernova_config_dir:
for dir_file in os.listdir(supernova_config_dir):
full_path = ''.join((supernova_config_dir, dir_file))
try:
nova_creds.merge(ConfigObj(full_path))
except:
msg = "Skipping '%s', Parsing Error.".format(full_path)
print(msg)
create_dynamic_configs(nova_creds)
return nova_creds
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_config_file(override_files=False):
""" Looks for the most specific configuration file available. An override can be provided as a string if needed. """
|
if override_files:
if isinstance(override_files, six.string_types):
possible_configs = [override_files]
else:
raise Exception("Config file override must be a string")
else:
xdg_config_home = os.environ.get('XDG_CONFIG_HOME') or \
os.path.expanduser('~/.config')
possible_configs = [os.path.join(xdg_config_home, "supernova"),
os.path.expanduser("~/.supernova"),
".supernova"]
for config_file in reversed(possible_configs):
if os.path.isfile(config_file):
return config_file
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_config_directory(override_files=False):
""" Looks for the most specific configuration directory possible, in order to load individual configuration files. """
|
if override_files:
possible_dirs = [override_files]
else:
xdg_config_home = os.environ.get('XDG_CONFIG_HOME') or \
os.path.expanduser('~/.config')
possible_dirs = [os.path.join(xdg_config_home, "supernova.d/"),
os.path.expanduser("~/.supernova.d/"),
".supernova.d/"]
for config_dir in reversed(possible_dirs):
if os.path.isdir(config_dir):
return config_dir
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute_executable(nova_args, env_vars):
""" Executes the executable given by the user. Hey, I know this method has a silly name, but I write the code here and I'm silly. """
|
process = subprocess.Popen(nova_args,
stdout=sys.stdout,
stderr=subprocess.PIPE,
env=env_vars)
process.wait()
return process
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_for_debug(supernova_args, nova_args):
""" If the user wanted to run the executable with debugging enabled, we need to apply the correct arguments to the executable. Heat is a corner case since it uses -d instead of --debug. """
|
# Heat requires special handling for debug arguments
if supernova_args['debug'] and supernova_args['executable'] == 'heat':
nova_args.insert(0, '-d ')
elif supernova_args['debug']:
nova_args.insert(0, '--debug ')
return nova_args
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_for_executable(supernova_args, env_vars):
""" It's possible that a user might set their custom executable via an environment variable. If we detect one, we should add it to supernova's arguments ONLY IF an executable wasn't set on the command line. The command line executable must take priority. """
|
exe = supernova_args.get('executable', 'default')
if exe != 'default':
return supernova_args
if 'OS_EXECUTABLE' in env_vars.keys():
supernova_args['executable'] = env_vars['OS_EXECUTABLE']
return supernova_args
supernova_args['executable'] = 'nova'
return supernova_args
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_for_bypass_url(raw_creds, nova_args):
""" Return a list of extra args that need to be passed on cmdline to nova. """
|
if 'BYPASS_URL' in raw_creds.keys():
bypass_args = ['--bypass-url', raw_creds['BYPASS_URL']]
nova_args = bypass_args + nova_args
return nova_args
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run_command(nova_creds, nova_args, supernova_args):
""" Sets the environment variables for the executable, runs the executable, and handles the output. """
|
nova_env = supernova_args['nova_env']
# (gtmanfred) make a copy of this object. If we don't copy it, the insert
# to 0 happens multiple times because it is the same object in memory.
nova_args = copy.copy(nova_args)
# Get the environment variables ready
env_vars = os.environ.copy()
env_vars.update(credentials.prep_shell_environment(nova_env,
nova_creds))
# BYPASS_URL is a weird one, so we need to send it as an argument,
# not an environment variable.
nova_args = check_for_bypass_url(nova_creds[nova_env], nova_args)
# Check for OS_EXECUTABLE
supernova_args = check_for_executable(supernova_args, env_vars)
# Check for a debug override
nova_args = check_for_debug(supernova_args, nova_args)
# Print a small message for the user (very helpful for groups)
msg = "Running %s against %s..." % (supernova_args.get('executable'),
nova_env)
if not supernova_args.get('quiet'):
click.echo("[%s] %s " % (click.style('SUPERNOVA', fg='green'), msg))
# Call executable and connect stdout to the current terminal
# so that any unicode characters from the executable's list will be
# displayed appropriately.
#
# In other news, I hate how python 2.6 does unicode.
nova_args.insert(0, supernova_args['executable'])
nova_args = [nova_arg.strip() for nova_arg in nova_args]
process = execute_executable(nova_args, env_vars)
# If the user asked us to be quiet, then let's not print stderr
if not supernova_args.get('quiet'):
handle_stderr(process.stderr)
return process.returncode
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_environment_presets():
""" Checks for environment variables that can cause problems with supernova """
|
presets = [x for x in os.environ.copy().keys() if x.startswith('NOVA_') or
x.startswith('OS_')]
if len(presets) < 1:
return True
else:
click.echo("_" * 80)
click.echo("*WARNING* Found existing environment variables that may "
"cause conflicts:")
for preset in presets:
click.echo(" - %s" % preset)
click.echo("_" * 80)
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_envs_in_group(group_name, nova_creds):
""" Takes a group_name and finds any environments that have a SUPERNOVA_GROUP configuration line that matches the group_name. """
|
envs = []
for key, value in nova_creds.items():
supernova_groups = value.get('SUPERNOVA_GROUP', [])
if hasattr(supernova_groups, 'startswith'):
supernova_groups = [supernova_groups]
if group_name in supernova_groups:
envs.append(key)
elif group_name == 'all':
envs.append(key)
return envs
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_valid_group(group_name, nova_creds):
""" Checks to see if the configuration file contains a SUPERNOVA_GROUP configuration option. """
|
valid_groups = []
for key, value in nova_creds.items():
supernova_groups = value.get('SUPERNOVA_GROUP', [])
if hasattr(supernova_groups, 'startswith'):
supernova_groups = [supernova_groups]
valid_groups.extend(supernova_groups)
valid_groups.append('all')
if group_name in valid_groups:
return True
else:
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rm_prefix(name):
""" Removes nova_ os_ novaclient_ prefix from string. """
|
if name.startswith('nova_'):
return name[5:]
elif name.startswith('novaclient_'):
return name[11:]
elif name.startswith('os_'):
return name[3:]
else:
return name
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def __pad(strdata):
""" Pads `strdata` with a Request's callback argument, if specified, or does
nothing.
"""
|
if request.args.get('callback'):
return "%s(%s);" % (request.args.get('callback'), strdata)
else:
return strdata
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def __dumps(*args, **kwargs):
""" Serializes `args` and `kwargs` as JSON. Supports serializing an array
as the top-level object, if it is the only argument.
"""
|
indent = None
if (current_app.config.get('JSONIFY_PRETTYPRINT_REGULAR', False) and
not request.is_xhr):
indent = 2
return json.dumps(args[0] if len(args) is 1 else dict(*args, **kwargs),
indent=indent)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_type_lookups(self):
""" Update type and typestring lookup dicts. Must be called once the ``types`` and ``python_type_strings`` attributes are set so that ``type_to_typestring`` and ``typestring_to_type`` are constructed. .. versionadded:: 0.2 Notes ----- Subclasses need to call this function explicitly. """
|
self.type_to_typestring = dict(zip(self.types,
self.python_type_strings))
self.typestring_to_type = dict(zip(self.python_type_strings,
self.types))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_type_string(self, data, type_string):
""" Gets type string. Finds the type string for 'data' contained in ``python_type_strings`` using its ``type``. Non-``None`` 'type_string` overrides whatever type string is looked up. The override makes it easier for subclasses to convert something that the parent marshaller can write to disk but still put the right type string in place). Parameters data : type to be marshalled The Python object that is being written to disk. type_string : str or None If it is a ``str``, it overrides any looked up type string. ``None`` means don't override. Returns ------- str The type string associated with 'data'. Will be 'type_string' if it is not ``None``. Notes ----- Subclasses probably do not need to override this method. """
|
if type_string is not None:
return type_string
else:
tp = type(data)
try:
return self.type_to_typestring[tp]
except KeyError:
return self.type_to_typestring[tp.__module__ + '.'
+ tp.__name__]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write(self, f, grp, name, data, type_string, options):
""" Writes an object's metadata to file. Writes the Python object 'data' to 'name' in h5py.Group 'grp'. .. versionchanged:: 0.2 Arguements changed. Parameters f : h5py.File The HDF5 file handle that is open. grp : h5py.Group or h5py.File The parent HDF5 Group (or File if at '/') that contains the object with the specified name. name : str Name of the object. data The object to write to file. type_string : str or None The type string for `data`. If it is ``None``, one will have to be gotten by ``get_type_string``. options : hdf5storage.core.Options hdf5storage options object. Raises ------ NotImplementedError If writing 'data' to file is currently not supported. hdf5storage.exceptions.TypeNotMatlabCompatibleError If writing a type not compatible with MATLAB and `options.action_for_matlab_incompatible` is set to ``'error'``. Notes ----- Must be overridden in a subclass because a ``NotImplementedError`` is thrown immediately. See Also -------- hdf5storage.utilities.write_data """
|
raise NotImplementedError('Can''t write data type: '
+ str(type(data)))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_metadata(self, f, dsetgrp, data, type_string, options, attributes=None):
""" Writes an object to file. Writes the metadata for a Python object `data` to file at `name` in h5py.Group `grp`. Metadata is written to HDF5 Attributes. Existing Attributes that are not being used are deleted. .. versionchanged:: 0.2 Arguements changed. Parameters f : h5py.File The HDF5 file handle that is open. dsetgrp : h5py.Dataset or h5py.Group The Dataset or Group object to add metadata to. data The object to write to file. type_string : str or None The type string for `data`. If it is ``None``, one will have to be gotten by ``get_type_string``. options : hdf5storage.core.Options hdf5storage options object. attributes : dict or None, optional The Attributes to set. The keys (``str``) are the names. The values are ``tuple`` of the Attribute kind and the value to set. Valid kinds are ``'string_array'``, ``'string'``, and ``'value'``. The values must correspond to what ``set_attribute_string_array``, ``set_attribute_string`` and ``set_attribute`` would take respectively. Default is no Attributes to set (``None``). Notes ----- The attribute 'Python.Type' is set to the type string. All H5PY Attributes not in ``python_attributes`` and/or ``matlab_attributes`` (depending on the attributes of 'options') are deleted. These are needed functions for writting essentially any Python object, so subclasses should probably call the baseclass's version of this function if they override it and just provide the additional functionality needed. This requires that the names of any additional HDF5 Attributes are put in the appropriate set. See Also -------- utilities.set_attributes_all """
|
if attributes is None:
attributes = dict()
# Make sure we have a complete type_string.
if options.store_python_metadata \
and 'Python.Type' not in attributes:
attributes['Python.Type'] = \
('string', self.get_type_string(data, type_string))
set_attributes_all(dsetgrp, attributes, discard_others=True)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_path(pth):
""" Processes paths. Processes the provided path and breaks it into it Group part (`groupname`) and target part (`targetname`). ``bytes`` paths are converted to ``str``. Separated paths are given as an iterable of ``str`` and ``bytes``. Each part of a separated path is escaped using ``escape_path``. Otherwise, the path is assumed to be already escaped. Escaping is done so that targets with a part that starts with one or more periods, contain slashes, and/or contain nulls can be used without causing the wrong Group to be looked in or the wrong target to be looked at. It essentially allows one to make a Dataset named ``'..'`` or ``'a/a'`` instead of moving around in the Dataset hierarchy. All paths are POSIX style. .. versionadded:: 0.2 Parameters pth : str or bytes or iterable of str or bytes The POSIX style path as a ``str`` or ``bytes`` or the separated path in an iterable with the elements being ``str`` and ``bytes``. For separated paths, escaping will be done on each part. Returns ------- groupname : str The path to the Group containing the target `pth` was pointing to. targetname : str The name of the target pointed to by `pth` in the Group `groupname`. Raises ------ TypeError If `pth` is not of the right type. See Also -------- escape_path """
|
# Do conversions and possibly escapes.
if isinstance(pth, bytes):
p = pth.decode('utf-8')
elif (sys.hexversion >= 0x03000000 and isinstance(pth, str)) \
or (sys.hexversion < 0x03000000 \
and isinstance(pth, unicode)):
p = pth
elif not isinstance(pth, collections.Iterable):
raise TypeError('p must be str, bytes, or an iterable '
+ 'solely of one of those two.')
else:
# Check that all elements are unicode or bytes.
if sys.hexversion >= 0x03000000:
if not all([isinstance(s, (bytes, str)) for s in pth]):
raise TypeError('Elements of p must be str or bytes.')
else:
if not all([isinstance(s, (str, unicode)) for s in pth]):
raise TypeError('Elements of p must be str or '
+ 'unicode.')
# Escape (and possibly convert to unicode) each element and then
# join them all together.
parts = [None] * len(pth)
for i, s in enumerate(pth):
if isinstance(s, bytes):
s = s.decode('utf-8')
parts[i] = escape_path(s)
parts = tuple(parts)
p = posixpath.join(*parts)
# Remove double slashes and a non-root trailing slash.
path = posixpath.normpath(p)
# Extract the group name and the target name (will be a dataset if
# data can be mapped to it, but will end up being made into a group
# otherwise. As HDF5 files use posix path, conventions, posixpath
# will do everything.
groupname = posixpath.dirname(path)
targetname = posixpath.basename(path)
# If groupname got turned into blank, then it is just root.
if len(groupname) == 0:
groupname = b'/'.decode('ascii')
# If targetname got turned blank, then it is the current directory.
if len(targetname) == 0:
targetname = b'.'.decode('ascii')
return groupname, targetname
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_object_array(f, data, options):
""" Writes an array of objects recursively. Writes the elements of the given object array recursively in the HDF5 Group ``options.group_for_references`` and returns an ``h5py.Reference`` array to all the elements. Parameters f : h5py.File The HDF5 file handle that is open. data : numpy.ndarray of objects Numpy object array to write the elements of. options : hdf5storage.core.Options hdf5storage options object. Returns ------- obj_array : numpy.ndarray of h5py.Reference A reference array pointing to all the elements written to the HDF5 file. For those that couldn't be written, the respective element points to the canonical empty. Raises ------ TypeNotMatlabCompatibleError If writing a type not compatible with MATLAB and `options.action_for_matlab_incompatible` is set to ``'error'``. See Also -------- read_object_array hdf5storage.Options.group_for_references h5py.Reference """
|
# We need to grab the special reference dtype and make an empty
# array to store all the references in.
ref_dtype = h5py.special_dtype(ref=h5py.Reference)
data_refs = np.zeros(shape=data.shape, dtype='object')
# We need to make sure that the group to hold references is present,
# and create it if it isn't.
if options.group_for_references not in f:
f.create_group(options.group_for_references)
grp2 = f[options.group_for_references]
if not isinstance(grp2, h5py.Group):
del f[options.group_for_references]
f.create_group(options.group_for_references)
grp2 = f[options.group_for_references]
# The Dataset 'a' needs to be present as the canonical empty. It is
# just and np.uint32/64([0, 0]) with its a MATLAB_class of
# 'canonical empty' and the 'MATLAB_empty' attribute set. If it
# isn't present or is incorrectly formatted, it is created
# truncating anything previously there.
try:
dset_a = grp2['a']
if dset_a.shape != (2,) \
or not dset_a.dtype.name.startswith('uint') \
or np.any(dset_a[...] != np.uint64([0, 0])) \
or get_attribute_string(dset_a, 'MATLAB_class') != \
'canonical empty' \
or get_attribute(dset_a, 'MATLAB_empty') != 1:
del grp2['a']
dset_a = grp2.create_dataset('a', data=np.uint64([0, 0]))
set_attribute_string(dset_a, 'MATLAB_class',
'canonical empty')
set_attribute(dset_a, 'MATLAB_empty',
np.uint8(1))
except:
dset_a = grp2.create_dataset('a', data=np.uint64([0, 0]))
set_attribute_string(dset_a, 'MATLAB_class',
'canonical empty')
set_attribute(dset_a, 'MATLAB_empty',
np.uint8(1))
# Go through all the elements of data and write them, gabbing their
# references and putting them in data_refs. They will be put in
# group_for_references, which is also what the H5PATH needs to be
# set to if we are doing MATLAB compatibility (otherwise, the
# attribute needs to be deleted). If an element can't be written
# (doing matlab compatibility, but it isn't compatible with matlab
# and action_for_matlab_incompatible option is True), the reference
# to the canonical empty will be used for the reference array to
# point to.
grp2name = grp2.name
for index, x in np.ndenumerate(data):
name_for_ref = next_unused_name_in_group(grp2, 16)
write_data(f, grp2, name_for_ref, x, None, options)
try:
dset = grp2[name_for_ref]
data_refs[index] = dset.ref
if options.matlab_compatible:
set_attribute_string(dset,
'H5PATH', grp2name)
else:
del_attribute(dset, 'H5PATH')
except:
data_refs[index] = dset_a.ref
# Now, the dtype needs to be changed to the reference type and the
# whole thing copied over to data_to_store.
return data_refs.astype(ref_dtype).copy()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_object_array(f, data, options):
""" Reads an array of objects recursively. Read the elements of the given HDF5 Reference array recursively in the and constructs a ``numpy.object_`` array from its elements, which is returned. Parameters f : h5py.File The HDF5 file handle that is open. data : numpy.ndarray of h5py.Reference The array of HDF5 References to read and make an object array from. options : hdf5storage.core.Options hdf5storage options object. Raises ------ NotImplementedError If reading the object from file is currently not supported. Returns ------- obj_array : numpy.ndarray of numpy.object\_ The Python object array containing the items pointed to by `data`. See Also -------- write_object_array hdf5storage.Options.group_for_references h5py.Reference """
|
# Go through all the elements of data and read them using their
# references, and the putting the output in new object array.
data_derefed = np.zeros(shape=data.shape, dtype='object')
for index, x in np.ndenumerate(data):
data_derefed[index] = read_data(f, None, None,
options,
dsetgrp=f[x])
return data_derefed
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def next_unused_name_in_group(grp, length):
""" Gives a name that isn't used in a Group. Generates a name of the desired length that is not a Dataset or Group in the given group. Note, if length is not large enough and `grp` is full enough, there may be no available names meaning that this function will hang. Parameters grp : h5py.Group or h5py.File The HDF5 Group (or File if at '/') to generate an unused name in. length : int Number of characters the name should be. Returns ------- name : str A name that isn't already an existing Dataset or Group in `grp`. """
|
# While
#
# ltrs = string.ascii_letters + string.digits
# name = ''.join([random.choice(ltrs) for i in range(length)])
#
# seems intuitive, its performance is abysmal compared to
#
# '%0{0}x'.format(length) % random.getrandbits(length * 4)
#
# The difference is a factor of 20. Idea from
#
# https://stackoverflow.com/questions/2782229/most-lightweight-way-
# to-create-a-random-string-and-a-random-hexadecimal-number/
# 35161595#35161595
fmt = '%0{0}x'.format(length)
name = fmt % random.getrandbits(length * 4)
while name in grp:
name = fmt % random.getrandbits(length * 4)
return name
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def convert_numpy_str_to_uint16(data):
""" Converts a numpy.unicode\_ to UTF-16 in numpy.uint16 form. Convert a ``numpy.unicode_`` or an array of them (they are UTF-32 strings) to UTF-16 in the equivalent array of ``numpy.uint16``. The conversion will throw an exception if any characters cannot be converted to UTF-16. Strings are expanded along rows (across columns) so a 2x3x4 array of 10 element strings will get turned into a 2x30x4 array of uint16's if every UTF-32 character converts easily to a UTF-16 singlet, as opposed to a UTF-16 doublet. Parameters data : numpy.unicode\_ or numpy.ndarray of numpy.unicode\_ The string or array of them to convert. Returns ------- array : numpy.ndarray of numpy.uint16 The result of the conversion. Raises ------ UnicodeEncodeError If a UTF-32 character has no UTF-16 representation. See Also -------- convert_numpy_str_to_uint32 convert_to_numpy_str """
|
# An empty string should be an empty uint16
if data.nbytes == 0:
return np.uint16([])
# We need to use the UTF-16 codec for our endianness. Using the
# right one means we don't have to worry about removing the BOM.
if sys.byteorder == 'little':
codec = 'UTF-16LE'
else:
codec = 'UTF-16BE'
# numpy.char.encode can do the conversion element wise. Then, we
# just have convert to uin16 with the appropriate dimensions. The
# dimensions are gotten from the shape of the converted data with
# the number of column increased by the number of words (pair of
# bytes) in the strings.
cdata = np.char.encode(np.atleast_1d(data), codec)
shape = list(cdata.shape)
shape[-1] *= (cdata.dtype.itemsize // 2)
return np.ndarray(shape=shape, dtype='uint16',
buffer=cdata.tostring())
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def convert_numpy_str_to_uint32(data):
""" Converts a numpy.unicode\_ to its numpy.uint32 representation. Convert a ``numpy.unicode_`` or an array of them (they are UTF-32 strings) into the equivalent array of ``numpy.uint32`` that is byte for byte identical. Strings are expanded along rows (across columns) so a 2x3x4 array of 10 element strings will get turned into a 2x30x4 array of uint32's. Parameters data : numpy.unicode\_ or numpy.ndarray of numpy.unicode\_ The string or array of them to convert. Returns ------- array : numpy.ndarray of numpy.uint32 The result of the conversion. See Also -------- convert_numpy_str_to_uint16 convert_to_numpy_str """
|
if data.nbytes == 0:
# An empty string should be an empty uint32.
return np.uint32([])
else:
# We need to calculate the new shape from the current shape,
# which will have to be expanded along the rows to fit all the
# characters (the dtype.itemsize gets the number of bytes in
# each string, which is just 4 times the number of
# characters. Then it is a mstter of getting a view of the
# string (in flattened form so that it is contiguous) as uint32
# and then reshaping it.
shape = list(np.atleast_1d(data).shape)
shape[-1] *= data.dtype.itemsize//4
return data.flatten().view(np.uint32).reshape(tuple(shape))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def decode_complex(data, complex_names=(None, None)):
""" Decodes possibly complex data read from an HDF5 file. Decodes possibly complex datasets read from an HDF5 file. HDF5 doesn't have a native complex type, so they are stored as H5T_COMPOUND types with fields such as 'r' and 'i' for the real and imaginary parts. As there is no standardization for field names, the field names have to be given explicitly, or the fieldnames in `data` analyzed for proper decoding to figure out the names. A variety of reasonably expected combinations of field names are checked and used if available to decode. If decoding is not possible, it is returned as is. Parameters data : arraylike The data read from an HDF5 file, that might be complex, to decode into the proper Numpy complex type. complex_names : tuple of 2 str and/or Nones, optional ``tuple`` of the names to use (in order) for the real and imaginary fields. A ``None`` indicates that various common field names should be tried. Returns ------- c : decoded data or data If `data` can be decoded into a complex type, the decoded complex version is returned. Otherwise, `data` is returned unchanged. See Also -------- encode_complex Notes ----- Currently looks for real field names of ``('r', 're', 'real')`` and imaginary field names of ``('i', 'im', 'imag', 'imaginary')`` ignoring case. """
|
# Now, complex types are stored in HDF5 files as an H5T_COMPOUND type
# with fields along the lines of ('r', 're', 'real') and ('i', 'im',
# 'imag', 'imaginary') for the real and imaginary parts, which most
# likely won't be properly extracted back into making a Python
# complex type unless the proper h5py configuration is set. Since we
# can't depend on it being set and adjusting it is hazardous (the
# setting is global), it is best to just decode it manually. These
# fields are obtained from the fields of its dtype. Obviously, if
# there are no fields, then there is nothing to do.
if data.dtype.fields is None:
return data
fields = list(data.dtype.fields)
# If there aren't exactly two fields, then it can't be complex.
if len(fields) != 2:
return data
# We need to grab the field names for the real and imaginary
# parts. This will be done by seeing which list, if any, each field
# is and setting variables to the proper name if it is in it (they
# are initialized to None so that we know if one isn't found).
real_fields = ['r', 're', 'real']
imag_fields = ['i', 'im', 'imag', 'imaginary']
cnames = list(complex_names)
for s in fields:
if s.lower() in real_fields:
cnames[0] = s
elif s.lower() in imag_fields:
cnames[1] = s
# If the real and imaginary fields were found, construct the complex
# form from the fields. This is done by finding the complex type
# that they cast to, making an array, and then setting the
# parts. Otherwise, return what we were given because it isn't in
# the right form.
if cnames[0] is not None and cnames[1] is not None:
cdata = np.result_type(data[cnames[0]].dtype, \
data[cnames[1]].dtype, 'complex64').type(data[cnames[0]])
cdata.imag = data[cnames[1]]
return cdata
else:
return data
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def encode_complex(data, complex_names):
""" Encodes complex data to having arbitrary complex field names. Encodes complex `data` to have the real and imaginary field names given in `complex_numbers`. This is needed because the field names have to be set so that it can be written to an HDF5 file with the right field names (HDF5 doesn't have a native complex type, so H5T_COMPOUND have to be used). Parameters data : arraylike The data to encode as a complex type with the desired real and imaginary part field names. complex_names : tuple of 2 str ``tuple`` of the names to use (in order) for the real and imaginary fields. Returns ------- d : encoded data `data` encoded into having the specified field names for the real and imaginary parts. See Also -------- decode_complex """
|
# Grab the dtype name, and convert it to the right non-complex type
# if it isn't already one.
dtype_name = data.dtype.name
if dtype_name[0:7] == 'complex':
dtype_name = 'float' + str(int(float(dtype_name[7:])/2))
# Create the new version of the data with the right field names for
# the real and complex parts. This is easy to do with putting the
# right detype in the view function.
dt = np.dtype([(complex_names[0], dtype_name),
(complex_names[1], dtype_name)])
return data.view(dt).copy()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def convert_attribute_to_string(value):
""" Convert an attribute value to a string. Converts the attribute value to a string if possible (get ``None`` if isn't a string type). .. versionadded:: 0.2 Parameters value : The Attribute value. Returns ------- s : str or None The ``str`` value of the attribute if the conversion is possible, or ``None`` if not. """
|
if value is None:
return value
elif (sys.hexversion >= 0x03000000 and isinstance(value, str)) \
or (sys.hexversion < 0x03000000 \
and isinstance(value, unicode)):
return value
elif isinstance(value, bytes):
return value.decode()
elif isinstance(value, np.unicode_):
return str(value)
elif isinstance(value, np.bytes_):
return value.decode()
else:
return None
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_attribute(target, name, value):
""" Sets an attribute on a Dataset or Group. If the attribute `name` doesn't exist yet, it is created. If it already exists, it is overwritten if it differs from `value`. Notes ----- ``set_attributes_all`` is the fastest way to set and delete Attributes in bulk. Parameters target : Dataset or Group Dataset or Group to set the attribute of. name : str Name of the attribute to set. value : numpy type other than numpy.unicode\_ Value to set the attribute to. See Also -------- set_attributes_all """
|
try:
target.attrs.modify(name, value)
except:
target.attrs.create(name, value)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_attribute_string(target, name, value):
""" Sets an attribute to a string on a Dataset or Group. If the attribute `name` doesn't exist yet, it is created. If it already exists, it is overwritten if it differs from `value`. Notes ----- ``set_attributes_all`` is the fastest way to set and delete Attributes in bulk. Parameters target : Dataset or Group Dataset or Group to set the string attribute of. name : str Name of the attribute to set. value : string Value to set the attribute to. Can be any sort of string type that will convert to a ``numpy.bytes_`` See Also -------- set_attributes_all """
|
set_attribute(target, name, np.bytes_(value))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_attribute_string_array(target, name, string_list):
""" Sets an attribute to an array of string on a Dataset or Group. If the attribute `name` doesn't exist yet, it is created. If it already exists, it is overwritten with the list of string `string_list` (they will be vlen strings). Notes ----- ``set_attributes_all`` is the fastest way to set and delete Attributes in bulk. Parameters target : Dataset or Group Dataset or Group to set the string array attribute of. name : str Name of the attribute to set. string_list : list of str List of strings to set the attribute to. Strings must be ``str`` See Also -------- set_attributes_all """
|
s_list = [convert_to_str(s) for s in string_list]
if sys.hexversion >= 0x03000000:
target.attrs.create(name, s_list,
dtype=h5py.special_dtype(vlen=str))
else:
target.attrs.create(name, s_list,
dtype=h5py.special_dtype(vlen=unicode))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_attributes_all(target, attributes, discard_others=True):
""" Set Attributes in bulk and optionally discard others. Sets each Attribute in turn (modifying it in place if possible if it is already present) and optionally discarding all other Attributes not explicitly set. This function yields much greater performance than the required individual calls to ``set_attribute``, ``set_attribute_string``, ``set_attribute_string_array`` and ``del_attribute`` put together. .. versionadded:: 0.2 Parameters target : Dataset or Group Dataset or Group to set the Attributes of. attributes : dict The Attributes to set. The keys (``str``) are the names. The values are ``tuple`` of the Attribute kind and the value to set. Valid kinds are ``'string_array'``, ``'string'``, and ``'value'``. The values must correspond to what ``set_attribute_string_array``, ``set_attribute_string`` and ``set_attribute`` would take respectively. discard_others : bool, optional Whether to discard all other Attributes not explicitly set (default) or not. See Also -------- set_attribute set_attribute_string set_attribute_string_array """
|
attrs = target.attrs
existing = dict(attrs.items())
# Generate special dtype for string arrays.
if sys.hexversion >= 0x03000000:
str_arr_dtype = h5py.special_dtype(vlen=str)
else:
str_arr_dtype = dtype=h5py.special_dtype(vlen=unicode)
# Go through each attribute. If it is already present, modify it if
# possible and create it otherwise (deletes old value.)
for k, (kind, value) in attributes.items():
if kind == 'string_array':
attrs.create(k, [convert_to_str(s) for s in value],
dtype=str_arr_dtype)
else:
if kind == 'string':
value = np.bytes_(value)
if k not in existing:
attrs.create(k, value)
else:
try:
if value.dtype == existing[k].dtype \
and value.shape == existing[k].shape:
attrs.modify(k, value)
except:
attrs.create(k, value)
# Discard all other attributes.
if discard_others:
for k in set(existing) - set(attributes):
del attrs[k]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find_thirdparty_marshaller_plugins():
""" Find, but don't load, all third party marshaller plugins. Third party marshaller plugins declare the entry point ``'hdf5storage.marshallers.plugins'`` with the name being the Marshaller API version and the target being a function that returns a ``tuple`` or ``list`` of all the marshallers provided by that plugin when given the hdf5storage version (``str``) as its only argument. .. versionadded:: 0.2 Returns ------- plugins : dict The marshaller obtaining entry points from third party plugins. The keys are the Marshaller API versions (``str``) and the values are ``dict`` of the entry points, with the module names as the keys (``str``) and the values being the entry points (``pkg_resources.EntryPoint``). See Also -------- supported_marshaller_api_versions """
|
all_plugins = tuple(pkg_resources.iter_entry_points(
'hdf5storage.marshallers.plugins'))
return {ver: {p.module_name: p
for p in all_plugins if p.name == ver}
for ver in supported_marshaller_api_versions()}
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def savemat(file_name, mdict, appendmat=True, format='7.3', oned_as='row', store_python_metadata=True, action_for_matlab_incompatible='error', marshaller_collection=None, truncate_existing=False, truncate_invalid_matlab=False, **keywords):
""" Save a dictionary of python types to a MATLAB MAT file. Saves the data provided in the dictionary `mdict` to a MATLAB MAT file. `format` determines which kind/vesion of file to use. The '7.3' version, which is HDF5 based, is handled by this package and all types that this package can write are supported. Versions 4 and 5 are not HDF5 based, so everything is dispatched to the SciPy package's ``scipy.io.savemat`` function, which this function is modelled after (arguments not specific to this package have the same names, etc.). Parameters file_name : str or file-like object Name of the MAT file to store in. The '.mat' extension is added on automatically if not present if `appendmat` is set to ``True``. An open file-like object can be passed if the writing is being dispatched to SciPy (`format` < 7.3). mdict : dict The dictionary of variables and their contents to store in the file. appendmat : bool, optional Whether to append the '.mat' extension to `file_name` if it doesn't already end in it or not. format : {'4', '5', '7.3'}, optional The MATLAB mat file format to use. The '7.3' format is handled by this package while the '4' and '5' formats are dispatched to SciPy. oned_as : {'row', 'column'}, optional Whether 1D arrays should be turned into row or column vectors. store_python_metadata : bool, optional Whether or not to store Python type information. Doing so allows most types to be read back perfectly. Only applicable if not dispatching to SciPy (`format` >= 7.3). action_for_matlab_incompatible: str, optional The action to perform writing data that is not MATLAB compatible. The actions are to write the data anyways ('ignore'), don't write the incompatible data ('discard'), or throw a ``TypeNotMatlabCompatibleError`` exception. marshaller_collection : MarshallerCollection, optional Collection of marshallers to disk to use. Only applicable if not dispatching to SciPy (`format` >= 7.3). truncate_existing : bool, optional Whether to truncate the file if it already exists before writing to it. truncate_invalid_matlab : bool, optional Whether to truncate a file if the file doesn't have the proper header (userblock in HDF5 terms) setup for MATLAB metadata to be placed. **keywords : Additional keywords arguments to be passed onto ``scipy.io.savemat`` if dispatching to SciPy (`format` < 7.3). Raises ------ ImportError If `format` < 7.3 and the ``scipy`` module can't be found. NotImplementedError If writing a variable in `mdict` is not supported. exceptions.TypeNotMatlabCompatibleError If writing a type not compatible with MATLAB and `action_for_matlab_incompatible` is set to ``'error'``. Notes ----- Writing the same data and then reading it back from disk using the HDF5 based version 7.3 format (the functions in this package) or the older format (SciPy functions) can lead to very different results. Each package supports a different set of data types and converts them to and from the same MATLAB types differently. See Also -------- loadmat : Equivelent function to do reading. scipy.io.savemat : SciPy function this one models after and dispatches to. Options writes : Function used to do the actual writing. """
|
# If format is a number less than 7.3, the call needs to be
# dispatched to the scipy version, if it is available, with all the
# relevant and extra keywords options provided.
if float(format) < 7.3:
import scipy.io
scipy.io.savemat(file_name, mdict, appendmat=appendmat,
format=format, oned_as=oned_as, **keywords)
return
# Append .mat if it isn't on the end of the file name and we are
# supposed to.
if appendmat and not file_name.endswith('.mat'):
file_name = file_name + '.mat'
# Make the options with matlab compatibility forced.
options = Options(store_python_metadata=store_python_metadata, \
matlab_compatible=True, oned_as=oned_as, \
action_for_matlab_incompatible=action_for_matlab_incompatible, \
marshaller_collection=marshaller_collection)
# Write the variables in the dictionary to file.
writes(mdict=mdict, filename=file_name,
truncate_existing=truncate_existing,
truncate_invalid_matlab=truncate_invalid_matlab,
options=options)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def loadmat(file_name, mdict=None, appendmat=True, variable_names=None, marshaller_collection=None, **keywords):
""" Loads data to a MATLAB MAT file. Reads data from the specified variables (or all) in a MATLAB MAT file. There are many different formats of MAT files. This package can only handle the HDF5 based ones (the version 7.3 and later). As SciPy's ``scipy.io.loadmat`` function can handle the earlier formats, if this function cannot read the file, it will dispatch it onto the scipy function with all the calling arguments it uses passed on. This function is modelled after the SciPy one (arguments not specific to this package have the same names, etc.). Parameters file_name : str Name of the MAT file to read from. The '.mat' extension is added on automatically if not present if `appendmat` is set to ``True``. mdict : dict, optional The dictionary to insert read variables into appendmat : bool, optional Whether to append the '.mat' extension to `file_name` if it doesn't already end in it or not. variable_names: None or sequence, optional The variable names to read from the file. ``None`` selects all. marshaller_collection : MarshallerCollection, optional Collection of marshallers from disk to use. Only applicable if not dispatching to SciPy (version 7.3 and newer files). **keywords : Additional keywords arguments to be passed onto ``scipy.io.loadmat`` if dispatching to SciPy if the file is not a version 7.3 or later format. Returns ------- dict Dictionary of all the variables read from the MAT file (name as the key, and content as the value). Raises ------ ImportError If it is not a version 7.3 .mat file and the ``scipy`` module can't be found when dispatching to SciPy. exceptions.CantReadError If reading the data can't be done. Notes ----- Writing the same data and then reading it back from disk using the HDF5 based version 7.3 format (the functions in this package) or the older format (SciPy functions) can lead to very different results. Each package supports a different set of data types and converts them to and from the same MATLAB types differently. See Also -------- savemat : Equivalent function to do writing. scipy.io.loadmat : SciPy function this one models after and dispatches to. Options reads : Function used to do the actual reading. """
|
# Will first assume that it is the HDF5 based 7.3 format. If an
# OSError occurs, then it wasn't an HDF5 file and the scipy function
# can be tried instead.
try:
# Make the options with the given marshallers.
options = Options(marshaller_collection=marshaller_collection)
# Append .mat if it isn't on the end of the file name and we are
# supposed to.
if appendmat and not file_name.endswith('.mat'):
filename = file_name + '.mat'
else:
filename = file_name
# Read everything if we were instructed.
if variable_names is None:
data = dict()
with h5py.File(filename, mode='r') as f:
for k in f:
# Read if not group_for_references. Data that
# produces errors when read is dicarded (the OSError
# that would happen if this is not an HDF5 file
# would already have happened when opening the
# file).
if f[k].name != options.group_for_references:
try:
data[utilities.unescape_path(k)] = \
utilities.read_data(f, f, k, options)
except:
pass
else:
# Extract the desired fields all together and then pack them
# into a dictionary one by one.
values = reads(paths=variable_names, filename=filename,
options=options)
data = dict()
for i, name in enumerate(variable_names):
data[name] = values[i]
# Read all the variables, stuff them into mdict, and return it.
if mdict is None:
mdict = dict()
for k, v in data.items():
mdict[k] = v
return mdict
except OSError:
import scipy.io
return scipy.io.loadmat(file_name, mdict, appendmat=appendmat,
variable_names=variable_names,
**keywords)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _update_marshallers(self):
""" Update the full marshaller list and other data structures. Makes a full list of both builtin and user marshallers and rebuilds internal data structures used for looking up which marshaller to use for reading/writing Python objects to/from file. Also checks for whether the required modules are present or not, loading the required modules (if not doing lazy loading), and whether the required modules are imported already or not. """
|
# Combine all sets of marshallers.
self._marshallers = []
for v in self._priority:
if v == 'builtin':
self._marshallers.extend(self._builtin_marshallers)
elif v == 'plugin':
self._marshallers.extend(self._plugin_marshallers)
elif v == 'user':
self._marshallers.extend(self._user_marshallers)
else:
raise ValueError('priority attribute has an illegal '
'element value.')
# Determine whether the required modules are present, do module
# loading, and determine whether the required modules are
# imported.
self._has_required_modules = len(self._marshallers) * [False]
self._imported_required_modules = \
len(self._marshallers) * [False]
for i, m in enumerate(self._marshallers):
# Check if the required modules are here.
try:
for name in m.required_parent_modules:
if name not in sys.modules \
and pkgutil.find_loader(name) is None:
raise ImportError('module not present')
except ImportError:
self._has_required_modules[i] = False
except:
raise
else:
self._has_required_modules[i] = True
# Modules obviously can't be fully loaded if not all are
# present.
if not self._has_required_modules[i]:
self._imported_required_modules[i] = False
continue
# Check if all modules are loaded or not, and load them if
# doing lazy loading.
try:
for name in m.required_modules:
if name not in sys.modules:
raise ImportError('module not loaded yet.')
except ImportError:
if self._lazy_loading:
self._imported_required_modules[i] = False
else:
success = self._import_marshaller_modules(m)
self._has_required_modules[i] = success
self._imported_required_modules[i] = success
except:
raise
else:
self._imported_required_modules[i] = True
# Construct the dictionary to look up the appropriate marshaller
# by type, the equivalent one to read data types given type
# strings needs to be created from it (basically, we have to
# make the key be the python_type_string from it), and the
# equivalent one to read data types given MATLAB class strings
# needs to be created from it (basically, we have to make the
# key be the matlab_class from it).
#
# Marshallers earlier in the list have priority (means that the
# builtins have the highest). Since the types can be specified
# as strings as well, duplicates will be checked for by running
# each type through str if it isn't str.
types_as_str = set()
self._types = dict()
self._type_strings = dict()
self._matlab_classes = dict()
for i, m in enumerate(self._marshallers):
# types.
for tp in m.types:
if isinstance(tp, str):
tp_as_str = tp
else:
tp_as_str = tp.__module__ + '.' + tp.__name__
if tp_as_str not in types_as_str:
self._types[tp_as_str] = i
types_as_str.add(tp_as_str)
# type strings
for type_string in m.python_type_strings:
if type_string not in self._type_strings:
self._type_strings[type_string] = i
# matlab classes.
for matlab_class in m.matlab_classes:
if matlab_class not in self._matlab_classes:
self._matlab_classes[matlab_class] = i
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _import_marshaller_modules(self, m):
""" Imports the modules required by the marshaller. Parameters m : marshaller The marshaller to load the modules for. Returns ------- success : bool Whether the modules `m` requires could be imported successfully or not. """
|
try:
for name in m.required_modules:
if name not in sys.modules:
if _has_importlib:
importlib.import_module(name)
else:
__import__(name)
except ImportError:
return False
except:
raise
else:
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_marshaller_for_type(self, tp):
""" Gets the appropriate marshaller for a type. Retrieves the marshaller, if any, that can be used to read/write a Python object with type 'tp'. The modules it requires, if available, will be loaded. Parameters tp : type or str Python object ``type`` (which would be the class reference) or its string representation like ``'collections.deque'``. Returns ------- marshaller : marshaller or None The marshaller that can read/write the type to file. ``None`` if no appropriate marshaller is found. has_required_modules : bool Whether the required modules for reading the type are present or not. See Also -------- hdf5storage.Marshallers.TypeMarshaller.types """
|
if not isinstance(tp, str):
tp = tp.__module__ + '.' + tp.__name__
if tp in self._types:
index = self._types[tp]
else:
return None, False
m = self._marshallers[index]
if self._imported_required_modules[index]:
return m, True
if not self._has_required_modules[index]:
return m, False
success = self._import_marshaller_modules(m)
self._has_required_modules[index] = success
self._imported_required_modules[index] = success
return m, success
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.