def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('SetAPI'):
cls.cfg[nameval[0]] = nameval[1]
authServiceUrl = cls.cfg.get(
"auth-service-url",
"https://kbase.us/services/authorization/Sessions/Login")
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({
'token':
token,
'user_id':
user_id,
'provenance': [{
'service': 'SetAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = SetAPI(cls.cfg)
# setup data at the class level for now (so that the code is run
# once for all tests, not before each test case. Not sure how to
# do that outside this function..)
suffix = int(time.time() * 1000)
wsName = "test_SetAPI_" + str(suffix)
cls.wsClient.create_workspace({'workspace': wsName})
cls.wsName = wsName
foft = FakeObjectsForTests(os.environ['SDK_CALLBACK_URL'])
# Make fake genomes
[fake_genome, fake_genome2] = foft.create_fake_genomes({
"ws_name":
wsName,
"obj_names": ["fake_genome", "fake_genome2"]
})
cls.genome_refs = [info_to_ref(fake_genome), info_to_ref(fake_genome2)]
# Make some fake feature sets
cls.featureset_refs = [
make_fake_feature_set("feature_set_{}".format(i),
cls.genome_refs[0], wsName, cls.wsClient)
for i in range(3)
]
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
user_id = requests.post(
'https://kbase.us/services/authorization/Sessions/Login',
data='token={}&fields=user_id'.format(token)).json()['user_id']
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({'token': token,
'user_id': user_id,
'provenance': [
{'service': 'SetAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('SetAPI'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = SetAPI(cls.cfg)
cls.serviceWizardURL = cls.cfg['service-wizard']
cls.dataPaletteServiceVersion = cls.cfg['datapaletteservice-version']
# setup data at the class level for now (so that the code is run
# once for all tests, not before each test case. Not sure how to
# do that outside this function..)
suffix = int(time.time() * 1000)
wsName = "test_SetAPI_" + str(suffix)
ret = cls.wsClient.create_workspace({'workspace': wsName})
cls.wsName = wsName
# copy test file to scratch area
fq_filename = "interleaved.fastq"
fq_path = os.path.join(cls.cfg['scratch'], fq_filename)
shutil.copy(os.path.join("data", fq_filename), fq_path)
ru = ReadsUtils(os.environ['SDK_CALLBACK_URL'])
cls.read1ref = ru.upload_reads({
'fwd_file': fq_path,
'sequencing_tech': 'tech1',
'wsname': wsName,
'name': 'reads1',
'interleaved':1
})['obj_ref']
cls.read2ref = ru.upload_reads({
'fwd_file': fq_path,
'sequencing_tech': 'tech2',
'wsname': wsName,
'name': 'reads2',
'interleaved':1
})['obj_ref']
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('SetAPI'):
cls.cfg[nameval[0]] = nameval[1]
authServiceUrl = cls.cfg.get(
'auth-service-url',
"https://kbase.us/services/authorization/Sessions/Login")
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({
'token':
token,
'user_id':
user_id,
'provenance': [{
'service': 'SetAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = SetAPI(cls.cfg)
# setup data at the class level for now (so that the code is run
# once for all tests, not before each test case. Not sure how to
# do that outside this function..)
suffix = int(time.time() * 1000)
wsName = "test_SetAPI_" + str(suffix)
ret = cls.wsClient.create_workspace({'workspace': wsName})
cls.wsName = wsName
foft = FakeObjectsForTests(os.environ['SDK_CALLBACK_URL'])
[info1, info2, info3] = foft.create_fake_reads({
'ws_name':
wsName,
'obj_names': ['reads1', 'reads2', 'reads3']
})
cls.read1ref = str(info1[6]) + '/' + str(info1[0]) + '/' + str(
info1[4])
cls.read2ref = str(info2[6]) + '/' + str(info2[0]) + '/' + str(
info2[4])
cls.read3ref = str(info3[6]) + '/' + str(info3[0]) + '/' + str(
info3[4])
cls.fake_sampleset_ref = make_fake_sampleset(
"test_sampleset", [cls.read1ref, cls.read2ref, cls.read3ref],
['wt', 'cond1', 'cond2'], cls.wsName, cls.wsClient)
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('SetAPI'):
cls.cfg[nameval[0]] = nameval[1]
authServiceUrl = cls.cfg.get('auth-service-url',
"https://kbase.us/services/authorization/Sessions/Login")
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({'token': token,
'user_id': user_id,
'provenance': [
{'service': 'SetAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = SetAPI(cls.cfg)
# setup data at the class level for now (so that the code is run
# once for all tests, not before each test case. Not sure how to
# do that outside this function..)
suffix = int(time.time() * 1000)
wsName = "test_SetAPI_" + str(suffix)
ret = cls.wsClient.create_workspace({'workspace': wsName})
# wsName = 'pranjan77:1477441032423'
cls.wsName = wsName
# copy test file to scratch area
fna_filename = "seq.fna"
fna_path = os.path.join(cls.cfg['scratch'], fna_filename)
shutil.copy(os.path.join("data", fna_filename), fna_path)
ru = AssemblyUtil(os.environ['SDK_CALLBACK_URL'])
ws_obj_name = 'MyNewAssembly'
cls.assembly1ref = ru.save_assembly_from_fasta(
{
'file':{'path':fna_path},
'workspace_name':wsName,
'assembly_name':'assembly_obj_1'
})
cls.assembly2ref = ru.save_assembly_from_fasta(
{
'file':{'path':fna_path},
'workspace_name':wsName,
'assembly_name':'assembly_obj_2'
})
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('SetAPI'):
cls.cfg[nameval[0]] = nameval[1]
authServiceUrl = cls.cfg.get(
'auth-service-url',
"https://kbase.us/services/authorization/Sessions/Login")
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({
'token':
token,
'user_id':
user_id,
'provenance': [{
'service': 'SetAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = SetAPI(cls.cfg)
cls.dfu = DataFileUtil(os.environ['SDK_CALLBACK_URL'])
# setup data at the class level for now (so that the code is run
# once for all tests, not before each test case. Not sure how to
# do that outside this function..)
suffix = int(time.time() * 1000)
wsName = "test_SetAPI_" + str(suffix)
ret = cls.wsClient.create_workspace({'workspace': wsName})
cls.wsName = wsName
cls.prepare_data()
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('SetAPI'):
cls.cfg[nameval[0]] = nameval[1]
authServiceUrl = cls.cfg.get(
"auth-service-url",
"https://kbase.us/services/authorization/Sessions/Login")
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({
'token':
token,
'user_id':
user_id,
'provenance': [{
'service': 'SetAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = SetAPI(cls.cfg)
# setup data at the class level for now (so that the code is run
# once for all tests, not before each test case. Not sure how to
# do that outside this function..)
suffix = int(time.time() * 1000)
wsName = "test_SetAPI_" + str(suffix)
cls.wsClient.create_workspace({'workspace': wsName})
cls.wsName = wsName
foft = FakeObjectsForTests(os.environ['SDK_CALLBACK_URL'])
# Make a fake genome
[fake_genome, fake_genome2] = foft.create_fake_genomes({
"ws_name":
wsName,
"obj_names": ["fake_genome", "fake_genome2"]
})
cls.genome_refs = [info_to_ref(fake_genome), info_to_ref(fake_genome2)]
# Make some fake reads objects
fake_reads_list = foft.create_fake_reads({
'ws_name':
wsName,
"obj_names": ["reads1", "reads2", "reads3"]
})
cls.alignment_refs = list()
cls.reads_refs = list()
# Make some fake alignments referencing those reads and genome
dummy_filename = "dummy.txt"
cls.dummy_path = os.path.join(cls.cfg['scratch'], dummy_filename)
shutil.copy(os.path.join("data", dummy_filename), cls.dummy_path)
for idx, reads_info in enumerate(fake_reads_list):
reads_ref = info_to_ref(reads_info)
cls.reads_refs.append(reads_ref)
cls.alignment_refs.append(
make_fake_alignment(os.environ['SDK_CALLBACK_URL'],
cls.dummy_path,
"fake_alignment_{}".format(idx), reads_ref,
cls.genome_refs[0], wsName, cls.wsClient))
# Need a fake annotation to get the expression objects
cls.annotation_ref = make_fake_annotation(
os.environ['SDK_CALLBACK_URL'], cls.dummy_path, "fake_annotation",
wsName, cls.wsClient)
# Now we can phony up some expression objects to build sets out of.
# name, genome_ref, annotation_ref, alignment_ref, ws_name, ws_client
cls.expression_refs = list()
for idx, alignment_ref in enumerate(cls.alignment_refs):
cls.expression_refs.append(
make_fake_expression(os.environ['SDK_CALLBACK_URL'],
cls.dummy_path,
"fake_expression_{}".format(idx),
cls.genome_refs[0], cls.annotation_ref,
alignment_ref, wsName, cls.wsClient))
# Make a fake RNASeq Alignment Set object
# Make a fake RNASeqSampleSet
cls.sampleset_ref = make_fake_sampleset("fake_sampleset", [], [],
wsName, cls.wsClient)
# Finally, make a couple fake RNASeqAlignmentSts objects from those alignments
cls.fake_rnaseq_alignment_set = make_fake_old_alignment_set(
"fake_rnaseq_alignment_set", cls.reads_refs, cls.genome_refs[0],
cls.sampleset_ref, cls.alignment_refs, wsName, cls.wsClient)
# Make a fake RNASeq Expression Set object
cls.fake_rnaseq_expression_set = make_fake_old_expression_set(
"fake_rnaseq_expression_set", cls.genome_refs[0],
cls.sampleset_ref, cls.alignment_refs,
cls.fake_rnaseq_alignment_set, cls.expression_refs, wsName,
cls.wsClient, True)
def get_config():
if not get_config_file():
return None
retconfig = {}
config = ConfigParser()
config.read(get_config_file())
for nameval in config.items(get_service_name() or 'SetAPI'):
retconfig[nameval[0]] = nameval[1]
return retconfig
config = get_config()
from SetAPI.SetAPIImpl import SetAPI # noqa @IgnorePep8
impl_SetAPI = SetAPI(config)
class JSONObjectEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, set):
return list(obj)
if isinstance(obj, frozenset):
return list(obj)
if hasattr(obj, 'toJSONable'):
return obj.toJSONable()
return json.JSONEncoder.default(self, obj)
class JSONRPCServiceCustom(JSONRPCService):
def call(self, ctx, jsondata):