Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Predict the next line after this snippet: <|code_start|> @classmethod
def from_crawler(cls, crawler):
batch=100
if crawler.settings.getbool('BATCH_INSERT'):
batch = crawler.settings.getint('BATCH_INSERT', 100)
ext= cls(batch)
# return the extension object
return ext
def open_spider(self, spider):
log.info("Opening Middleware", spider=spider)
def close_spider(self, spider):
if len(self.items) >= 0:
self.bulkInsert(spider)
log.info("Closing Middleware", spider=spider)
def process_item(self, item, spider):
try:
r={ 'snapshot':item['snapshot']
,'uri':item['uri']
,'timestamp':item['timestamp']
,'status':item['status']
,'exc':item['exc']
,'header':item['header']
,'mime':item['mime']
,'size':item['size']
}
<|code_end|>
using the current file's imports:
import datetime
import gzip
import hashlib
import os
import time
import urllib
import structlog
import sys
import twisted
import scrapy
from urlparse import urlparse
from scrapy.http import Response
from odpw.utils.error_handling import getExceptionString, ErrorHandler
from odpw.core.model import ResourceInfo, ResourceCrawlLog
and any relevant context from other files:
# Path: odpw/utils/error_handling.py
# def getExceptionString(e):
# try:
# if isinstance(e,ckanapi.errors.CKANAPIError):
# try:
# err = literal_eval(e.extra_msg)
# return str(type(e))+":"+str(err[2])
# except Exception:
# return str(type(e))+":"+str(e.extra_msg)
# else:
# if e.message:
# return str(type(e))+":"+str(e.message)
# if e.message:
# return str(type(e))+":"
# except Exception as e:
# log.error("Get Exception string", exctype=type(e), excmsg=e.message,exc_info=True)
# return 601
#
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/core/model.py
# class ResourceInfo(Base):
# __tablename__ = tab_resourcesinfo
#
# uri= Column(String, primary_key=True)
# snapshot= Column(SmallInteger, primary_key=True)
# timestamp= Column(TIMESTAMP)
# status=Column(SmallInteger)
# exc=Column(String)
# header=Column(JSONB)
# mime=Column(String)
# size=Column(BigInteger)
#
# class ResourceCrawlLog(Base):
# __tablename__ = tab_resourcescrawllog
#
# uri= Column(String, primary_key=True)
# snapshot= Column(SmallInteger, primary_key=True)
# timestamp= Column(TIMESTAMP, primary_key=True)
# status=Column(SmallInteger, index=True)
#
# exc=Column(String)
# header=Column(JSONB)
# mime=Column(String)
# size=Column(BigInteger)
# crawltime=Column(BigInteger)
#
# referrer=Column( String)
# disklocation=Column( String)
# digest=Column( String)
# contentchanged=Column( Integer)
# domain=Column( String, index=True)
. Output only the next line. | RI=ResourceInfo(**r) |
Based on the snippet: <|code_start|> return response # return response coz we should
class CrawlLogInserter(object):
def __init__(self, batch):
self.items=[]
self.batch=batch
@classmethod
def from_crawler(cls, crawler):
batch=100
if crawler.settings.getbool('BATCH_INSERT'):
batch = crawler.settings.getint('BATCH_INSERT', 100)
ext= cls(batch)
# return the extension object
return ext
def open_spider(self, spider):
log.info("Opeing Middleware", spider=spider)
def close_spider(self, spider):
if len(self.items) >= 0:
self.bulkInsert(spider)
log.info("Closing Middleware", spider=spider)
def process_item(self, item, spider):
try:
<|code_end|>
, predict the immediate next line with the help of imports:
import datetime
import gzip
import hashlib
import os
import time
import urllib
import structlog
import sys
import twisted
import scrapy
from urlparse import urlparse
from scrapy.http import Response
from odpw.utils.error_handling import getExceptionString, ErrorHandler
from odpw.core.model import ResourceInfo, ResourceCrawlLog
and context (classes, functions, sometimes code) from other files:
# Path: odpw/utils/error_handling.py
# def getExceptionString(e):
# try:
# if isinstance(e,ckanapi.errors.CKANAPIError):
# try:
# err = literal_eval(e.extra_msg)
# return str(type(e))+":"+str(err[2])
# except Exception:
# return str(type(e))+":"+str(e.extra_msg)
# else:
# if e.message:
# return str(type(e))+":"+str(e.message)
# if e.message:
# return str(type(e))+":"
# except Exception as e:
# log.error("Get Exception string", exctype=type(e), excmsg=e.message,exc_info=True)
# return 601
#
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/core/model.py
# class ResourceInfo(Base):
# __tablename__ = tab_resourcesinfo
#
# uri= Column(String, primary_key=True)
# snapshot= Column(SmallInteger, primary_key=True)
# timestamp= Column(TIMESTAMP)
# status=Column(SmallInteger)
# exc=Column(String)
# header=Column(JSONB)
# mime=Column(String)
# size=Column(BigInteger)
#
# class ResourceCrawlLog(Base):
# __tablename__ = tab_resourcescrawllog
#
# uri= Column(String, primary_key=True)
# snapshot= Column(SmallInteger, primary_key=True)
# timestamp= Column(TIMESTAMP, primary_key=True)
# status=Column(SmallInteger, index=True)
#
# exc=Column(String)
# header=Column(JSONB)
# mime=Column(String)
# size=Column(BigInteger)
# crawltime=Column(BigInteger)
#
# referrer=Column( String)
# disklocation=Column( String)
# digest=Column( String)
# contentchanged=Column( Integer)
# domain=Column( String, index=True)
. Output only the next line. | cl=ResourceCrawlLog(**item) |
Predict the next line after this snippet: <|code_start|>
# file upload
post_param = reqparse.RequestParser()
post_param.add_argument('json_file',
type=datastructures.FileStorage,
location='files',
required=True,
help='JSON file')
# url parameter
url_param = reqparse.RequestParser()
url_param.add_argument('url', required=True, help='URL of JSON metadata document')
qual_url = reqparse.RequestParser()
qual_url.add_argument('url', required=True, help='URL of JSON metadata document')
qual_post = reqparse.RequestParser()
qual_post.add_argument('json_file',
type=datastructures.FileStorage,
location='files',
required=True,
help='JSON file')
for q in [qual_post, qual_url]:
q.add_argument('format', required=False, choices=['json-ld', 'json', 'csv'], default='json',
help='Output format')
<|code_end|>
using the current file's imports:
from flask_restplus import reqparse
from werkzeug import datastructures
from odpw.quality.dcat_analysers import dcat_analyser
and any relevant context from other files:
# Path: odpw/quality/dcat_analysers.py
# def dcat_analyser():
# dcat_analyser = {}
# ##################### EXISTS ######################################
# # ACCESS
#
# dcat_analyser['ExAc'] = AnyMetric([AccessUrlDCAT(), DownloadUrlDCAT()], id='ExAc')
# # CONTACT
# dcat_analyser['ExCo'] = AnyMetric([DatasetContactDCAT(), DatasetPublisherDCAT()], id='ExCo')
#
#
# # DISCOVERY
# dcat_analyser['ExDi'] = AverageMetric([DatasetTitleDCAT(), DatasetDescriptionDCAT(), DatasetKeywordsDCAT(), DistributionTitleDCAT(), DistributionDescriptionDCAT()], id='ExDi')
# # PRESERVATION
# dcat_analyser['ExPr'] = AverageMetric([DatasetAccrualPeriodicityDCAT(), DistributionFormatsDCAT(), DistributionMediaTypesDCAT(), DistributionByteSizeDCAT()], id='ExPr')
# # DATE
# dcat_analyser['ExDa'] = AverageMetric([DatasetCreationDCAT(), DatasetModificationDCAT(), DistributionIssuedDCAT(), DistributionModifiedDCAT()], id='ExDa')
#
#
# # LICENSE
# dcat_analyser['ExRi'] = ProvLicenseDCAT()
# # TEMPORAL
# dcat_analyser['ExTe'] = DatasetTemporalDCAT()
# # SPATIAL
# dcat_analyser['ExSp'] = DatasetSpatialDCAT()
#
# ####################### CONFORMANCE ###########################
# # ACCESS
# dcat_analyser['CoAc'] = AnyConformMetric([ConformAccessUrlDCAT(), ConformDownloadUrlDCAT()], id='CoAc')
# # CONTACT
# dcat_analyser['CoCE'] = AnyConformMetric([EmailConformContactPoint(), EmailConformPublisher()], id='CoCE')
# dcat_analyser['CoCU'] = AnyConformMetric([UrlConformContactPoint(), UrlConformPublisher()], id='CoCU')
#
# # DATE
# dcat_analyser['CoDa'] = AverageConformMetric([DateConform(dcat_access.getCreationDate),
# DateConform(dcat_access.getModificationDate),
# DateConform(dcat_access.getDistributionCreationDates),
# DateConform(dcat_access.getDistributionModificationDates)], id='CoDa')
# # LICENSE
# dcat_analyser['CoLi'] = LicenseConform()
# # FORMAT
# dcat_analyser['CoFo'] = IANAFormatDCATAnalyser()
#
# ####################### OPENNESS ###########################
# dcat_analyser['OpFo'] = FormatOpennessDCATAnalyser()
# dcat_analyser['OpMa'] = FormatMachineReadableDCATAnalyser()
# dcat_analyser['OpLi'] = LicenseOpennessDCATAnalyser()
#
# ####################### RETRIEVABILITY ###########################
# #status_code = DatasetStatusCode()
# #dcat_analyser['ReDa'] = status_code
# #dcat_analyser['ReRe'] = DSRetrieveMetric(status_code)
#
# return dcat_analyser
. Output only the next line. | q.add_argument('metric', required=False, action='append', help='Filter by a specific metric', choices=[m.lower() for m in dcat_analyser().keys()]) |
Given the code snippet: <|code_start|> reader = yacp.YACParser(filename=filename)
deli = reader.meta['delimiter']
encoding = reader.meta['encoding']
descriptionLines = reader.descriptionLines
header_line = reader.header_line
f_name = os.path.basename(filename)
cleaned_path = os.path.join(os.path.dirname(filename), '..', 'cleaned')
if not os.path.exists(cleaned_path):
os.mkdir(cleaned_path)
cleaned_content = reader.generate(delimiter=out_delimiter, comments=False)
with codecs.open(os.path.join(cleaned_path, f_name), 'w', out_encoding) as out_f:
out_f.write(cleaned_content.decode(out_encoding))
g = rdflib.Graph()
g.parse(metadata, format="json-ld")
snapshot = getCurrentSnapshot()
activity = adequate_prov(g, snapshot)
if stream_orig:
try:
# add csvw info to orig resource
stream_csv.addMetadata(orig_url, snapshot, g, csvw_activity=activity)
except Exception as e:
ErrorHandler.handleError(log, "GetCSVWMetadata", exception=e, url=orig_url, snapshot=snapshot,
exc_info=True)
<|code_end|>
, generate the next line using the imports in this file:
from StringIO import StringIO
from pyyacp import yacp
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, RDFS
from odpw.quality.dqv_export import DCAT, PROV
from odpw.services import stream_csv
from odpw.utils.error_handling import ErrorHandler
from odpw.utils.utils_snapshot import tofirstdayinisoweek, toLastdayinisoweek, getCurrentSnapshot
import structlog
import codecs
import os
import csv
import rdflib
and context (functions, classes, or occasionally code) from other files:
# Path: odpw/quality/dqv_export.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
#
# PROV = Namespace("http://www.w3.org/ns/prov#")
#
# Path: odpw/services/stream_csv.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# CSVW = Namespace("http://www.w3.org/ns/csvw#")
# PROV = Namespace("http://www.w3.org/ns/prov#")
# P =db.Session.query(Portal).filter(Portal.id==args.portalid).one()
# def addMetadata(url, snapshot, graph, max_lines=100, csvw_activity=None):
# def storeGraph(graph, portalid, directory):
# def csvw_prov(graph, snapshot):
# def streamCSVs(obj):
# def help():
# def name():
# def setupCLI(pa):
# def cli(args,dbm):
#
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/utils/utils_snapshot.py
# def tofirstdayinisoweek(yearweek):
# """
#
# :param yearweek:
# :return: the first day in a week
# """
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
#
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt
#
# def toLastdayinisoweek(yearweek):
#
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt + timedelta(days=6)
#
# def getCurrentSnapshot():
# now = datetime.now()
# y=now.isocalendar()[0]
# w=now.isocalendar()[1]
# sn=str(y)[2:]+'{:02}'.format(w)
#
# return sn
. Output only the next line. | dataset_ref = g.value(predicate=RDF.type, object=DCAT.Dataset) |
Predict the next line after this snippet: <|code_start|>
AD_AGENT = URIRef("https://www.adequate.at/")
AD = Namespace("https://www.adequate.at/ns#")
log =structlog.get_logger()
def adequate_prov(graph, snapshot):
ad_activity = URIRef("http://www.adequate.at/csvprofiler/" + str(snapshot))
<|code_end|>
using the current file's imports:
from StringIO import StringIO
from pyyacp import yacp
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, RDFS
from odpw.quality.dqv_export import DCAT, PROV
from odpw.services import stream_csv
from odpw.utils.error_handling import ErrorHandler
from odpw.utils.utils_snapshot import tofirstdayinisoweek, toLastdayinisoweek, getCurrentSnapshot
import structlog
import codecs
import os
import csv
import rdflib
and any relevant context from other files:
# Path: odpw/quality/dqv_export.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
#
# PROV = Namespace("http://www.w3.org/ns/prov#")
#
# Path: odpw/services/stream_csv.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# CSVW = Namespace("http://www.w3.org/ns/csvw#")
# PROV = Namespace("http://www.w3.org/ns/prov#")
# P =db.Session.query(Portal).filter(Portal.id==args.portalid).one()
# def addMetadata(url, snapshot, graph, max_lines=100, csvw_activity=None):
# def storeGraph(graph, portalid, directory):
# def csvw_prov(graph, snapshot):
# def streamCSVs(obj):
# def help():
# def name():
# def setupCLI(pa):
# def cli(args,dbm):
#
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/utils/utils_snapshot.py
# def tofirstdayinisoweek(yearweek):
# """
#
# :param yearweek:
# :return: the first day in a week
# """
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
#
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt
#
# def toLastdayinisoweek(yearweek):
#
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt + timedelta(days=6)
#
# def getCurrentSnapshot():
# now = datetime.now()
# y=now.isocalendar()[0]
# w=now.isocalendar()[1]
# sn=str(y)[2:]+'{:02}'.format(w)
#
# return sn
. Output only the next line. | graph.add((ad_activity, RDF.type, PROV.Activity)) |
Based on the snippet: <|code_start|>
# TODO read csv files in dir, run pyyacp and and track modifications, read jsonld, add new resource with description and modifications
out_encoding = 'utf-8'
out_delimiter = ','
reader = yacp.YACParser(filename=filename)
deli = reader.meta['delimiter']
encoding = reader.meta['encoding']
descriptionLines = reader.descriptionLines
header_line = reader.header_line
f_name = os.path.basename(filename)
cleaned_path = os.path.join(os.path.dirname(filename), '..', 'cleaned')
if not os.path.exists(cleaned_path):
os.mkdir(cleaned_path)
cleaned_content = reader.generate(delimiter=out_delimiter, comments=False)
with codecs.open(os.path.join(cleaned_path, f_name), 'w', out_encoding) as out_f:
out_f.write(cleaned_content.decode(out_encoding))
g = rdflib.Graph()
g.parse(metadata, format="json-ld")
snapshot = getCurrentSnapshot()
activity = adequate_prov(g, snapshot)
if stream_orig:
try:
# add csvw info to orig resource
<|code_end|>
, predict the immediate next line with the help of imports:
from StringIO import StringIO
from pyyacp import yacp
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, RDFS
from odpw.quality.dqv_export import DCAT, PROV
from odpw.services import stream_csv
from odpw.utils.error_handling import ErrorHandler
from odpw.utils.utils_snapshot import tofirstdayinisoweek, toLastdayinisoweek, getCurrentSnapshot
import structlog
import codecs
import os
import csv
import rdflib
and context (classes, functions, sometimes code) from other files:
# Path: odpw/quality/dqv_export.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
#
# PROV = Namespace("http://www.w3.org/ns/prov#")
#
# Path: odpw/services/stream_csv.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# CSVW = Namespace("http://www.w3.org/ns/csvw#")
# PROV = Namespace("http://www.w3.org/ns/prov#")
# P =db.Session.query(Portal).filter(Portal.id==args.portalid).one()
# def addMetadata(url, snapshot, graph, max_lines=100, csvw_activity=None):
# def storeGraph(graph, portalid, directory):
# def csvw_prov(graph, snapshot):
# def streamCSVs(obj):
# def help():
# def name():
# def setupCLI(pa):
# def cli(args,dbm):
#
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/utils/utils_snapshot.py
# def tofirstdayinisoweek(yearweek):
# """
#
# :param yearweek:
# :return: the first day in a week
# """
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
#
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt
#
# def toLastdayinisoweek(yearweek):
#
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt + timedelta(days=6)
#
# def getCurrentSnapshot():
# now = datetime.now()
# y=now.isocalendar()[0]
# w=now.isocalendar()[1]
# sn=str(y)[2:]+'{:02}'.format(w)
#
# return sn
. Output only the next line. | stream_csv.addMetadata(orig_url, snapshot, g, csvw_activity=activity) |
Based on the snippet: <|code_start|> out_encoding = 'utf-8'
out_delimiter = ','
reader = yacp.YACParser(filename=filename)
deli = reader.meta['delimiter']
encoding = reader.meta['encoding']
descriptionLines = reader.descriptionLines
header_line = reader.header_line
f_name = os.path.basename(filename)
cleaned_path = os.path.join(os.path.dirname(filename), '..', 'cleaned')
if not os.path.exists(cleaned_path):
os.mkdir(cleaned_path)
cleaned_content = reader.generate(delimiter=out_delimiter, comments=False)
with codecs.open(os.path.join(cleaned_path, f_name), 'w', out_encoding) as out_f:
out_f.write(cleaned_content.decode(out_encoding))
g = rdflib.Graph()
g.parse(metadata, format="json-ld")
snapshot = getCurrentSnapshot()
activity = adequate_prov(g, snapshot)
if stream_orig:
try:
# add csvw info to orig resource
stream_csv.addMetadata(orig_url, snapshot, g, csvw_activity=activity)
except Exception as e:
<|code_end|>
, predict the immediate next line with the help of imports:
from StringIO import StringIO
from pyyacp import yacp
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, RDFS
from odpw.quality.dqv_export import DCAT, PROV
from odpw.services import stream_csv
from odpw.utils.error_handling import ErrorHandler
from odpw.utils.utils_snapshot import tofirstdayinisoweek, toLastdayinisoweek, getCurrentSnapshot
import structlog
import codecs
import os
import csv
import rdflib
and context (classes, functions, sometimes code) from other files:
# Path: odpw/quality/dqv_export.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
#
# PROV = Namespace("http://www.w3.org/ns/prov#")
#
# Path: odpw/services/stream_csv.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# CSVW = Namespace("http://www.w3.org/ns/csvw#")
# PROV = Namespace("http://www.w3.org/ns/prov#")
# P =db.Session.query(Portal).filter(Portal.id==args.portalid).one()
# def addMetadata(url, snapshot, graph, max_lines=100, csvw_activity=None):
# def storeGraph(graph, portalid, directory):
# def csvw_prov(graph, snapshot):
# def streamCSVs(obj):
# def help():
# def name():
# def setupCLI(pa):
# def cli(args,dbm):
#
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/utils/utils_snapshot.py
# def tofirstdayinisoweek(yearweek):
# """
#
# :param yearweek:
# :return: the first day in a week
# """
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
#
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt
#
# def toLastdayinisoweek(yearweek):
#
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt + timedelta(days=6)
#
# def getCurrentSnapshot():
# now = datetime.now()
# y=now.isocalendar()[0]
# w=now.isocalendar()[1]
# sn=str(y)[2:]+'{:02}'.format(w)
#
# return sn
. Output only the next line. | ErrorHandler.handleError(log, "GetCSVWMetadata", exception=e, url=orig_url, snapshot=snapshot, |
Using the snippet: <|code_start|>
AD_AGENT = URIRef("https://www.adequate.at/")
AD = Namespace("https://www.adequate.at/ns#")
log =structlog.get_logger()
def adequate_prov(graph, snapshot):
ad_activity = URIRef("http://www.adequate.at/csvprofiler/" + str(snapshot))
graph.add((ad_activity, RDF.type, PROV.Activity))
<|code_end|>
, determine the next line of code. You have imports:
from StringIO import StringIO
from pyyacp import yacp
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, RDFS
from odpw.quality.dqv_export import DCAT, PROV
from odpw.services import stream_csv
from odpw.utils.error_handling import ErrorHandler
from odpw.utils.utils_snapshot import tofirstdayinisoweek, toLastdayinisoweek, getCurrentSnapshot
import structlog
import codecs
import os
import csv
import rdflib
and context (class names, function names, or code) available:
# Path: odpw/quality/dqv_export.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
#
# PROV = Namespace("http://www.w3.org/ns/prov#")
#
# Path: odpw/services/stream_csv.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# CSVW = Namespace("http://www.w3.org/ns/csvw#")
# PROV = Namespace("http://www.w3.org/ns/prov#")
# P =db.Session.query(Portal).filter(Portal.id==args.portalid).one()
# def addMetadata(url, snapshot, graph, max_lines=100, csvw_activity=None):
# def storeGraph(graph, portalid, directory):
# def csvw_prov(graph, snapshot):
# def streamCSVs(obj):
# def help():
# def name():
# def setupCLI(pa):
# def cli(args,dbm):
#
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/utils/utils_snapshot.py
# def tofirstdayinisoweek(yearweek):
# """
#
# :param yearweek:
# :return: the first day in a week
# """
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
#
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt
#
# def toLastdayinisoweek(yearweek):
#
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt + timedelta(days=6)
#
# def getCurrentSnapshot():
# now = datetime.now()
# y=now.isocalendar()[0]
# w=now.isocalendar()[1]
# sn=str(y)[2:]+'{:02}'.format(w)
#
# return sn
. Output only the next line. | graph.add((ad_activity, PROV.startedAtTime, Literal(tofirstdayinisoweek(snapshot)))) |
Using the snippet: <|code_start|>
AD_AGENT = URIRef("https://www.adequate.at/")
AD = Namespace("https://www.adequate.at/ns#")
log =structlog.get_logger()
def adequate_prov(graph, snapshot):
ad_activity = URIRef("http://www.adequate.at/csvprofiler/" + str(snapshot))
graph.add((ad_activity, RDF.type, PROV.Activity))
graph.add((ad_activity, PROV.startedAtTime, Literal(tofirstdayinisoweek(snapshot))))
<|code_end|>
, determine the next line of code. You have imports:
from StringIO import StringIO
from pyyacp import yacp
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, RDFS
from odpw.quality.dqv_export import DCAT, PROV
from odpw.services import stream_csv
from odpw.utils.error_handling import ErrorHandler
from odpw.utils.utils_snapshot import tofirstdayinisoweek, toLastdayinisoweek, getCurrentSnapshot
import structlog
import codecs
import os
import csv
import rdflib
and context (class names, function names, or code) available:
# Path: odpw/quality/dqv_export.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
#
# PROV = Namespace("http://www.w3.org/ns/prov#")
#
# Path: odpw/services/stream_csv.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# CSVW = Namespace("http://www.w3.org/ns/csvw#")
# PROV = Namespace("http://www.w3.org/ns/prov#")
# P =db.Session.query(Portal).filter(Portal.id==args.portalid).one()
# def addMetadata(url, snapshot, graph, max_lines=100, csvw_activity=None):
# def storeGraph(graph, portalid, directory):
# def csvw_prov(graph, snapshot):
# def streamCSVs(obj):
# def help():
# def name():
# def setupCLI(pa):
# def cli(args,dbm):
#
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/utils/utils_snapshot.py
# def tofirstdayinisoweek(yearweek):
# """
#
# :param yearweek:
# :return: the first day in a week
# """
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
#
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt
#
# def toLastdayinisoweek(yearweek):
#
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt + timedelta(days=6)
#
# def getCurrentSnapshot():
# now = datetime.now()
# y=now.isocalendar()[0]
# w=now.isocalendar()[1]
# sn=str(y)[2:]+'{:02}'.format(w)
#
# return sn
. Output only the next line. | graph.add((ad_activity, PROV.endedAtTime, Literal(toLastdayinisoweek(snapshot)))) |
Predict the next line after this snippet: <|code_start|>def csv_clean(filename, git_url, orig_url, metadata, stream_orig=True, max_file_size=10):
# get the file size in MB
filesize = os.path.getsize(filename) >> 20
if filesize > max_file_size:
return
# TODO read csv files in dir, run pyyacp and and track modifications, read jsonld, add new resource with description and modifications
out_encoding = 'utf-8'
out_delimiter = ','
reader = yacp.YACParser(filename=filename)
deli = reader.meta['delimiter']
encoding = reader.meta['encoding']
descriptionLines = reader.descriptionLines
header_line = reader.header_line
f_name = os.path.basename(filename)
cleaned_path = os.path.join(os.path.dirname(filename), '..', 'cleaned')
if not os.path.exists(cleaned_path):
os.mkdir(cleaned_path)
cleaned_content = reader.generate(delimiter=out_delimiter, comments=False)
with codecs.open(os.path.join(cleaned_path, f_name), 'w', out_encoding) as out_f:
out_f.write(cleaned_content.decode(out_encoding))
g = rdflib.Graph()
g.parse(metadata, format="json-ld")
<|code_end|>
using the current file's imports:
from StringIO import StringIO
from pyyacp import yacp
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, RDFS
from odpw.quality.dqv_export import DCAT, PROV
from odpw.services import stream_csv
from odpw.utils.error_handling import ErrorHandler
from odpw.utils.utils_snapshot import tofirstdayinisoweek, toLastdayinisoweek, getCurrentSnapshot
import structlog
import codecs
import os
import csv
import rdflib
and any relevant context from other files:
# Path: odpw/quality/dqv_export.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
#
# PROV = Namespace("http://www.w3.org/ns/prov#")
#
# Path: odpw/services/stream_csv.py
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# CSVW = Namespace("http://www.w3.org/ns/csvw#")
# PROV = Namespace("http://www.w3.org/ns/prov#")
# P =db.Session.query(Portal).filter(Portal.id==args.portalid).one()
# def addMetadata(url, snapshot, graph, max_lines=100, csvw_activity=None):
# def storeGraph(graph, portalid, directory):
# def csvw_prov(graph, snapshot):
# def streamCSVs(obj):
# def help():
# def name():
# def setupCLI(pa):
# def cli(args,dbm):
#
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/utils/utils_snapshot.py
# def tofirstdayinisoweek(yearweek):
# """
#
# :param yearweek:
# :return: the first day in a week
# """
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
#
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt
#
# def toLastdayinisoweek(yearweek):
#
# year=int('20'+str(yearweek)[:2])
# week=int(str(yearweek)[2:])
# d = date(year,1,1)
# d = d - timedelta(d.weekday())
# dlt = timedelta(days = (week)*7)
# return d + dlt + timedelta(days=6)
#
# def getCurrentSnapshot():
# now = datetime.now()
# y=now.isocalendar()[0]
# w=now.isocalendar()[1]
# sn=str(y)[2:]+'{:02}'.format(w)
#
# return sn
. Output only the next line. | snapshot = getCurrentSnapshot() |
Predict the next line after this snippet: <|code_start|>
x = PWQ.OpenFormat
g.add((x, RDF.type, DQV.Metric))
g.add((x, SKOS.prefLabel, Literal("Format Openness")))
g.add((x, SKOS.definition, Literal("Is the file format based on an open standard?")))
g.add((x, RDFS.comment, Literal("Some of the specified formats are not considered open")))
g.add((x, DQV.expectedDataType, XSD.double))
g.add((x, DQV.inDimension, od))
x = PWQ.MachineRead
g.add((x, RDF.type, DQV.Metric))
g.add((x, SKOS.prefLabel, Literal("Format machine readability")))
g.add((x, SKOS.definition, Literal("Can the file format be considered as machine readable?")))
g.add((x, RDFS.comment, Literal("Some of the specified formats are not considered as machine readable")))
g.add((x, DQV.expectedDataType, XSD.double))
g.add((x, DQV.inDimension, od))
x = PWQ.OpenLicense
g.add((x, RDF.type, DQV.Metric))
g.add((x, SKOS.prefLabel, Literal("License Openneness")))
g.add((x, SKOS.definition, Literal("Is the used license conform to the open definition?")))
g.add((x, RDFS.comment, Literal("The specified license is not considered to be open by the opendefinition.org")))
g.add((x, DQV.expectedDataType, XSD.double))
g.add((x, DQV.inDimension, od))
def get_measures_and_dataset(portal, dataset, datasetquality, graph=None, portal_uri=None, fetch_activity=None):
if graph == None:
graph = rdflib.Graph()
# write dcat dataset into graph
<|code_end|>
using the current file's imports:
import hashlib
import rdflib
from odpw.core import dataset_converter
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, SKOS, RDFS, XSD, FOAF
from odpw.utils import utils_snapshot
and any relevant context from other files:
# Path: odpw/core/dataset_converter.py
# DCT = Namespace("http://purl.org/dc/terms/")
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# ADMS = Namespace("http://www.w3.org/ns/adms#")
# VCARD = Namespace("http://www.w3.org/2006/vcard/ns#")
# FOAF = Namespace("http://xmlns.com/foaf/0.1/")
# SCHEMA = Namespace('http://schema.org/')
# TIME = Namespace('http://www.w3.org/2006/time')
# LOCN = Namespace('http://www.w3.org/ns/locn#')
# GSP = Namespace('http://www.opengis.net/ont/geosparql#')
# OWL = Namespace('http://www.w3.org/2002/07/owl#')
# ADEQUATE = Namespace('https://www.adequate.at/ns#')
# GEOJSON_IMT = 'https://www.iana.org/assignments/media-types/application/vnd.geo+json'
# VALID_URL = re.compile(
# r'^(?:http|ftp)s?://' # http:// or https://
# r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' #domain...
# r'localhost|' #localhost...
# r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip
# r'(?::\d+)?' # optional port
# r'(?:/?|[/?]\S+)$', re.IGNORECASE)
# URI = get_compiled_pattern('^%(URI)s$')
# def add_dcat_to_graph(dataset_dict, portal, graph, portal_uri):
# def dict_to_dcat(dataset_dict, portal, graph=None, format='json-ld', portal_uri=None):
# def fix_socrata_graph(g, dataset_dict, portal_url):
# def is_valid_url(references):
# def is_valid_uri(references):
# def graph_from_opendatasoft(g, dataset_dict, portal_url):
# def graph_from_data_gouv_fr(g, dataset_dict, portal_url):
# def __init__(self, graph, portal_base_url):
# def graph_from_ckan(self, dataset_dict):
# def _get_dataset_value(self, dataset_dict, key, default=None):
# def publisher_uri_from_dataset_dict(self, dataset_dict):
# def catalog_uri(self):
# def resource_uri(self, resource_dict, dataset_id):
# def dataset_uri(self, dataset_dict):
# def _add_triples_from_dict(graph, _dict, subject, items,
# list_value=False,
# date_value=False):
# def _add_date_triples_from_dict(graph, _dict, subject, items):
# def _add_list_triples_from_dict(graph, _dict, subject, items):
# def _add_triple_from_dict(graph, _dict, subject, predicate, key,
# fallbacks=None,
# list_value=False,
# date_value=False):
# def _get_dict_value(_dict, key, default=None):
# def _add_list_triple(graph, subject, predicate, value):
# def _add_date_triple(graph, subject, predicate, value):
# class CKANConverter:
#
# Path: odpw/utils/utils_snapshot.py
# def getCurrentSnapshot():
# def getSnapshotfromTime(now, delta=None,before=False):
# def weekIter(startDate, endDate, delta=timedelta(days=7)):
# def tofirstdayinisoweek(yearweek):
# def toLastdayinisoweek(yearweek):
# def getNextWeek(snapshot):
# def getPreviousWeek(snapshot):
# def getWeekString1(yearweek):
# def getWeekString(yearweek):
# def getLastNSnapshots(yearweek,n):
. Output only the next line. | dataset_ref = dataset_converter.add_dcat_to_graph(dataset.data.raw, portal, graph=graph, portal_uri=portal_uri) |
Continue the code snippet: <|code_start|>def get_measures_and_dataset(portal, dataset, datasetquality, graph=None, portal_uri=None, fetch_activity=None):
if graph == None:
graph = rdflib.Graph()
# write dcat dataset into graph
dataset_ref = dataset_converter.add_dcat_to_graph(dataset.data.raw, portal, graph=graph, portal_uri=portal_uri)
if dataset_ref and fetch_activity:
# add prov information to dataset_ref
graph.add((dataset_ref, PROV.wasGeneratedBy, fetch_activity))
graph.add((fetch_activity, PROV.generated, dataset_ref))
graph.add((dataset_ref, RDF.type, PROV.Entity))
if dataset_ref:
dataset_quality_to_dqv(graph, dataset_ref, datasetquality, dataset.snapshot, fetch_activity)
return graph
def _get_measures_for_dataset(portal, dataset, datasetquality):
graph = rdflib.Graph()
# write dcat dataset into graph
dataset_converter.dict_to_dcat(dataset.data.raw, portal, graph=graph)
measures_g = rdflib.Graph()
ds_id = graph.value(predicate=RDF.type, object=DCAT.Dataset)
dataset_quality_to_dqv(measures_g, ds_id, datasetquality, dataset.snapshot)
return measures_g, ds_id
def get_measures_for_dataset(portal, dataset, datasetquality):
measures_g, datasetref = _get_measures_for_dataset(portal, dataset, datasetquality)
return measures_g
def dataset_quality_to_dqv(graph, ds_id, datasetquality, snapshot, fetch_activity=None):
<|code_end|>
. Use current file imports:
import hashlib
import rdflib
from odpw.core import dataset_converter
from rdflib import URIRef, BNode, Literal
from rdflib.namespace import Namespace, RDF, SKOS, RDFS, XSD, FOAF
from odpw.utils import utils_snapshot
and context (classes, functions, or code) from other files:
# Path: odpw/core/dataset_converter.py
# DCT = Namespace("http://purl.org/dc/terms/")
# DCAT = Namespace("http://www.w3.org/ns/dcat#")
# ADMS = Namespace("http://www.w3.org/ns/adms#")
# VCARD = Namespace("http://www.w3.org/2006/vcard/ns#")
# FOAF = Namespace("http://xmlns.com/foaf/0.1/")
# SCHEMA = Namespace('http://schema.org/')
# TIME = Namespace('http://www.w3.org/2006/time')
# LOCN = Namespace('http://www.w3.org/ns/locn#')
# GSP = Namespace('http://www.opengis.net/ont/geosparql#')
# OWL = Namespace('http://www.w3.org/2002/07/owl#')
# ADEQUATE = Namespace('https://www.adequate.at/ns#')
# GEOJSON_IMT = 'https://www.iana.org/assignments/media-types/application/vnd.geo+json'
# VALID_URL = re.compile(
# r'^(?:http|ftp)s?://' # http:// or https://
# r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' #domain...
# r'localhost|' #localhost...
# r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip
# r'(?::\d+)?' # optional port
# r'(?:/?|[/?]\S+)$', re.IGNORECASE)
# URI = get_compiled_pattern('^%(URI)s$')
# def add_dcat_to_graph(dataset_dict, portal, graph, portal_uri):
# def dict_to_dcat(dataset_dict, portal, graph=None, format='json-ld', portal_uri=None):
# def fix_socrata_graph(g, dataset_dict, portal_url):
# def is_valid_url(references):
# def is_valid_uri(references):
# def graph_from_opendatasoft(g, dataset_dict, portal_url):
# def graph_from_data_gouv_fr(g, dataset_dict, portal_url):
# def __init__(self, graph, portal_base_url):
# def graph_from_ckan(self, dataset_dict):
# def _get_dataset_value(self, dataset_dict, key, default=None):
# def publisher_uri_from_dataset_dict(self, dataset_dict):
# def catalog_uri(self):
# def resource_uri(self, resource_dict, dataset_id):
# def dataset_uri(self, dataset_dict):
# def _add_triples_from_dict(graph, _dict, subject, items,
# list_value=False,
# date_value=False):
# def _add_date_triples_from_dict(graph, _dict, subject, items):
# def _add_list_triples_from_dict(graph, _dict, subject, items):
# def _add_triple_from_dict(graph, _dict, subject, predicate, key,
# fallbacks=None,
# list_value=False,
# date_value=False):
# def _get_dict_value(_dict, key, default=None):
# def _add_list_triple(graph, subject, predicate, value):
# def _add_date_triple(graph, subject, predicate, value):
# class CKANConverter:
#
# Path: odpw/utils/utils_snapshot.py
# def getCurrentSnapshot():
# def getSnapshotfromTime(now, delta=None,before=False):
# def weekIter(startDate, endDate, delta=timedelta(days=7)):
# def tofirstdayinisoweek(yearweek):
# def toLastdayinisoweek(yearweek):
# def getNextWeek(snapshot):
# def getPreviousWeek(snapshot):
# def getWeekString1(yearweek):
# def getWeekString(yearweek):
# def getLastNSnapshots(yearweek,n):
. Output only the next line. | sn_time = utils_snapshot.tofirstdayinisoweek(snapshot) |
Using the snippet: <|code_start|>log = structlog.get_logger()
def help():
return "Initalise the DB"
def name():
return 'InitDB'
def setupCLI(pa):
pass
def cli(args,dbm):
log.info('Initalising the DB')
<|code_end|>
, determine the next line of code. You have imports:
from odpw.core.model import Base
import structlog
and context (class names, function names, or code) available:
# Path: odpw/core/model.py
# class Portal(Base):
# class PortalSnapshot(Base):
# class Serializable(object):
# class PortalSnapshotDynamicity(Base,Serializable):
# class PortalSnapshotQuality(Base):
# class Dataset(Base):
# class DatasetData(Base):
# class DatasetQuality(Base):
# class MetaResource(Base):
# class ResourceInfo(Base):
# class ResourceCrawlLog(Base):
# class ResourceHistory(Base):
# class ResourceFreshness(Base):
# class FormatDist(Base):
# def snapshot_count(self):
# def snapshot_count(cls):
# def first_snapshot(self):
# def first_snapshot(cls):
# def last_snapshot(self):
# def last_snapshot(cls):
# def datasetcount(self):
# def datasetcount(cls):
# def resourcecount(self):
# def resourcecount(cls):
# def __repr__(self):
# def fetchtime(self):
# def __repr__(self):
# def to_dict(self):
# def dyratio(self):
# def adddelratio(self):
# def addRatio(self):
# def delRatio(self):
# def updatedRatio(self):
# def staticRatio(self):
# def __repr__(self):
# def __repr__(self):
# def __repr__(self):
# def __repr__(self):
# def info(cls):
# def __repr__(self):
. Output only the next line. | dbm.init(Base) |
Given the following code snippet before the placeholder: <|code_start|>
log = structlog.get_logger()
class DCATDMD(Analyser):
def __init__(self):
super(DCATDMD, self).__init__()
self.analysers = dcat_analyser()
def analyse_Dataset(self, dataset):
if hasattr(dataset,'dmd'):
dataset.dmd['dcat'] = {}
else:
dataset.dmd={'dcat': {}}
for id in self.analysers:
try:
dataset.dmd['dcat'][id] = self.analysers[id].analyse(dataset)
except Exception as e:
<|code_end|>
, predict the next line using imports from the current file:
from odpw.quality.conformance_dcat import *
from odpw.quality.existence_dcat import *
from odpw.utils.error_handling import ErrorHandler
from odpw.quality.open_dcat_format import *
from odpw.quality.open_dcat_license import LicenseOpennessDCATAnalyser
import structlog
and context including class names, function names, and sometimes code from other files:
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/quality/open_dcat_license.py
# class LicenseOpennessDCATAnalyser(ElementCountAnalyser):
# id = 'OpLi'
#
# def __init__(self):
# self.l_mapping = LicensesOpennessMapping()
# super(LicenseOpennessDCATAnalyser, self).__init__()
# self.quality = None
# self.count = 0
# self.total = 0
# self.id = LicenseOpennessDCATAnalyser.id
#
# def analyse_Dataset(self, dataset):
# values = getDistributionLicenseTriples(dataset)
# if len(values) ==0:
# return None
# appr = ''
# for id, label, url in values:
# id, appr = self.l_mapping.map_license(label, id, url)
# self.analyse_generic(appr)
# break
#
# return True if 'approved' in appr else False
. Output only the next line. | ErrorHandler.handleError(log, "DcatAnalyserException", analyser=id, exception=e, exc_info=True) |
Predict the next line for this snippet: <|code_start|> dcat_analyser['ExDa'] = AverageMetric([DatasetCreationDCAT(), DatasetModificationDCAT(), DistributionIssuedDCAT(), DistributionModifiedDCAT()], id='ExDa')
# LICENSE
dcat_analyser['ExRi'] = ProvLicenseDCAT()
# TEMPORAL
dcat_analyser['ExTe'] = DatasetTemporalDCAT()
# SPATIAL
dcat_analyser['ExSp'] = DatasetSpatialDCAT()
####################### CONFORMANCE ###########################
# ACCESS
dcat_analyser['CoAc'] = AnyConformMetric([ConformAccessUrlDCAT(), ConformDownloadUrlDCAT()], id='CoAc')
# CONTACT
dcat_analyser['CoCE'] = AnyConformMetric([EmailConformContactPoint(), EmailConformPublisher()], id='CoCE')
dcat_analyser['CoCU'] = AnyConformMetric([UrlConformContactPoint(), UrlConformPublisher()], id='CoCU')
# DATE
dcat_analyser['CoDa'] = AverageConformMetric([DateConform(dcat_access.getCreationDate),
DateConform(dcat_access.getModificationDate),
DateConform(dcat_access.getDistributionCreationDates),
DateConform(dcat_access.getDistributionModificationDates)], id='CoDa')
# LICENSE
dcat_analyser['CoLi'] = LicenseConform()
# FORMAT
dcat_analyser['CoFo'] = IANAFormatDCATAnalyser()
####################### OPENNESS ###########################
dcat_analyser['OpFo'] = FormatOpennessDCATAnalyser()
dcat_analyser['OpMa'] = FormatMachineReadableDCATAnalyser()
<|code_end|>
with the help of current file imports:
from odpw.quality.conformance_dcat import *
from odpw.quality.existence_dcat import *
from odpw.utils.error_handling import ErrorHandler
from odpw.quality.open_dcat_format import *
from odpw.quality.open_dcat_license import LicenseOpennessDCATAnalyser
import structlog
and context from other files:
# Path: odpw/utils/error_handling.py
# class ErrorHandler():
#
# exceptions=defaultdict(long)
#
# DEBUG=False
#
# @classmethod
# def handleError(cls, log, msg=None, exception=None, debug=False, **kwargs):
# name=type(exception).__name__
# cls.exceptions[name] +=1
#
# if debug:
# print(traceback.format_exc())
#
# log.error(msg, exctype=type(exception), excmsg=exception.message, **kwargs)
#
# @classmethod
# def printStats(cls):
# print '>>>','--*'*10,'EXCEPTIONS','*--'*10
# if len(cls.exceptions)==0:
# print "No exceptions handled"
# else:
# print " Numbers of Exceptions:"
# for exc, count in cls.exceptions.iteritems():
# print " ",exc, count
# print '<<<','--*'*25
#
# Path: odpw/quality/open_dcat_license.py
# class LicenseOpennessDCATAnalyser(ElementCountAnalyser):
# id = 'OpLi'
#
# def __init__(self):
# self.l_mapping = LicensesOpennessMapping()
# super(LicenseOpennessDCATAnalyser, self).__init__()
# self.quality = None
# self.count = 0
# self.total = 0
# self.id = LicenseOpennessDCATAnalyser.id
#
# def analyse_Dataset(self, dataset):
# values = getDistributionLicenseTriples(dataset)
# if len(values) ==0:
# return None
# appr = ''
# for id, label, url in values:
# id, appr = self.l_mapping.map_license(label, id, url)
# self.analyse_generic(appr)
# break
#
# return True if 'approved' in appr else False
, which may contain function names, class names, or code. Output only the next line. | dcat_analyser['OpLi'] = LicenseOpennessDCATAnalyser() |
Given snippet: <|code_start|># Copyright (c) 2010-2012, Lawrence Livermore National Security, LLC
# Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_defines(unittest.TestCase):
def test_combine(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import sys, unittest
from md import defines, logger
and context:
# Path: md/defines.py
# class Defines(dict):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, overridingDefines):
# def expand(self, inString):
# def normalizeKey(key, lower=True):
# def surround(name):
# def setOverrideDefines(defs, overrideGroup):
# def __setToolDefines(defs, overrideGroup):
# def __setFlagDefines(defs, overrideGroup):
# def setJobSlotsDefines(defs, jobSlots):
# def setPrefixDefines(defs, prefix):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
which might include code, classes, or functions. Output only the next line. | def1 = defines.Defines() |
Predict the next line after this snippet: <|code_start|> self.assertEquals(defines.normalizeKey("(foo)"), "(foo)", "normalizeKey() returned wrong value")
self.assertEquals(defines.normalizeKey("$foo)"), "$foo)", "normalizeKey() returned wrong value")
self.assertEquals(defines.normalizeKey("$foo"), "$foo", "normalizeKey() returned wrong value")
def test_surround(self):
self.assertEquals(defines.surround("foo"), "$(foo)", "surround() returned wrong value")
self.assertEquals(defines.surround("Foo"), "$(Foo)", "surround() returned wrong value")
self.assertEquals(defines.surround("fOo"), "$(fOo)", "surround() returned wrong value")
self.assertEquals(defines.surround("foO"), "$(foO)", "surround() returned wrong value")
self.assertEquals(defines.surround("FOo"), "$(FOo)", "surround() returned wrong value")
self.assertEquals(defines.surround("FOO"), "$(FOO)", "surround() returned wrong value")
self.assertEquals(defines.surround("fOO"), "$(fOO)", "surround() returned wrong value")
self.assertEquals(defines.surround("foO"), "$(foO)", "surround() returned wrong value")
self.assertEquals(defines.surround("FOO "), "$(FOO )", "surround() returned wrong value")
self.assertEquals(defines.surround(" FOO "), "$( FOO )", "surround() returned wrong value")
self.assertEquals(defines.surround(" FOO "), "$( FOO )", "surround() returned wrong value")
self.assertEquals(defines.surround(" FOO "), "$( FOO )", "surround() returned wrong value")
self.assertEquals(defines.surround("$(foo)"), "$($(foo))", "surround() returned wrong value")
self.assertEquals(defines.surround("$(foo"), "$($(foo)", "surround() returned wrong value")
self.assertEquals(defines.surround("foo)"), "$(foo))", "surround() returned wrong value")
self.assertEquals(defines.surround("(foo)"), "$((foo))", "surround() returned wrong value")
self.assertEquals(defines.surround("$foo)"), "$($foo))", "surround() returned wrong value")
self.assertEquals(defines.surround("$foo"), "$($foo)", "surround() returned wrong value")
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_defines))
return suite
if __name__ == "__main__":
<|code_end|>
using the current file's imports:
import sys, unittest
from md import defines, logger
and any relevant context from other files:
# Path: md/defines.py
# class Defines(dict):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, overridingDefines):
# def expand(self, inString):
# def normalizeKey(key, lower=True):
# def surround(name):
# def setOverrideDefines(defs, overrideGroup):
# def __setToolDefines(defs, overrideGroup):
# def __setFlagDefines(defs, overrideGroup):
# def setJobSlotsDefines(defs, jobSlots):
# def setPrefixDefines(defs, prefix):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
. Output only the next line. | logger.setLogger("Console") |
Based on the snippet: <|code_start|> self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
self.assertEquals(testOptions.cleanMixDown, True, "cleanMixDown should not have been set")
def test_processCommandline16(self):
testOptions = options.Options()
commandline = "MixDown --import -v"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
self.assertEquals(testOptions.verbose, True, "verbose should have been set")
def test_processCommandline17(self):
testOptions = options.Options()
commandline = "MixDown --import -wtest"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
self.assertEquals(testOptions.downloadDir, "mdDownload", "downloadDir should not have been set")
def test_processCommandline18(self):
testOptions = options.Options()
commandline = "MixDown --import -btest"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
self.assertEquals(testOptions.buildDir, "mdBuild", "buildDir should not have been set")
def test_processCommandline19(self):
testOptions = options.Options()
commandline = "MixDown --import -j9"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
<|code_end|>
, predict the immediate next line with the help of imports:
import os, sys, unittest, mdTestUtilities
from md import defines, options, logger, utilityFunctions
and context (classes, functions, sometimes code) from other files:
# Path: md/defines.py
# class Defines(dict):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, overridingDefines):
# def expand(self, inString):
# def normalizeKey(key, lower=True):
# def surround(name):
# def setOverrideDefines(defs, overrideGroup):
# def __setToolDefines(defs, overrideGroup):
# def __setFlagDefines(defs, overrideGroup):
# def setJobSlotsDefines(defs, jobSlots):
# def setPrefixDefines(defs, prefix):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | self.assertEquals(testOptions.defines[defines.surround(defines.mdJobSlots[0])], "", "cleanMixDown should not have been set") |
Next line prediction: <|code_start|># Copyright (c) 2010-2012, Lawrence Livermore National Security, LLC
# Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_options(unittest.TestCase):
def test_processCommandline01(self):
<|code_end|>
. Use current file imports:
(import os, sys, unittest, mdTestUtilities
from md import defines, options, logger, utilityFunctions)
and context including class names, function names, or small code snippets from other files:
# Path: md/defines.py
# class Defines(dict):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, overridingDefines):
# def expand(self, inString):
# def normalizeKey(key, lower=True):
# def surround(name):
# def setOverrideDefines(defs, overrideGroup):
# def __setToolDefines(defs, overrideGroup):
# def __setFlagDefines(defs, overrideGroup):
# def setJobSlotsDefines(defs, jobSlots):
# def setPrefixDefines(defs, prefix):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | testOptions = options.Options() |
Predict the next line for this snippet: <|code_start|> self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
self.assertEquals(testOptions.verbose, True, "verbose should have been set")
def test_processCommandline17(self):
testOptions = options.Options()
commandline = "MixDown --import -wtest"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
self.assertEquals(testOptions.downloadDir, "mdDownload", "downloadDir should not have been set")
def test_processCommandline18(self):
testOptions = options.Options()
commandline = "MixDown --import -btest"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
self.assertEquals(testOptions.buildDir, "mdBuild", "buildDir should not have been set")
def test_processCommandline19(self):
testOptions = options.Options()
commandline = "MixDown --import -j9"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
self.assertEquals(testOptions.defines[defines.surround(defines.mdJobSlots[0])], "", "cleanMixDown should not have been set")
def test_processCommandline20(self):
testOptions = options.Options()
commandline = "MixDown --import -lconsole"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
self.assertEquals(testOptions.targetsToImport, [], "targetsToImport should have not been set")
<|code_end|>
with the help of current file imports:
import os, sys, unittest, mdTestUtilities
from md import defines, options, logger, utilityFunctions
and context from other files:
# Path: md/defines.py
# class Defines(dict):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, overridingDefines):
# def expand(self, inString):
# def normalizeKey(key, lower=True):
# def surround(name):
# def setOverrideDefines(defs, overrideGroup):
# def __setToolDefines(defs, overrideGroup):
# def __setFlagDefines(defs, overrideGroup):
# def setJobSlotsDefines(defs, jobSlots):
# def setPrefixDefines(defs, prefix):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may contain function names, class names, or code. Output only the next line. | self.assertEquals(testOptions.logger, "file", "logger should not have been set") |
Here is a snippet: <|code_start|> testOptions = options.Options()
commandline = "MixDown --import"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
def test_processCommandline04(self):
testOptions = options.Options()
commandline = "MixDown"
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), False, "Command-line should not have processed correctly")
def test_processCommandline05(self):
try:
tempDir = mdTestUtilities.makeTempDir()
url = "http://www.webdav.org/neon/neon-0.29.5.tar.gz"
tarDir, tarFile = mdTestUtilities.createTarFile(tempDir)
tarPath = os.path.join(tempDir, tarFile)
directory = os.path.join(tempDir, "c")
os.mkdir(directory)
testOptions = options.Options()
commandline = "MixDown --import " + url + " " + tarPath + " " + directory
self.assertEquals(testOptions.processCommandline(commandline.split(" ")), True, "Command-line should have processed correctly")
self.assertEquals(len(testOptions.targetsToImport), 3, "Number of targets to import was wrong")
self.assertEquals(testOptions.targetsToImport[0].name, "neon", "Target had wrong name")
self.assertEquals(testOptions.targetsToImport[0].path, url, "Target had wrong name")
self.assertEquals(testOptions.targetsToImport[1].name, "test", "Target had wrong name")
self.assertEquals(testOptions.targetsToImport[1].path, tarPath, "Target had wrong name")
self.assertEquals(testOptions.targetsToImport[2].name, "c", "Target had wrong name")
self.assertEquals(testOptions.targetsToImport[2].path, directory, "Target had wrong name")
self.assertEquals(testOptions.validate(), True, "Command-line options should have validated")
finally:
<|code_end|>
. Write the next line using the current file imports:
import os, sys, unittest, mdTestUtilities
from md import defines, options, logger, utilityFunctions
and context from other files:
# Path: md/defines.py
# class Defines(dict):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, overridingDefines):
# def expand(self, inString):
# def normalizeKey(key, lower=True):
# def surround(name):
# def setOverrideDefines(defs, overrideGroup):
# def __setToolDefines(defs, overrideGroup):
# def __setFlagDefines(defs, overrideGroup):
# def setJobSlotsDefines(defs, jobSlots):
# def setPrefixDefines(defs, prefix):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may include functions, classes, or code. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Here is a snippet: <|code_start|> self.assertEquals(filename, "pymol-v1.4.1.tar.gz", "Wrong filename '" + filename + "' returned from function")
def test_URLToFileName08(self):
url = "http://www.sourceforge.net/projects/pymol/files/pymol/1.4.1/pymol-v1.4.1.tgz/download"
filename = utilityFunctions.URLToFilename(url)
self.assertEquals(filename, "pymol-v1.4.1.tgz", "Wrong filename '" + filename + "' returned from function")
def test_URLToFileName09(self):
#Check for false positive
url = "http://www.sourceforge.net/projects/pymol/files/pymol/1.4.1/pymol-v1.4.1/download"
filename = utilityFunctions.URLToFilename(url)
self.assertEquals(filename, "download", "Wrong filename '" + filename + "' returned from function")
def test_URLToFileName10(self):
#Check for false positive
url = "http://www.oioioi.net/projects/pymol/files/pymol/1.4.1/pymol-v1.4.1.tar.bz2/download"
filename = utilityFunctions.URLToFilename(url)
self.assertEquals(filename, "download", "Wrong filename '" + filename + "' returned from function")
def test_URLToFileName11(self):
url = "http://www.sf.net/projects/pymol/files/pymol/1.4.1/pymol-v1.4.1.tar.bz2"
filename = utilityFunctions.URLToFilename(url)
self.assertEquals(filename, "pymol-v1.4.1.tar.bz2", "Wrong filename '" + filename + "' returned from function")
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_utilityFunctions))
return suite
if __name__ == "__main__":
<|code_end|>
. Write the next line using the current file imports:
import os, sys, unittest, mdTestUtilities
from md import logger, utilityFunctions
and context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may include functions, classes, or code. Output only the next line. | logger.setLogger("Console") |
Predict the next line after this snippet: <|code_start|># Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_utilityFunctions(unittest.TestCase):
def test_pathExists1(self):
try:
tempDir = mdTestUtilities.makeTempDir()
tempFile = mdTestUtilities.makeTempFile(tempDir)
<|code_end|>
using the current file's imports:
import os, sys, unittest, mdTestUtilities
from md import logger, utilityFunctions
and any relevant context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | self.assertEquals(utilityFunctions.pathExists(tempFile), True, "pathExists should have returned True") |
Next line prediction: <|code_start|># Copyright (c) 2010-2012, Lawrence Livermore National Security, LLC
# Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_cmake(unittest.TestCase):
def test_isCMakeProject1(self):
<|code_end|>
. Use current file imports:
(import os, sys, unittest, mdTestUtilities
from md import cmake, logger, utilityFunctions)
and context including class names, function names, or small code snippets from other files:
# Path: md/cmake.py
# def isCMakeProject(path):
# def getInstallDir(command):
# def _findAllCMakeFiles(path, listToBeFilled):
# def getDependencies(path, name="", verbose=True):
# def isCmakeInstalled():
# def getPreconfigureCommand():
# def getConfigureCommand():
# def getBuildCommand():
# def getInstallCommand():
# def getCleanCommand():
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | self.assertTrue(cmake.isCMakeProject("cases/cmake/hello/hello1"), "Failed to detect CMake project.") |
Continue the code snippet: <|code_start|> 'opengl', 'opengles', 'opengles2', 'pkgconfig', 'poco', 'tbb',
'x11', 'xaw', 'zlib', 'zzip'],
"Wrong dependencies found in CMake project")
finally:
utilityFunctions.removeDir(tempDir)
def test_getDependenciesFalse1(self):
#False positive
try:
tempDir = mdTestUtilities.copyDirToTempDir("cases/simpleGraphAutoTools/TestCaseA")
dependencies = cmake.getDependencies(tempDir, verbose=False)
self.assertEquals(dependencies, None, "Wrong dependencies found in CMake project")
finally:
utilityFunctions.removeDir(tempDir)
def test_getDependenciesFalse2(self):
#False positive
try:
tempDir = mdTestUtilities.copyDirToTempDir("cases/simpleGraphAutoTools/TestCaseB")
dependencies = cmake.getDependencies(tempDir, verbose=False)
self.assertEquals(dependencies, None, "Wrong dependencies found in CMake project")
finally:
utilityFunctions.removeDir(tempDir)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_cmake))
return suite
if __name__ == "__main__":
<|code_end|>
. Use current file imports:
import os, sys, unittest, mdTestUtilities
from md import cmake, logger, utilityFunctions
and context (classes, functions, or code) from other files:
# Path: md/cmake.py
# def isCMakeProject(path):
# def getInstallDir(command):
# def _findAllCMakeFiles(path, listToBeFilled):
# def getDependencies(path, name="", verbose=True):
# def isCmakeInstalled():
# def getPreconfigureCommand():
# def getConfigureCommand():
# def getBuildCommand():
# def getInstallCommand():
# def getCleanCommand():
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | logger.setLogger("Console") |
Here is a snippet: <|code_start|># under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_cmake(unittest.TestCase):
def test_isCMakeProject1(self):
self.assertTrue(cmake.isCMakeProject("cases/cmake/hello/hello1"), "Failed to detect CMake project.")
self.assertTrue(cmake.isCMakeProject("cases/cmake/hello/main"), "Failed to detect CMake project.")
self.assertFalse(cmake.isCMakeProject("cases/simpleGraphAutoTools/TestCaseA"), "False positive when given CMake project.")
def test_isCMakeProject2(self):
try:
tempDir = mdTestUtilities.makeTempDir()
tempFile = os.path.join(tempDir, "CMakeLists.txt")
mdTestUtilities.createBlankFile(tempFile)
self.assertTrue(cmake.isCMakeProject(tempDir), "Failed to detect CMake project.")
finally:
<|code_end|>
. Write the next line using the current file imports:
import os, sys, unittest, mdTestUtilities
from md import cmake, logger, utilityFunctions
and context from other files:
# Path: md/cmake.py
# def isCMakeProject(path):
# def getInstallDir(command):
# def _findAllCMakeFiles(path, listToBeFilled):
# def getDependencies(path, name="", verbose=True):
# def isCmakeInstalled():
# def getPreconfigureCommand():
# def getConfigureCommand():
# def getBuildCommand():
# def getInstallCommand():
# def getCleanCommand():
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may include functions, classes, or code. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Based on the snippet: <|code_start|>
if not ".." in sys.path:
sys.path.append("..")
def createPythonCallInfo(currentPath="", outputPath="", downloadDir=""):
pci = python.PythonCallInfo()
pci.success = False
pci.currentPath = currentPath
pci.outputPath = outputPath
pci.downloadDir = downloadDir
pci.logger = logger.Logger()
return pci
class Test_steps(unittest.TestCase):
def _test_fetchCvs(self):
if not mdCvs.isCvsInstalled():
self.fail("Cvs is not installed on your system. All Cvs tests will fail.")
try:
tempDir = mdTestUtilities.makeTempDir()
repoPath = mdTestUtilities.createCvsRepository(tempDir)
pci = createPythonCallInfo(repoPath, os.path.join(tempDir, "output"), os.path.join(tempDir, "download"))
pci = steps.fetch(pci)
testFilePath = os.path.join(pci.outputPath, mdTestUtilities.testFileName)
self.assertEqual(pci.success, True, "Cvs repository failed to fetch.")
self.assertEqual(os.path.exists(testFilePath), True, "'" + mdTestUtilities.testFileName + "' did not exist after fetching a Cvs repository.")
finally:
utilityFunctions.removeDir(tempDir)
def test_fetchGit(self):
<|code_end|>
, predict the immediate next line with the help of imports:
import os, sys, tarfile, unittest, zipfile, mdTestUtilities
from md import git, hg, logger, python, steps, svn, utilityFunctions
and context (classes, functions, sometimes code) from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/python.py
# def parsePythonCommand(command):
# def callPythonCommand(namespace, function, target, options, project):
# def __init__(self):
# class PythonCallInfo(object):
#
# Path: md/steps.py
# def fetch(pythonCallInfo):
# def unpack(pythonCallInfo):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | if not git.isGitInstalled(): |
Given the code snippet: <|code_start|>class Test_steps(unittest.TestCase):
def _test_fetchCvs(self):
if not mdCvs.isCvsInstalled():
self.fail("Cvs is not installed on your system. All Cvs tests will fail.")
try:
tempDir = mdTestUtilities.makeTempDir()
repoPath = mdTestUtilities.createCvsRepository(tempDir)
pci = createPythonCallInfo(repoPath, os.path.join(tempDir, "output"), os.path.join(tempDir, "download"))
pci = steps.fetch(pci)
testFilePath = os.path.join(pci.outputPath, mdTestUtilities.testFileName)
self.assertEqual(pci.success, True, "Cvs repository failed to fetch.")
self.assertEqual(os.path.exists(testFilePath), True, "'" + mdTestUtilities.testFileName + "' did not exist after fetching a Cvs repository.")
finally:
utilityFunctions.removeDir(tempDir)
def test_fetchGit(self):
if not git.isGitInstalled():
self.fail("Git is not installed on your system. All Git tests will fail.")
try:
tempDir = mdTestUtilities.makeTempDir()
repoPath = mdTestUtilities.createGitRepository(tempDir)
pci = createPythonCallInfo(repoPath, os.path.join(tempDir, "output"), os.path.join(tempDir, "download"))
pci = steps.fetch(pci)
testFilePath = os.path.join(pci.outputPath, mdTestUtilities.testFileName)
self.assertEqual(pci.success, True, "Hg repository failed to fetch.")
self.assertEqual(os.path.exists(testFilePath), True, "'" + mdTestUtilities.testFileName + "' did not exist after fetching a Git repository.")
finally:
utilityFunctions.removeDir(tempDir)
def test_fetchHg(self):
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, tarfile, unittest, zipfile, mdTestUtilities
from md import git, hg, logger, python, steps, svn, utilityFunctions
and context (functions, classes, or occasionally code) from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/python.py
# def parsePythonCommand(command):
# def callPythonCommand(namespace, function, target, options, project):
# def __init__(self):
# class PythonCallInfo(object):
#
# Path: md/steps.py
# def fetch(pythonCallInfo):
# def unpack(pythonCallInfo):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | if not hg.isHgInstalled(): |
Here is a snippet: <|code_start|># All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
def createPythonCallInfo(currentPath="", outputPath="", downloadDir=""):
pci = python.PythonCallInfo()
pci.success = False
pci.currentPath = currentPath
pci.outputPath = outputPath
pci.downloadDir = downloadDir
<|code_end|>
. Write the next line using the current file imports:
import os, sys, tarfile, unittest, zipfile, mdTestUtilities
from md import git, hg, logger, python, steps, svn, utilityFunctions
and context from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/python.py
# def parsePythonCommand(command):
# def callPythonCommand(namespace, function, target, options, project):
# def __init__(self):
# class PythonCallInfo(object):
#
# Path: md/steps.py
# def fetch(pythonCallInfo):
# def unpack(pythonCallInfo):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may include functions, classes, or code. Output only the next line. | pci.logger = logger.Logger() |
Here is a snippet: <|code_start|># Copyright (c) 2010-2012, Lawrence Livermore National Security, LLC
# Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
def createPythonCallInfo(currentPath="", outputPath="", downloadDir=""):
<|code_end|>
. Write the next line using the current file imports:
import os, sys, tarfile, unittest, zipfile, mdTestUtilities
from md import git, hg, logger, python, steps, svn, utilityFunctions
and context from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/python.py
# def parsePythonCommand(command):
# def callPythonCommand(namespace, function, target, options, project):
# def __init__(self):
# class PythonCallInfo(object):
#
# Path: md/steps.py
# def fetch(pythonCallInfo):
# def unpack(pythonCallInfo):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may include functions, classes, or code. Output only the next line. | pci = python.PythonCallInfo() |
Predict the next line after this snippet: <|code_start|># WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
def createPythonCallInfo(currentPath="", outputPath="", downloadDir=""):
pci = python.PythonCallInfo()
pci.success = False
pci.currentPath = currentPath
pci.outputPath = outputPath
pci.downloadDir = downloadDir
pci.logger = logger.Logger()
return pci
class Test_steps(unittest.TestCase):
def _test_fetchCvs(self):
if not mdCvs.isCvsInstalled():
self.fail("Cvs is not installed on your system. All Cvs tests will fail.")
try:
tempDir = mdTestUtilities.makeTempDir()
repoPath = mdTestUtilities.createCvsRepository(tempDir)
pci = createPythonCallInfo(repoPath, os.path.join(tempDir, "output"), os.path.join(tempDir, "download"))
<|code_end|>
using the current file's imports:
import os, sys, tarfile, unittest, zipfile, mdTestUtilities
from md import git, hg, logger, python, steps, svn, utilityFunctions
and any relevant context from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/python.py
# def parsePythonCommand(command):
# def callPythonCommand(namespace, function, target, options, project):
# def __init__(self):
# class PythonCallInfo(object):
#
# Path: md/steps.py
# def fetch(pythonCallInfo):
# def unpack(pythonCallInfo):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | pci = steps.fetch(pci) |
Given the code snippet: <|code_start|>
def test_fetchGit(self):
if not git.isGitInstalled():
self.fail("Git is not installed on your system. All Git tests will fail.")
try:
tempDir = mdTestUtilities.makeTempDir()
repoPath = mdTestUtilities.createGitRepository(tempDir)
pci = createPythonCallInfo(repoPath, os.path.join(tempDir, "output"), os.path.join(tempDir, "download"))
pci = steps.fetch(pci)
testFilePath = os.path.join(pci.outputPath, mdTestUtilities.testFileName)
self.assertEqual(pci.success, True, "Hg repository failed to fetch.")
self.assertEqual(os.path.exists(testFilePath), True, "'" + mdTestUtilities.testFileName + "' did not exist after fetching a Git repository.")
finally:
utilityFunctions.removeDir(tempDir)
def test_fetchHg(self):
if not hg.isHgInstalled():
self.fail("Hg is not installed on your system. All Hg tests will fail.")
try:
tempDir = mdTestUtilities.makeTempDir()
repoPath = mdTestUtilities.createHgRepository(tempDir)
pci = createPythonCallInfo(repoPath, os.path.join(tempDir, "output"), os.path.join(tempDir, "download"))
pci = steps.fetch(pci)
testFilePath = os.path.join(pci.outputPath, mdTestUtilities.testFileName)
self.assertEqual(pci.success, True, "Hg repository failed to fetch.")
self.assertEqual(os.path.exists(testFilePath), True, "'" + mdTestUtilities.testFileName + "' did not exist after fetching a Hg repository.")
finally:
utilityFunctions.removeDir(tempDir)
def test_fetchSvn(self):
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, tarfile, unittest, zipfile, mdTestUtilities
from md import git, hg, logger, python, steps, svn, utilityFunctions
and context (functions, classes, or occasionally code) from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/python.py
# def parsePythonCommand(command):
# def callPythonCommand(namespace, function, target, options, project):
# def __init__(self):
# class PythonCallInfo(object):
#
# Path: md/steps.py
# def fetch(pythonCallInfo):
# def unpack(pythonCallInfo):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | if not svn.isSvnInstalled(): |
Next line prediction: <|code_start|># along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
def createPythonCallInfo(currentPath="", outputPath="", downloadDir=""):
pci = python.PythonCallInfo()
pci.success = False
pci.currentPath = currentPath
pci.outputPath = outputPath
pci.downloadDir = downloadDir
pci.logger = logger.Logger()
return pci
class Test_steps(unittest.TestCase):
def _test_fetchCvs(self):
if not mdCvs.isCvsInstalled():
self.fail("Cvs is not installed on your system. All Cvs tests will fail.")
try:
tempDir = mdTestUtilities.makeTempDir()
repoPath = mdTestUtilities.createCvsRepository(tempDir)
pci = createPythonCallInfo(repoPath, os.path.join(tempDir, "output"), os.path.join(tempDir, "download"))
pci = steps.fetch(pci)
testFilePath = os.path.join(pci.outputPath, mdTestUtilities.testFileName)
self.assertEqual(pci.success, True, "Cvs repository failed to fetch.")
self.assertEqual(os.path.exists(testFilePath), True, "'" + mdTestUtilities.testFileName + "' did not exist after fetching a Cvs repository.")
finally:
<|code_end|>
. Use current file imports:
(import os, sys, tarfile, unittest, zipfile, mdTestUtilities
from md import git, hg, logger, python, steps, svn, utilityFunctions)
and context including class names, function names, or small code snippets from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/python.py
# def parsePythonCommand(command):
# def callPythonCommand(namespace, function, target, options, project):
# def __init__(self):
# class PythonCallInfo(object):
#
# Path: md/steps.py
# def fetch(pythonCallInfo):
# def unpack(pythonCallInfo):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Given the code snippet: <|code_start|> tempDir = mdTestUtilities.makeTempDir()
tempRepo = mdTestUtilities.createSvnRepository(tempDir)
returnValue = svn.isSvnRepo(tempRepo)
self.assertEqual(returnValue, True, "svn.isSvnRepo(" + tempRepo + ") should have returned true.")
finally:
utilityFunctions.removeDir(tempDir)
#Test if wrong path returns false
falsePath = "http://foo/wrong/path"
returnValue = svn.isSvnRepo(falsePath)
self.assertEqual(returnValue, False, "svn.isSvnRepo(" + falsePath + ") should have returned false.")
def test_svnCheckout(self):
if not svn.isSvnInstalled():
self.fail("Svn is not installed on your system. All Svn tests will fail.")
try:
tempDir = mdTestUtilities.makeTempDir()
tempRepo = mdTestUtilities.createSvnRepository(tempDir)
checkedOutRepo = os.path.join(tempDir, "checkedOut")
svn.svnCheckout(tempRepo, checkedOutRepo)
returnValue = os.path.exists(os.path.join(checkedOutRepo, mdTestUtilities.testFileName))
self.assertEqual(returnValue, True, "'" + mdTestUtilities.testFileName + "' did not exist after svn.svnCheckout(" + tempRepo + ") was called.")
finally:
utilityFunctions.removeDir(tempDir)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_svn))
return suite
if __name__ == "__main__":
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, unittest, mdTestUtilities
from md import logger, svn, utilityFunctions
and context (functions, classes, or occasionally code) from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | logger.setLogger("Console") |
Predict the next line for this snippet: <|code_start|># Copyright (c) 2010-2012, Lawrence Livermore National Security, LLC
# Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_svn(unittest.TestCase):
def test_isSvnInstalled(self):
<|code_end|>
with the help of current file imports:
import os, sys, unittest, mdTestUtilities
from md import logger, svn, utilityFunctions
and context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may contain function names, class names, or code. Output only the next line. | returnValue = svn.isSvnInstalled() |
Here is a snippet: <|code_start|>#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_svn(unittest.TestCase):
def test_isSvnInstalled(self):
returnValue = svn.isSvnInstalled()
self.assertEqual(returnValue, True, "Svn is not installed on your system. All Svn tests will fail.")
def test_isSvnRepo(self):
if not svn.isSvnInstalled():
self.fail("Svn is not installed on your system. All Svn tests will fail.")
#Create repository and test if is svn repo
try:
tempDir = mdTestUtilities.makeTempDir()
tempRepo = mdTestUtilities.createSvnRepository(tempDir)
returnValue = svn.isSvnRepo(tempRepo)
self.assertEqual(returnValue, True, "svn.isSvnRepo(" + tempRepo + ") should have returned true.")
finally:
<|code_end|>
. Write the next line using the current file imports:
import os, sys, unittest, mdTestUtilities
from md import logger, svn, utilityFunctions
and context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/svn.py
# def isSvnInstalled():
# def isSvnRepo(location):
# def svnCheckout(repoLocation, outPath, outfd=None):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may include functions, classes, or code. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Given the following code snippet before the placeholder: <|code_start|># Copyright (c) 2010-2012, Lawrence Livermore National Security, LLC
# Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_cvs(unittest.TestCase):
def test_isCvsInstalled(self):
<|code_end|>
, predict the next line using imports from the current file:
import os, sys, unittest, mdTestUtilities
from md import cvs, logger, utilityFunctions
and context including class names, function names, and sometimes code from other files:
# Path: md/cvs.py
# def isCvsInstalled():
# def isCvsRepo(location):
# def cvsCheckout(repoLocation, project, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | returnValue = cvs.isCvsInstalled() |
Continue the code snippet: <|code_start|> try:
returnValue = cvs.isCvsRepo(tempRepo)
self.assertEqual(returnValue, True, "cvs.isCvsRepo(" + tempRepo + ") should have returned true.")
finally:
utilityFunctions.removeDir(tempDir)
#Test if wrong path returns false
falsePath = "http://foo/wrong/path"
returnValue = cvs.isCvsRepo(falsePath)
self.assertEqual(returnValue, False, "cvs.isCvsRepo(" + falsePath + ") should have returned false.")
def test_cvsCheckout(self):
if not cvs.isCvsInstalled():
self.fail("Cvs is not installed on your system. All Cvs tests will fail.")
tempDir = mdTestUtilities.makeTempDir()
tempRepo = mdTestUtilities.createCvsRepository(tempDir)
checkedOutRepo = os.path.join(tempDir, "checkedOut")
try:
cvs.cvsCheckout(tempRepo, checkedOutRepo)
returnValue = os.path.exists(os.path.join(checkedOutRepo, mdTestUtilities.testFileName))
self.assertEqual(returnValue, True, "'" + mdTestUtilities.testFileName + "' did not exist after cvs.cvsCheckout(" + tempRepo + ") was called.")
finally:
utilityFunctions.removeDir(tempDir)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_cvs))
return suite
if __name__ == "__main__":
<|code_end|>
. Use current file imports:
import os, sys, unittest, mdTestUtilities
from md import cvs, logger, utilityFunctions
and context (classes, functions, or code) from other files:
# Path: md/cvs.py
# def isCvsInstalled():
# def isCvsRepo(location):
# def cvsCheckout(repoLocation, project, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | logger.setLogger("Console") |
Using the snippet: <|code_start|>#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_cvs(unittest.TestCase):
def test_isCvsInstalled(self):
returnValue = cvs.isCvsInstalled()
self.assertEqual(returnValue, True, "Cvs is not installed on your system. All Cvs tests will fail.")
def test_isCvsRepo(self):
if not cvs.isCvsInstalled():
self.fail("Cvs is not installed on your system. All Cvs tests will fail.")
#Create repository and test if is cvs repo
tempDir = mdTestUtilities.makeTempDir()
tempRepo = mdTestUtilities.createCvsRepository(tempDir)
try:
returnValue = cvs.isCvsRepo(tempRepo)
self.assertEqual(returnValue, True, "cvs.isCvsRepo(" + tempRepo + ") should have returned true.")
finally:
<|code_end|>
, determine the next line of code. You have imports:
import os, sys, unittest, mdTestUtilities
from md import cvs, logger, utilityFunctions
and context (class names, function names, or code) available:
# Path: md/cvs.py
# def isCvsInstalled():
# def isCvsRepo(location):
# def cvsCheckout(repoLocation, project, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Predict the next line for this snippet: <|code_start|> self.assertEquals(groups[0].parallel, "*", "readGroups() has wrong information")
self.assertEquals(fullCount(groups[0]), 3, "readGroups() has wrong information")
self.assertEquals(groups[0]["ccompiler"], "gcc", "readGroups() has wrong information")
self.assertEquals(groups[0]["cflags"], "-O0", "readGroups() has wrong information")
self.assertEquals(groups[0].defines["testvariable"], "foo", "readGroups() has wrong information")
finally:
utilityFunctions.removeDir(tempDir)
def test_readGroups13(self):
fileContents = textwrap.dedent("""
wrongParens, *, * (
ccompiler = gcc
cflags = -O0
testVariable = foo
)
""")
try:
tempDir = mdTestUtilities.makeTempDir()
filePath = mdTestUtilities.makeTempFile(tempDir, fileContents)
groups = overrides.readGroups(filePath)
self.assertEquals(groups, None, "readGroups() should have failed to read groups")
finally:
utilityFunctions.removeDir(tempDir)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_overrides))
return suite
if __name__ == "__main__":
<|code_end|>
with the help of current file imports:
import os, sys, textwrap, unittest, mdTestUtilities
from md import logger, overrides, options, utilityFunctions
and context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/overrides.py
# class OverrideGroup(dict):
# def __init__(self):
# def __str__(self):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, child):
# def readGroups(filename):
# def selectGroups(groups, overrideGroupNames):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may contain function names, class names, or code. Output only the next line. | logger.setLogger("Console") |
Predict the next line after this snippet: <|code_start|># LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
def fullCount(overrideGroup):
return len(overrideGroup) + len(overrideGroup.defines)
class Test_overrides(unittest.TestCase):
def test_len01(self):
<|code_end|>
using the current file's imports:
import os, sys, textwrap, unittest, mdTestUtilities
from md import logger, overrides, options, utilityFunctions
and any relevant context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/overrides.py
# class OverrideGroup(dict):
# def __init__(self):
# def __str__(self):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, child):
# def readGroups(filename):
# def selectGroups(groups, overrideGroupNames):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | group = overrides.OverrideGroup() |
Based on the snippet: <|code_start|>
def test_hasOverrides4(self):
group = overrides.OverrideGroup()
group.defines["test"] = "value"
self.assertEquals("test" in group, False, "hasOverride did not returned correct value")
def test_combine1(self):
group1 = overrides.OverrideGroup()
group1["test"] = "value1"
group1["group1Only"] = "group1OnlyValue"
group2 = overrides.OverrideGroup()
group2["test"] = "value2"
group2["group2Only"] = "group2OnlyValue"
group1.combine(group2)
self.assertEquals("test" in group1, True, "After combine() hasOverride() did not returned correct value")
self.assertEquals(group1["test"], "value2", "After combine() getOverride() did not returned correct value")
self.assertEquals("group1Only" in group1, True, "After combine() hasOverride() did not returned correct value")
self.assertEquals(group1["group1Only"], "group1OnlyValue", "After combine() getOverride() did not returned correct value")
self.assertEquals("group2Only" in group1, True, "After combine() hasOverride() did not returned correct value")
self.assertEquals(group1["group2Only"], "group2OnlyValue", "After combine() getOverride() did not returned correct value")
self.assertEquals("test" in group2, True, "After combine() hasOverride() did not returned correct value")
self.assertEquals(group2["test"], "value2", "After combine() getOverride() did not returned correct value")
self.assertEquals("group2Only" in group2, True, "After combine() hasOverride() did not returned correct value")
self.assertEquals(group2["group2Only"], "group2OnlyValue", "After combine() getOverride() did not returned correct value")
self.assertEquals("group1Only" in group2, False, "After combine() hasOverride() did not returned correct value")
self.assertEquals(group2["group1Only"], None, "After combine() getOverride() did not returned correct value")
def test_selectGroups01(self):
<|code_end|>
, predict the immediate next line with the help of imports:
import os, sys, textwrap, unittest, mdTestUtilities
from md import logger, overrides, options, utilityFunctions
and context (classes, functions, sometimes code) from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/overrides.py
# class OverrideGroup(dict):
# def __init__(self):
# def __str__(self):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, child):
# def readGroups(filename):
# def selectGroups(groups, overrideGroupNames):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | mdOptions = options.Options() |
Given snippet: <|code_start|> cflags = -O0
testVariable = baseVar
}
gcc, release, * {
cflags = -O2
testVariable = releaseVar
}
""")
try:
tempDir = mdTestUtilities.makeTempDir()
filePath = mdTestUtilities.makeTempFile(tempDir, fileContents)
groups = overrides.readGroups(filePath)
self.assertNotEquals(groups, None, "readGroups() failed to read groups")
self.assertEquals(len(groups), 2, "Wrong number of groups returned")
self.assertEquals(groups[0].compiler, "gcc", "readGroups() has wrong information")
self.assertEquals(groups[0].optimization, "*", "readGroups() has wrong information")
self.assertEquals(groups[0].parallel, "*", "readGroups() has wrong information")
self.assertEquals(fullCount(groups[0]), 3, "readGroups() has wrong information")
self.assertEquals(groups[0]["ccompiler"], "gcc", "readGroups() has wrong information")
self.assertEquals(groups[0]["cflags"], "-O0", "readGroups() has wrong information")
self.assertEquals(groups[0].defines["testvariable"], "baseVar", "readGroups() has wrong information")
self.assertEquals(groups[1].compiler, "gcc", "readGroups() has wrong information")
self.assertEquals(groups[1].optimization, "release", "readGroups() has wrong information")
self.assertEquals(groups[1].parallel, "*", "readGroups() has wrong information")
self.assertEquals(fullCount(groups[1]), 2, "readGroups() has wrong information")
self.assertEquals(groups[1]["cflags"], "-O2", "readGroups() has wrong information")
self.assertEquals(groups[1].defines["testvariable"], "releaseVar", "readGroups() has wrong information")
finally:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os, sys, textwrap, unittest, mdTestUtilities
from md import logger, overrides, options, utilityFunctions
and context:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/overrides.py
# class OverrideGroup(dict):
# def __init__(self):
# def __str__(self):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, child):
# def readGroups(filename):
# def selectGroups(groups, overrideGroupNames):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
which might include code, classes, or functions. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Predict the next line for this snippet: <|code_start|># Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_autoTools(unittest.TestCase):
def test_generateConfigureFiles(self):
try:
tempDir = mdTestUtilities.copyDirToTempDir("cases/simpleGraphAutoTools/TestCaseA")
<|code_end|>
with the help of current file imports:
import os, sys, unittest, mdTestUtilities
from md import autoTools, logger, utilityFunctions
and context from other files:
# Path: md/autoTools.py
# def isAutoToolsProject(path):
# def getInstallDir(command):
# def generateConfigureFiles(path, name, verbose=True):
# def getDependencies(path, name="", verbose=True):
# def isAutoconfInstalled():
# def isLibtoolInstalled():
# def getPreconfigureCommand(path):
# def getConfigureCommand(target):
# def getBuildCommand():
# def getInstallCommand():
# def getCleanCommand():
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may contain function names, class names, or code. Output only the next line. | success = autoTools.generateConfigureFiles(tempDir, "testCaseTarget", False) |
Based on the snippet: <|code_start|> self.assertEquals(success, True, "Unable to generate build files.")
dependencies = autoTools.getDependencies(tempDir, verbose=False)
self.assertEquals(dependencies, [], "Wrong dependencies found in AutoTools project")
finally:
utilityFunctions.removeDir(tempDir)
def test_getDependencies5(self):
#False positive
try:
tempDir = mdTestUtilities.copyDirToTempDir("cases/cmake/hello/main")
dependencies = autoTools.getDependencies(tempDir, verbose=False)
self.assertEquals(dependencies, None, "Wrong dependencies found in AutoTools project")
finally:
utilityFunctions.removeDir(tempDir)
def test_getDependencies6(self):
#False positive
try:
tempDir = mdTestUtilities.copyDirToTempDir("cases/cmake/hello/hello1")
dependencies = autoTools.getDependencies(tempDir, verbose=False)
self.assertEquals(dependencies, None, "Wrong dependencies found in AutoTools project")
finally:
utilityFunctions.removeDir(tempDir)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_autoTools))
return suite
if __name__ == "__main__":
<|code_end|>
, predict the immediate next line with the help of imports:
import os, sys, unittest, mdTestUtilities
from md import autoTools, logger, utilityFunctions
and context (classes, functions, sometimes code) from other files:
# Path: md/autoTools.py
# def isAutoToolsProject(path):
# def getInstallDir(command):
# def generateConfigureFiles(path, name, verbose=True):
# def getDependencies(path, name="", verbose=True):
# def isAutoconfInstalled():
# def isLibtoolInstalled():
# def getPreconfigureCommand(path):
# def getConfigureCommand(target):
# def getBuildCommand():
# def getInstallCommand():
# def getCleanCommand():
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | logger.setLogger("Console") |
Using the snippet: <|code_start|># This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_autoTools(unittest.TestCase):
def test_generateConfigureFiles(self):
try:
tempDir = mdTestUtilities.copyDirToTempDir("cases/simpleGraphAutoTools/TestCaseA")
success = autoTools.generateConfigureFiles(tempDir, "testCaseTarget", False)
self.assertEquals(success, True, "Unable to generate configure files.")
self.assertEquals(os.path.exists(os.path.join(tempDir, "configure")), True, "Configure files did not exist after calling generateConfigureFiles.")
finally:
<|code_end|>
, determine the next line of code. You have imports:
import os, sys, unittest, mdTestUtilities
from md import autoTools, logger, utilityFunctions
and context (class names, function names, or code) available:
# Path: md/autoTools.py
# def isAutoToolsProject(path):
# def getInstallDir(command):
# def generateConfigureFiles(path, name, verbose=True):
# def getDependencies(path, name="", verbose=True):
# def isAutoconfInstalled():
# def isLibtoolInstalled():
# def getPreconfigureCommand(path):
# def getConfigureCommand(target):
# def getBuildCommand():
# def getInstallCommand():
# def getCleanCommand():
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Predict the next line after this snippet: <|code_start|># Copyright (c) 2010-2012, Lawrence Livermore National Security, LLC
# Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_hg(unittest.TestCase):
def test_isHgInstalled(self):
<|code_end|>
using the current file's imports:
import os, sys, unittest, mdTestUtilities
from md import hg, logger, utilityFunctions
and any relevant context from other files:
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | returnValue = hg.isHgInstalled() |
Continue the code snippet: <|code_start|> tempRepo = mdTestUtilities.createHgRepository(tempDir)
try:
returnValue = hg.isHgRepo(tempRepo)
self.assertEqual(returnValue, True, "hg.isHgRepo(" + tempRepo + ") should have returned true.")
finally:
utilityFunctions.removeDir(tempDir)
#Test if wrong path returns false
falsePath = "http://foo/wrong/path"
returnValue = hg.isHgRepo(falsePath)
self.assertEqual(returnValue, False, "hg.isHgRepo(" + falsePath + ") should have returned false.")
def test_hgCheckout(self):
if not hg.isHgInstalled():
self.fail("Hg is not installed on your system. All Hg tests will fail.")
tempDir = mdTestUtilities.makeTempDir()
tempRepo = mdTestUtilities.createHgRepository(tempDir)
checkedOutRepo = os.path.join(tempDir, "checkedOut")
try:
hg.hgCheckout(tempRepo, checkedOutRepo)
returnValue = os.path.exists(os.path.join(checkedOutRepo, "testFile"))
self.assertEqual(returnValue, True, "'testFile' did not exist after hg.hgCheckout(" + tempRepo + ") was called.")
finally:
utilityFunctions.removeDir(tempDir)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_hg))
return suite
if __name__ == "__main__":
<|code_end|>
. Use current file imports:
import os, sys, unittest, mdTestUtilities
from md import hg, logger, utilityFunctions
and context (classes, functions, or code) from other files:
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | logger.setLogger("Console") |
Predict the next line after this snippet: <|code_start|>#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_hg(unittest.TestCase):
def test_isHgInstalled(self):
returnValue = hg.isHgInstalled()
self.assertEqual(returnValue, True, "Hg is not installed on your system. All Hg tests will fail.")
def test_isHgRepoCase1(self):
#Case 1: Local directory that is a Hg repository
if not hg.isHgInstalled():
self.fail("Hg is not installed on your system. All Hg tests will fail.")
#Create repository and test if is Hg repo
tempDir = mdTestUtilities.makeTempDir()
path = mdTestUtilities.createHgRepository(tempDir)
try:
self.assertTrue(hg.isHgRepo(path), "hg.isHgRepo(" + path + ") should have returned true.")
finally:
<|code_end|>
using the current file's imports:
import os, sys, unittest, mdTestUtilities
from md import hg, logger, utilityFunctions
and any relevant context from other files:
# Path: md/hg.py
# def isHgInstalled():
# def isHgRepo(location):
# def hgCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Given the code snippet: <|code_start|> Name: b
Path: b-2.22.tar.gz
DependsOn: c
Name: c
Path: c-3.33.tar.gz
""")
try:
tempDir = mdTestUtilities.makeTempDir()
projectFilePath = mdTestUtilities.makeTempFile(tempDir, projectFileContents, ".md")
myProject = project.Project(projectFilePath)
option = options.Options()
self.assertEquals(myProject.read(), False, "Project file read should have failed")
finally:
utilityFunctions.removeDir(tempDir)
def test_validateSingleTargetProjectWithSteps(self):
projectFileContents = textwrap.dedent("""
Name: a
Path: a-1.11.tar.gz
PreConfig: autoreconf -i
Config: ./configure --prefix=$(_prefix)
Build: make
Install: make install
""")
try:
tempDir = mdTestUtilities.makeTempDir()
projectFilePath = mdTestUtilities.makeTempFile(tempDir, projectFileContents, ".md")
myProject = project.Project(projectFilePath)
option = options.Options()
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, textwrap, unittest, mdTestUtilities
from md import defines, logger, options, project, utilityFunctions
and context (functions, classes, or occasionally code) from other files:
# Path: md/defines.py
# class Defines(dict):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, overridingDefines):
# def expand(self, inString):
# def normalizeKey(key, lower=True):
# def surround(name):
# def setOverrideDefines(defs, overrideGroup):
# def __setToolDefines(defs, overrideGroup):
# def __setFlagDefines(defs, overrideGroup):
# def setJobSlotsDefines(defs, jobSlots):
# def setPrefixDefines(defs, prefix):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/project.py
# class Project(object):
# def __init__(self, projectFilePath, targets=[]):
# def determineStartPoint(self):
# def determineTargetsBuildStepStart(self):
# def determineTargetsSuccess(self):
# def writeStatusLog(self, options):
# def __getStatusLogLine(self, fd, lineCount):
# def __assureEqualsInStatusLog(self, l, name, value):
# def readStatusLog(self, options):
# def addSkipStepFromOptions(self, options):
# def validate(self, options):
# def examine(self, options):
# def __addTarget(self, targets, lineCount=0):
# def getTarget(self, targetName):
# def replaceTarget(self, newTarget):
# def setTargetFieldsAsDefines(self, defines):
# def read(self):
# def write(self, fileName=""):
# def __str__(self):
# def __validateDependsOnLists(self):
# def __searchPathsForCycles(self, path):
# def __assignDepthToTargetList(self):
# def __sortTargetList(self, targetList):
# def __expandDependancyLists(self):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | defines.setPrefixDefines(option.defines, os.path.abspath(os.path.join(tempDir, "prefix"))) |
Given the following code snippet before the placeholder: <|code_start|># under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_project(unittest.TestCase):
def test_readSingleTargetProject(self):
projectFileContents = textwrap.dedent("""
Name: a
Path: a-1.11.tar.gz
PreConfig: autoreconf -i
Config: ./configure --prefix=$(_prefix)
Build: make
Install: make install
""")
try:
tempDir = mdTestUtilities.makeTempDir()
projectFilePath = mdTestUtilities.makeTempFile(tempDir, projectFileContents, ".md")
<|code_end|>
, predict the next line using imports from the current file:
import os, sys, textwrap, unittest, mdTestUtilities
from md import defines, logger, options, project, utilityFunctions
and context including class names, function names, and sometimes code from other files:
# Path: md/defines.py
# class Defines(dict):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, overridingDefines):
# def expand(self, inString):
# def normalizeKey(key, lower=True):
# def surround(name):
# def setOverrideDefines(defs, overrideGroup):
# def __setToolDefines(defs, overrideGroup):
# def __setFlagDefines(defs, overrideGroup):
# def setJobSlotsDefines(defs, jobSlots):
# def setPrefixDefines(defs, prefix):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/project.py
# class Project(object):
# def __init__(self, projectFilePath, targets=[]):
# def determineStartPoint(self):
# def determineTargetsBuildStepStart(self):
# def determineTargetsSuccess(self):
# def writeStatusLog(self, options):
# def __getStatusLogLine(self, fd, lineCount):
# def __assureEqualsInStatusLog(self, l, name, value):
# def readStatusLog(self, options):
# def addSkipStepFromOptions(self, options):
# def validate(self, options):
# def examine(self, options):
# def __addTarget(self, targets, lineCount=0):
# def getTarget(self, targetName):
# def replaceTarget(self, newTarget):
# def setTargetFieldsAsDefines(self, defines):
# def read(self):
# def write(self, fileName=""):
# def __str__(self):
# def __validateDependsOnLists(self):
# def __searchPathsForCycles(self, path):
# def __assignDepthToTargetList(self):
# def __sortTargetList(self, targetList):
# def __expandDependancyLists(self):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | myProject = project.Project(projectFilePath) |
Based on the snippet: <|code_start|># LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
testFileName = "testFile"
def createTarFile(tempDir):
tarDir = os.path.join(tempDir, "tar")
os.mkdir(tarDir)
<|code_end|>
, predict the immediate next line with the help of imports:
import os, shutil, sys, tempfile
from md import utilityFunctions
and context (classes, functions, sometimes code) from other files:
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | utilityFunctions.executeSubProcess("touch tar/" + testFileName, tempDir) |
Continue the code snippet: <|code_start|> def test_findExecutables07(self):
try:
tempDir = mdTestUtilities.makeTempDir()
mdTestUtilities.createBlankFile(os.path.join(tempDir, "test"))
aDir = os.path.join(tempDir, 'a')
aGccExe = os.path.join(aDir, "gcc")
mdTestUtilities.createBlankFile(aGccExe)
mdTestUtilities.makeFileExecutable(aGccExe)
bDir = os.path.join(tempDir, 'b')
bIccExe = os.path.join(bDir, "icc")
mdTestUtilities.createBlankFile(bIccExe)
mdTestUtilities.makeFileExecutable(bIccExe)
acDir = os.path.join(os.path.join(tempDir, 'a'), 'c')
acIccExe = os.path.join(acDir, "icc")
mdTestUtilities.createBlankFile(acIccExe)
mdTestUtilities.makeFileExecutable(acIccExe)
exes = profiler.findExecutables([(tempDir, True)], ["icc", "gcc"])
self.assertEquals(len(exes), 3, "profiler.findExecutables did not find the right amount of executables")
self.assertTrue(aGccExe in exes, "profiler.findExecutables did not find the right executable")
self.assertTrue(bIccExe in exes, "profiler.findExecutables did not find the right executable")
self.assertTrue(acIccExe in exes, "profiler.findExecutables did not find the right executable")
finally:
utilityFunctions.removeDir(tempDir)
def test_addGnuOptimizationGroup01(self):
<|code_end|>
. Use current file imports:
import os, sys, unittest, mdTestUtilities
from md import logger, options, overrides, profiler, utilityFunctions
and context (classes, functions, or code) from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/overrides.py
# class OverrideGroup(dict):
# def __init__(self):
# def __str__(self):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, child):
# def readGroups(filename):
# def selectGroups(groups, overrideGroupNames):
#
# Path: md/profiler.py
# def findExecutables(dirPairs, exeWildCards):
# def profile(mdOptions):
# def addGnuOptimizationGroup(groups, compilerGroup):
# def addIntelOptimizationGroup(groups, compilerGroup):
# def addPathscaleOptimizationGroup(groups, compilerGroup):
# def addPortlandGroupOptimizationGroup(groups, compilerGroup):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | compilerGroup = overrides.OverrideGroup() |
Here is a snippet: <|code_start|>#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_profiler(unittest.TestCase):
def test_findExecutables01(self):
try:
tempDir = mdTestUtilities.makeTempDir()
testExe = os.path.join(tempDir, "gcc")
mdTestUtilities.createBlankFile(testExe)
mdTestUtilities.makeFileExecutable(testExe)
<|code_end|>
. Write the next line using the current file imports:
import os, sys, unittest, mdTestUtilities
from md import logger, options, overrides, profiler, utilityFunctions
and context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/overrides.py
# class OverrideGroup(dict):
# def __init__(self):
# def __str__(self):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, child):
# def readGroups(filename):
# def selectGroups(groups, overrideGroupNames):
#
# Path: md/profiler.py
# def findExecutables(dirPairs, exeWildCards):
# def profile(mdOptions):
# def addGnuOptimizationGroup(groups, compilerGroup):
# def addIntelOptimizationGroup(groups, compilerGroup):
# def addPathscaleOptimizationGroup(groups, compilerGroup):
# def addPortlandGroupOptimizationGroup(groups, compilerGroup):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may include functions, classes, or code. Output only the next line. | exes = profiler.findExecutables([(tempDir, False)], ["gcc"]) |
Continue the code snippet: <|code_start|>#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_profiler(unittest.TestCase):
def test_findExecutables01(self):
try:
tempDir = mdTestUtilities.makeTempDir()
testExe = os.path.join(tempDir, "gcc")
mdTestUtilities.createBlankFile(testExe)
mdTestUtilities.makeFileExecutable(testExe)
exes = profiler.findExecutables([(tempDir, False)], ["gcc"])
self.assertEquals(len(exes), 1, "profiler.findExecutables did not find the right amount of executables")
self.assertEquals(exes[0], testExe, "profiler.findExecutables did not find the right executable")
finally:
<|code_end|>
. Use current file imports:
import os, sys, unittest, mdTestUtilities
from md import logger, options, overrides, profiler, utilityFunctions
and context (classes, functions, or code) from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/options.py
# class Options(object):
# def __init__(self):
# def __str__(self):
# def targetSpecifiedToBuild(self, targetName):
# def setStatusLogPath(self, prefix, projectName):
# def validate(self):
# def __validateOptionsDir(self, path):
# def __processImportCommandline(self, commandline):
# def __processProfileCommandline(self, commandline):
# def processCommandline(self, commandline=[]):
# def printUsageAndExit(self, errorStr=""):
# def printUsage(self, errorStr=""):
# def validateOptionPair(flag, value):
# def validateOption(flag, value):
#
# Path: md/overrides.py
# class OverrideGroup(dict):
# def __init__(self):
# def __str__(self):
# def __contains__(self, key):
# def __setitem__(self, key, value):
# def __getitem__(self, key):
# def combine(self, child):
# def readGroups(filename):
# def selectGroups(groups, overrideGroupNames):
#
# Path: md/profiler.py
# def findExecutables(dirPairs, exeWildCards):
# def profile(mdOptions):
# def addGnuOptimizationGroup(groups, compilerGroup):
# def addIntelOptimizationGroup(groups, compilerGroup):
# def addPathscaleOptimizationGroup(groups, compilerGroup):
# def addPortlandGroupOptimizationGroup(groups, compilerGroup):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Predict the next line for this snippet: <|code_start|>
neonPath = utilityFunctions.downloadFile(neonURL, downloadDir)
self.assertNotEquals(neonPath, "", "Neon failed to download")
sqlitePath = utilityFunctions.downloadFile(sqliteURL, downloadDir)
self.assertNotEquals(sqlitePath, "", "Sqlite failed to download")
importRC = utilityFunctions.executeSubProcess("mixdown --import " + svnPath + " " + aprPath + " " + aprUtilPath + " " + neonPath + " " + sqlitePath, tempDir)
self.assertEquals(importRC, 0, "Subversion test case failed import.")
buildRC = utilityFunctions.executeSubProcess("mixdown subversion-1.6.12.md -ptestPrefix" + skipAPRPreconfig, tempDir)
self.assertEquals(buildRC, 0, "Subversion test case failed build.")
cleanRC = utilityFunctions.executeSubProcess("mixdown --clean subversion-1.6.12.md", tempDir)
self.assertEquals(cleanRC, 0, "Subversion test case failed clean.")
prefix = os.path.join(tempDir, "testPrefix")
binDir = os.path.join(prefix, "bin")
libDir = os.path.join(prefix, "lib")
self.assertEquals(os.path.exists(os.path.join(binDir, "svn")), True, "Executable does not exist after building CMake Hello test case.")
finally:
utilityFunctions.removeDir(tempDir)
os.environ["PATH"] = origPath
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_MixDownLong))
return suite
if __name__ == "__main__":
<|code_end|>
with the help of current file imports:
import os, socket, sys, unittest, mdTestUtilities
from md import logger, utilityFunctions
and context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
, which may contain function names, class names, or code. Output only the next line. | logger.setLogger("Console") |
Given the code snippet: <|code_start|># WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_MixDownLong(unittest.TestCase):
def test_subversion(self):
svnURL = "http://subversion.tigris.org/downloads/subversion-1.6.12.tar.bz2"
aprURL = "http://mirror.candidhosting.com/pub/apache/apr/apr-1.4.6.tar.bz2"
aprUtilURL = "http://mirror.candidhosting.com/pub/apache//apr/apr-util-1.3.12.tar.gz"
neonURL = "http://www.webdav.org/neon/neon-0.29.5.tar.gz"
sqliteURL = "http://www.sqlite.org/sqlite-autoconf-3070500.tar.gz"
skipAPRPreconfig = ""
if socket.gethostname() == "tux316.llnl.gov":
skipAPRPreconfig = " -sapr:preconfig"
try:
mixDownPath = os.path.abspath("..")
origPath = os.environ["PATH"]
os.environ["PATH"] = mixDownPath + ":" + origPath
tempDir = mdTestUtilities.makeTempDir()
downloadDir = os.path.join(tempDir, "testDownloadFiles")
<|code_end|>
, generate the next line using the imports in this file:
import os, socket, sys, unittest, mdTestUtilities
from md import logger, utilityFunctions
and context (functions, classes, or occasionally code) from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | svnPath = utilityFunctions.downloadFile(svnURL, downloadDir) |
Based on the snippet: <|code_start|># Copyright (c) 2010-2012, Lawrence Livermore National Security, LLC
# Produced at Lawrence Livermore National Laboratory
# LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_git(unittest.TestCase):
def test_isGitInstalled(self):
<|code_end|>
, predict the immediate next line with the help of imports:
import os, sys, unittest, mdTestUtilities
from md import git, logger, utilityFunctions
and context (classes, functions, sometimes code) from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | returnValue = git.isGitInstalled() |
Given the code snippet: <|code_start|> try:
tempDir = mdTestUtilities.makeTempDir()
tarDir, path = mdTestUtilities.createGzipFile(tempDir)
self.assertFalse(git.isGitRepo(path), "git.isGitRepo(" + path + ") should have returned false.")
finally:
utilityFunctions.removeDir(tempDir)
#Remote file
path = "http://www.eng.lsu.edu/mirrors/apache//apr/apr-util-1.3.10.tar.gz"
self.assertFalse(git.isGitRepo(path), "git.isGitRepo(" + path + ") should have returned false.")
def test_gitCheckout(self):
if not git.isGitInstalled():
self.fail("Git is not installed on your system. All Git tests will fail.")
tempDir = mdTestUtilities.makeTempDir()
tempRepo = mdTestUtilities.createGitRepository(tempDir)
checkedOutRepo = os.path.join(tempDir, "checkedOut")
try:
git.gitCheckout(tempRepo, checkedOutRepo)
returnValue = os.path.exists(os.path.join(checkedOutRepo, mdTestUtilities.testFileName))
self.assertEqual(returnValue, True, "'" + mdTestUtilities.testFileName + "' did not exist after git.gitCheckout(" + tempRepo + ") was called.")
finally:
utilityFunctions.removeDir(tempDir)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_git))
return suite
if __name__ == "__main__":
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, unittest, mdTestUtilities
from md import git, logger, utilityFunctions
and context (functions, classes, or occasionally code) from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | logger.setLogger("Console") |
Given the code snippet: <|code_start|>#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_git(unittest.TestCase):
def test_isGitInstalled(self):
returnValue = git.isGitInstalled()
self.assertEqual(returnValue, True, "Git is not installed on your system. All Git tests will fail.")
def test_isGitRepoCase1(self):
#Case 1: Local directory that is a git repository
if not git.isGitInstalled():
self.fail("Git is not installed on your system. All Git tests will fail.")
#Create repository and test if is git repo
tempDir = mdTestUtilities.makeTempDir()
tempRepo = mdTestUtilities.createGitRepository(tempDir)
try:
self.assertTrue(git.isGitRepo(tempRepo), "git.isGitRepo(" + tempRepo + ") should have returned true.")
finally:
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, unittest, mdTestUtilities
from md import git, logger, utilityFunctions
and context (functions, classes, or occasionally code) from other files:
# Path: md/git.py
# def isGitInstalled():
# def isGitRepo(location):
# def gitCheckout(repoLocation, outPath):
#
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | utilityFunctions.removeDir(tempDir) |
Next line prediction: <|code_start|> origPath = os.environ["PATH"]
os.environ["PATH"] = mixDownPath + ":" + origPath
tempDir = mdTestUtilities.copyDirToTempDir("cases/simpleGraphAutoTools")
importRC = utilityFunctions.executeSubProcess("mixdown --import " + os.path.join(tempDir, "TestCaseA") + " " + os.path.join(tempDir, "TestCaseB") + " " + os.path.join(tempDir, "TestCaseC") + " " + os.path.join(tempDir, "TestCaseD"), tempDir)
self.assertEquals(importRC, 0, "AutoTools Simple Graph test case failed import.")
self.assertEquals(os.path.exists(os.path.join(tempDir, "TestCaseA.md")), True, "MixDown project file does not exist after importing AutoTools Simple Graph test case.")
buildRC = utilityFunctions.executeSubProcess("mixdown TestCaseA.md -ptestPrefix", tempDir)
self.assertEquals(buildRC, 0, "AutoTools Simple Graph test case failed build.")
cleanRC = utilityFunctions.executeSubProcess("mixdown --clean TestCaseA.md", tempDir)
self.assertEquals(cleanRC, 0, "AutoTools Simple Graph test case failed clean.")
prefix = os.path.join(tempDir, "testPrefix")
binDir = os.path.join(prefix, "bin")
self.assertEquals(os.path.exists(os.path.join(binDir, "TestCaseA")), True, "Executable A does not exist after building AutoTools Simple Graph test case.")
self.assertEquals(os.path.exists(os.path.join(binDir, "TestCaseB")), True, "Executable B does not exist after building AutoTools Simple Graph test case.")
self.assertEquals(os.path.exists(os.path.join(binDir, "TestCaseC")), True, "Executable C does not exist after building AutoTools Simple Graph test case.")
self.assertEquals(os.path.exists(os.path.join(binDir, "TestCaseD")), True, "Executable D does not exist after building AutoTools Simple Graph test case.")
finally:
utilityFunctions.removeDir(tempDir)
os.environ["PATH"] = origPath
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test_MixDownShort))
return suite
if __name__ == "__main__":
<|code_end|>
. Use current file imports:
(import os, sys, unittest, mdTestUtilities
from md import logger, utilityFunctions)
and context including class names, function names, or small code snippets from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | logger.setLogger("Console") |
Predict the next line after this snippet: <|code_start|># LLNL-CODE-462894
# All rights reserved.
#
# This file is part of MixDown. Please read the COPYRIGHT file
# for Our Notice and the LICENSE file for the GNU Lesser General Public
# License.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License (as published by
# the Free Software Foundation) version 3 dated June 2007.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if not ".." in sys.path:
sys.path.append("..")
class Test_MixDownShort(unittest.TestCase):
def test_cmakeHello(self):
try:
mixDownPath = os.path.join(os.path.abspath(".."), "mixdown")
tempDir = mdTestUtilities.copyDirToTempDir("cases/cmake/hello")
<|code_end|>
using the current file's imports:
import os, sys, unittest, mdTestUtilities
from md import logger, utilityFunctions
and any relevant context from other files:
# Path: md/logger.py
# def secondsToHMS(seconds=0):
# def Logger():
# def setLogger(loggerName="", logOutputDir=""):
# def close():
# def writeMessage(message, targetName="", targetStep="", forceStdOut=False):
# def writeError(message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(targetName="", targetStep="", reason=""):
# def reportStart(targetName="", targetStep=""):
# def reportSuccess(targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(targetName="", targetStep=""):
# def getErrorFd(targetName="", targetStep=""):
# def _writeStdOut(self, message):
# def _writeStdErr(self, message):
# def close(self):
# def writeMessage(self, message, targetName="", targetStep=""):
# def writeError(self, message, targetName="", targetStep="", filePath="", lineNumber=0, exitProgram=False):
# def reportSkipped(self, targetName="", targetStep="", reason=""):
# def reportStart(self, targetName="", targetStep=""):
# def reportSuccess(self, targetName="", targetStep="", timeInSeconds=0):
# def reportFailure(self, targetName="", targetStep="", timeInSeconds=0, returnCode=0, exitProgram=False):
# def getOutFd(self, targetName="", targetStep=""):
# def getErrorFd(self, targetName="", targetStep=""):
# class LoggerBase(object):
#
# Path: md/utilityFunctions.py
# def boolToStr(s):
# def downloadFile(URL, downloadDir):
# def executeCommand(command, args="", workingDirectory="", verbose=False, exitOnError=False):
# def executeSubProcess(command, workingDirectory=tempfile.gettempdir(), outFileHandle=1, verbose=False, exitOnError=False):
# def findFilesWithExtension(path, extension):
# def findShallowestFile(startPath, fileList):
# def getBasename(path):
# def haveWriteAccess(path):
# def isURL(url):
# def __pathExists(directory, basename):
# def pathExists(path, forceCaseSensitive=False):
# def prettyPrintList(list, header="", headerIndent="", itemIndent=""):
# def printErrorAndExit(errorStr, filePath="", lineNumber=0):
# def removeDir(path):
# def removeDuplicatesFromList(myList):
# def splitFileName(fileName):
# def stripItemsInList(value):
# def untar(tarPath, outPath="", stripDir=False):
# def unzip(zipPath, outPath="", stripDir=False):
# def URLToFilename(url):
# def hasTarFileExtension(path):
# def validateCompressedFile(path, logger=None):
# def setVariables(filename, variableList):
# def is_exe(fpath):
# def isInstalled(program):
. Output only the next line. | importRC = utilityFunctions.executeSubProcess(mixDownPath + " --import " + os.path.join(tempDir, "main") + " " + os.path.join(tempDir, "hello1"), tempDir) |
Given snippet: <|code_start|>
TIGER_CONTINGENCY_FILENAME = 'Tiger_et_al_TableS1_SBtab_ContingencyID.tsv'
TIGER_CONTINGENCY_PATH = os.path.join(os.path.dirname(__file__), TIGER_CONTINGENCY_FILENAME)
DEFINITIONS_FILENAME = 'definitions.tsv'
DEFINITIONS_PATH = os.path.join(os.path.dirname(__file__), DEFINITIONS_FILENAME)
RXNCON_DEFINITIONS_FILENAME = 'rxncon_Definition.tsv'
RXNCON_DEFINITIONS_PATH = os.path.join(os.path.dirname(__file__), RXNCON_DEFINITIONS_FILENAME)
def test_sbtab_definition_from_file() -> None:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import math
import pytest
from rxncon.input.sbtab.sbtab import sbtab_data_from_file, ValidatedSBtabData, SBtabData
and context:
# Path: rxncon/input/sbtab/sbtab.py
# def sbtab_data_from_file(filename: str, separator: str = '\t', definitions: Optional[SBtabData] = None) -> SBtabData:
# sbtab_input = []
#
# with open(filename) as f:
# for row in f:
# if row.startswith('%'):
# continue
# else:
# sbtab_input.append(row.split(separator))
#
# if definitions:
# return ValidatedSBtabData(sbtab_input, definitions)
# else:
# return SBtabData(sbtab_input)
#
# class ValidatedSBtabData(SBtabData):
# def __init__(self, input: List[List[str]], definition: SBtabData) -> None:
# super().__init__(input)
#
# self._definition = definition
# self._field_postprocessors = {} # type: Dict[str, Callable[[str], Union[str, float, bool, int]]]
# self._construct_field_postprocessors()
# self._entry_class.field_postprocessors = {_field_name_from_column_name(col): func # type: ignore
# for col, func in self._field_postprocessors.items()} # type: ignore
# self._postprocess_entries()
#
# def _construct_field_postprocessors(self) -> None:
# if hasattr(self._definition.entries[0], 'ComponentName'):
# type_definitions = {def_entry.ComponentName: def_entry.Format # type: ignore
# for def_entry in self._definition.entries
# if def_entry.IsPartOf == self.table_type} # type: ignore
# elif hasattr(self._definition.entries[0], 'Component'):
# type_definitions = {def_entry.Component: def_entry.Format # type: ignore
# for def_entry in self._definition.entries
# if def_entry.IsPartOf == self.table_type} # type: ignore
# else:
# raise AssertionError('Could not parse the definition file')
#
# for column in self._column_names:
# self._field_postprocessors[column] = _field_postprocessor_for_type_string(type_definitions[column])
#
# def _postprocess_entries(self) -> None:
# for entry in self.entries:
# entry.postprocess()
#
# class SBtabData:
# def __init__(self, input: List[List[str]]) -> None:
# self.version = None # type: Optional[str]
# self.entries = [] # type: List[EntryBase]
# self.document_name = None # type: Optional[str]
# self.table_type = None # type: Optional[str]
# self.table_name = None # type: Optional[str]
#
# self._input = input
# self._column_names = [] # type: List[str]
#
# self._parse_header()
# self._parse_column_names()
# self._construct_entry_class()
# self._parse_entries()
#
# def _parse_header(self) -> None:
# REGEX_VERSION_A = 'SBtabVersion (\'|\").+?(\'|\")'
# REGEX_VERSION_B = 'SBtabVersion=(\'|\").+?(\'|\")'
# REGEX_DOCUMENT = 'Document=(\'|\").+?(\'|\")'
# REGEX_TABLE_TYPE = 'TableType=(\'|\").+?(\'|\")'
# REGEX_TABLE_NAME = 'TableName=(\'|\").+?(\'|\")'
#
# for col in self._input[0][1:]:
# assert not col.strip('\n')
#
# header = self._input[0][0]
#
# assert header.startswith('!!SBtab')
#
# match = re.search(REGEX_VERSION_A, header)
# if match:
# setattr(self, 'version', _unquote(match.group(0).split(' ')[1]))
#
# for regex, attr in zip([REGEX_VERSION_B, REGEX_DOCUMENT, REGEX_TABLE_TYPE, REGEX_TABLE_NAME],
# ['version', 'document_name', 'table_type', 'table_name']):
# match = re.search(regex, header)
# if match:
# setattr(self, attr, _header_value(match.group(0)))
#
# def _parse_column_names(self) -> None:
# columns = self._input[1]
# assert len(columns) > 0
#
# self._column_names = [_cleaned_column_name(name) for name in columns]
#
# def _construct_entry_class(self) -> None:
# assert self.table_name
# assert self._column_names
# self._entry_class = type(_class_name_from_table_name(self.table_name), (EntryBase,),
# {'field_names': [_field_name_from_column_name(col) for col in self._column_names]})
#
# def _parse_entries(self) -> None:
# for row in self._input[2:]:
# entry = self._entry_class()
#
# for i, column_value in enumerate(row):
# setattr(entry, _field_name_from_column_name(self._column_names[i]), column_value.strip())
#
# self.entries.append(entry)
which might include code, classes, or functions. Output only the next line. | sbtab = sbtab_data_from_file(DEFINITIONS_PATH) |
Given snippet: <|code_start|># All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
CONF = config.CONF
bp = flask.Blueprint("regions", __name__)
@bp.route("", defaults={"detailed": False})
@bp.route("/detailed", defaults={"detailed": True})
@fake_regions.get_regions
def get_regions(detailed):
regions = {}
for service_name in CONF["services"].keys():
if service_name == "infra":
continue # TODO(boris-42): This should not be checked here.
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import flask
from oss_lib import config
from ceagle.api import client
from ceagle.api_fake_data import fake_regions
and context:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api_fake_data/fake_regions.py
# REGIONS_NUM = 4
# def regions(detailed=False):
# def get_regions(detailed):
which might include code, classes, or functions. Output only the next line. | service_client = client.get_client(service_name) |
Predict the next line for this snippet: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
CONF = config.CONF
bp = flask.Blueprint("regions", __name__)
@bp.route("", defaults={"detailed": False})
@bp.route("/detailed", defaults={"detailed": True})
<|code_end|>
with the help of current file imports:
import flask
from oss_lib import config
from ceagle.api import client
from ceagle.api_fake_data import fake_regions
and context from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api_fake_data/fake_regions.py
# REGIONS_NUM = 4
# def regions(detailed=False):
# def get_regions(detailed):
, which may contain function names, class names, or code. Output only the next line. | @fake_regions.get_regions |
Here is a snippet: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
config.process_env("CEAGLE",
default_config_path=cfg.DEFAULT_CONF_PATH,
defaults=cfg.DEFAULT,
validation_schema=cfg.SCHEMA)
<|code_end|>
. Write the next line using the current file imports:
from oss_lib import config
from ceagle import app
from ceagle import config as cfg
and context from other files:
# Path: ceagle/app.py
# def versions():
# def not_found(error):
# def handle_unknown_service(ex):
#
# Path: ceagle/config.py
# DEFAULT_CONF_PATH = "/etc/ceagle/config.yaml"
# DEFAULT = {
# "use_fake_api_data": True,
# "services": {},
# }
# SCHEMA = {
# "use_fake_api_data": {"type": "boolean"},
# "services": {
# "type": "object",
# "properties": {
# "availability": {"type": "string"},
# "capacity": {"type": "string"},
# "cis": {"type": "string"},
# "health": {"type": "string"},
# "optimization": {"type": "string"},
# "performance": {"type": "string"},
# "security": {"type": "string"},
# "infra": {
# "type": "object",
# "patternProperties": {
# "\w+": {
# "type": "array",
# "uniqueItems": True,
# "items": {
# "type": "object",
# "properties": {
# "id": {
# "type": "string",
# "minLength": 1,
# },
# "title": {
# "type": "string",
# "minLength": 1,
# },
# "description": {
# "type": "string",
# "minLength": 1,
# },
# "urls": {
# "type": "array",
# "items": {
# "type": "array",
# "items": {
# "type": "string",
# "minLength": 8
# }
# }
# },
# },
# "required": ["id", "title", "description", "urls"],
# "additionalProperties": False,
# },
# },
# }
# }
# },
# "additionalProperties": False,
# },
# }
, which may include functions, classes, or code. Output only the next line. | application = app.app |
Given the following code snippet before the placeholder: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
<|code_end|>
, predict the next line using imports from the current file:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and context including class names, function names, and sometimes code from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
. Output only the next line. | @app.errorhandler(client.UnknownService) |
Given the code snippet: <|code_start|>#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
@app.errorhandler(client.UnknownService)
def handle_unknown_service(ex):
return flask.jsonify({"error": str(ex)}), 404
for bp in [status, infrastructure, intelligence, optimization, security,
<|code_end|>
, generate the next line using the imports in this file:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and context (functions, classes, or occasionally code) from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
. Output only the next line. | regions, runbooks, capacity]: |
Predict the next line after this snippet: <|code_start|># a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
@app.errorhandler(client.UnknownService)
def handle_unknown_service(ex):
return flask.jsonify({"error": str(ex)}), 404
<|code_end|>
using the current file's imports:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and any relevant context from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
. Output only the next line. | for bp in [status, infrastructure, intelligence, optimization, security, |
Predict the next line after this snippet: <|code_start|># a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
@app.errorhandler(client.UnknownService)
def handle_unknown_service(ex):
return flask.jsonify({"error": str(ex)}), 404
<|code_end|>
using the current file's imports:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and any relevant context from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
. Output only the next line. | for bp in [status, infrastructure, intelligence, optimization, security, |
Given the code snippet: <|code_start|># a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
@app.errorhandler(client.UnknownService)
def handle_unknown_service(ex):
return flask.jsonify({"error": str(ex)}), 404
<|code_end|>
, generate the next line using the imports in this file:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and context (functions, classes, or occasionally code) from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
. Output only the next line. | for bp in [status, infrastructure, intelligence, optimization, security, |
Predict the next line after this snippet: <|code_start|>#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
@app.errorhandler(client.UnknownService)
def handle_unknown_service(ex):
return flask.jsonify({"error": str(ex)}), 404
for bp in [status, infrastructure, intelligence, optimization, security,
<|code_end|>
using the current file's imports:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and any relevant context from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
. Output only the next line. | regions, runbooks, capacity]: |
Continue the code snippet: <|code_start|>#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
@app.errorhandler(client.UnknownService)
def handle_unknown_service(ex):
return flask.jsonify({"error": str(ex)}), 404
for bp in [status, infrastructure, intelligence, optimization, security,
<|code_end|>
. Use current file imports:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and context (classes, functions, or code) from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
. Output only the next line. | regions, runbooks, capacity]: |
Predict the next line for this snippet: <|code_start|># a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
@app.errorhandler(client.UnknownService)
def handle_unknown_service(ex):
return flask.jsonify({"error": str(ex)}), 404
<|code_end|>
with the help of current file imports:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and context from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
, which may contain function names, class names, or code. Output only the next line. | for bp in [status, infrastructure, intelligence, optimization, security, |
Here is a snippet: <|code_start|># a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
app = flask.Flask("ceagle", static_folder=None)
@app.route("/api/")
def versions():
return flask.jsonify({"versions": ["1.0"]})
@app.errorhandler(404)
def not_found(error):
return flask.jsonify({"error": "Not Found"}), 404
@app.errorhandler(client.UnknownService)
def handle_unknown_service(ex):
return flask.jsonify({"error": str(ex)}), 404
<|code_end|>
. Write the next line using the current file imports:
import flask
from oss_lib import routing
from ceagle.api import client
from ceagle.api.v1 import capacity
from ceagle.api.v1 import infrastructure
from ceagle.api.v1 import intelligence
from ceagle.api.v1 import optimization
from ceagle.api.v1 import regions
from ceagle.api.v1 import runbooks
from ceagle.api.v1 import security
from ceagle.api.v1 import status
and context from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api/v1/capacity.py
# def index():
# def get_blueprints():
#
# Path: ceagle/api/v1/infrastructure.py
# CONF = config.CONF
# def get_region_infra(region):
# def get_regions_infra():
# def get_blueprints():
#
# Path: ceagle/api/v1/intelligence.py
# def get_intelligence():
# def get_blueprints():
#
# Path: ceagle/api/v1/optimization.py
# def get_optimization():
# def get_blueprints():
#
# Path: ceagle/api/v1/regions.py
# CONF = config.CONF
# def get_regions(detailed):
# def get_blueprints():
#
# Path: ceagle/api/v1/runbooks.py
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
# def get_blueprints():
#
# Path: ceagle/api/v1/security.py
# def get_issues(region, period):
# def get_issues_all_regions(period):
# def get_blueprints():
#
# Path: ceagle/api/v1/status.py
# CONF = config.CONF
# def get_status_helper(period, region=None):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
# def get_blueprints():
, which may include functions, classes, or code. Output only the next line. | for bp in [status, infrastructure, intelligence, optimization, security, |
Given the following code snippet before the placeholder: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
CONF = config.CONF
bp = flask.Blueprint("infra", __name__)
@bp.route("/region/<region>/infra")
<|code_end|>
, predict the next line using imports from the current file:
import flask
from oss_lib import config
from ceagle.api_fake_data import fake_infra
and context including class names, function names, and sometimes code from other files:
# Path: ceagle/api_fake_data/fake_infra.py
# INFRAS = [
# [{"id": "horizon",
# "title": "Horizon",
# "description": "Web UI that manages OpenStack resources",
# "urls": [["http://none"]]},
# {"id": "git",
# "title": "Git Source Control",
# "description": ("Gitlab with Git repositories with all "
# "projects source code"),
# "urls": [["http://none"], ["http://none", "http://none"]]},
# {"id": "packages",
# "title": "JFrog Artifactory Packages",
# "description": ("JFrog Artifactory service that contains "
# "all cloud packages & images"),
# "urls": [["http://none"],
# ["http://none", "http://none"],
# ["http://none", "http://none", "http://none"],
# ]},
# {"id": "stacklight",
# "title": "Stacklight",
# "description": "Cloud Logging, Metering and Alerting services",
# "urls": [["http://none", "http://none", "http://none", "http://none"]]}],
# [{"id": "horizon",
# "title": "Horizon",
# "description": "Web UI that manages OpenStack resources",
# "urls": [["http://none"]]},
# {"id": "baremetal",
# "title": "Baremetal Provisioning",
# "description": "MaaS service that manages baremetal infrastructure",
# "urls": [["http://none", "http://none"], ["http://none"]]},
# {"id": "jenkins",
# "title": "Jenkins CI/CD",
# "description": "Cloud Continues Integration and Deployment.",
# "urls": [["http://none"]]}]]
# def get_region_infra(region):
# def get_regions_infra():
. Output only the next line. | @fake_infra.get_region_infra |
Here is a snippet: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
security = flask.Blueprint("security", __name__)
@security.route("/region/<region>/security/issues/<period>", methods=["GET"])
def get_issues(region, period):
<|code_end|>
. Write the next line using the current file imports:
import flask
from ceagle.api import client
and context from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
, which may include functions, classes, or code. Output only the next line. | c = client.get_client("security") |
Predict the next line after this snippet: <|code_start|> "title": "Git Source Control",
"description": ("Gitlab with Git repositories with all "
"projects source code"),
"urls": [["http://none"], ["http://none", "http://none"]]},
{"id": "packages",
"title": "JFrog Artifactory Packages",
"description": ("JFrog Artifactory service that contains "
"all cloud packages & images"),
"urls": [["http://none"],
["http://none", "http://none"],
["http://none", "http://none", "http://none"],
]},
{"id": "stacklight",
"title": "Stacklight",
"description": "Cloud Logging, Metering and Alerting services",
"urls": [["http://none", "http://none", "http://none", "http://none"]]}],
[{"id": "horizon",
"title": "Horizon",
"description": "Web UI that manages OpenStack resources",
"urls": [["http://none"]]},
{"id": "baremetal",
"title": "Baremetal Provisioning",
"description": "MaaS service that manages baremetal infrastructure",
"urls": [["http://none", "http://none"], ["http://none"]]},
{"id": "jenkins",
"title": "Jenkins CI/CD",
"description": "Cloud Continues Integration and Deployment.",
"urls": [["http://none"]]}]]
<|code_end|>
using the current file's imports:
import itertools
import flask
from ceagle.api_fake_data import base
from ceagle.api_fake_data import fake_regions
and any relevant context from other files:
# Path: ceagle/api_fake_data/base.py
# CONF = config.CONF
# def route(reg):
# def decorator(method):
# def __init__(self, name, endpoint):
# def _setup_routing(self):
# def _find_route(self, path):
# def default(self, path, *args, **kwargs):
# def get(self, path, **kwargs):
# def api_handler(fake):
# def real_function_handler(real):
# def choice_maker(*args, **kwargs):
# def randnum(from_num, to_num, round_by=2):
# class FakeClient(object):
#
# Path: ceagle/api_fake_data/fake_regions.py
# REGIONS_NUM = 4
# def regions(detailed=False):
# def get_regions(detailed):
. Output only the next line. | @base.api_handler |
Next line prediction: <|code_start|> "projects source code"),
"urls": [["http://none"], ["http://none", "http://none"]]},
{"id": "packages",
"title": "JFrog Artifactory Packages",
"description": ("JFrog Artifactory service that contains "
"all cloud packages & images"),
"urls": [["http://none"],
["http://none", "http://none"],
["http://none", "http://none", "http://none"],
]},
{"id": "stacklight",
"title": "Stacklight",
"description": "Cloud Logging, Metering and Alerting services",
"urls": [["http://none", "http://none", "http://none", "http://none"]]}],
[{"id": "horizon",
"title": "Horizon",
"description": "Web UI that manages OpenStack resources",
"urls": [["http://none"]]},
{"id": "baremetal",
"title": "Baremetal Provisioning",
"description": "MaaS service that manages baremetal infrastructure",
"urls": [["http://none", "http://none"], ["http://none"]]},
{"id": "jenkins",
"title": "Jenkins CI/CD",
"description": "Cloud Continues Integration and Deployment.",
"urls": [["http://none"]]}]]
@base.api_handler
def get_region_infra(region):
<|code_end|>
. Use current file imports:
(import itertools
import flask
from ceagle.api_fake_data import base
from ceagle.api_fake_data import fake_regions)
and context including class names, function names, or small code snippets from other files:
# Path: ceagle/api_fake_data/base.py
# CONF = config.CONF
# def route(reg):
# def decorator(method):
# def __init__(self, name, endpoint):
# def _setup_routing(self):
# def _find_route(self, path):
# def default(self, path, *args, **kwargs):
# def get(self, path, **kwargs):
# def api_handler(fake):
# def real_function_handler(real):
# def choice_maker(*args, **kwargs):
# def randnum(from_num, to_num, round_by=2):
# class FakeClient(object):
#
# Path: ceagle/api_fake_data/fake_regions.py
# REGIONS_NUM = 4
# def regions(detailed=False):
# def get_regions(detailed):
. Output only the next line. | regions = fake_regions.regions() |
Based on the snippet: <|code_start|># a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--host",
default="0.0.0.0",
help="A host to bind development server. "
"(default 0.0.0.0)")
parser.add_argument("--port",
type=int,
default=5000,
help="A port to bind development server. "
"(default 5000)")
args = config.process_args("CEAGLE",
parser=parser,
default_config_path=cfg.DEFAULT_CONF_PATH,
defaults=cfg.DEFAULT,
validation_schema=cfg.SCHEMA)
<|code_end|>
, predict the immediate next line with the help of imports:
import argparse
from oss_lib import config
from ceagle import app
from ceagle import config as cfg
and context (classes, functions, sometimes code) from other files:
# Path: ceagle/app.py
# def versions():
# def not_found(error):
# def handle_unknown_service(ex):
#
# Path: ceagle/config.py
# DEFAULT_CONF_PATH = "/etc/ceagle/config.yaml"
# DEFAULT = {
# "use_fake_api_data": True,
# "services": {},
# }
# SCHEMA = {
# "use_fake_api_data": {"type": "boolean"},
# "services": {
# "type": "object",
# "properties": {
# "availability": {"type": "string"},
# "capacity": {"type": "string"},
# "cis": {"type": "string"},
# "health": {"type": "string"},
# "optimization": {"type": "string"},
# "performance": {"type": "string"},
# "security": {"type": "string"},
# "infra": {
# "type": "object",
# "patternProperties": {
# "\w+": {
# "type": "array",
# "uniqueItems": True,
# "items": {
# "type": "object",
# "properties": {
# "id": {
# "type": "string",
# "minLength": 1,
# },
# "title": {
# "type": "string",
# "minLength": 1,
# },
# "description": {
# "type": "string",
# "minLength": 1,
# },
# "urls": {
# "type": "array",
# "items": {
# "type": "array",
# "items": {
# "type": "string",
# "minLength": 8
# }
# }
# },
# },
# "required": ["id", "title", "description", "urls"],
# "additionalProperties": False,
# },
# },
# }
# }
# },
# "additionalProperties": False,
# },
# }
. Output only the next line. | app.app.config["DEBUG"] = args.debug |
Given the code snippet: <|code_start|>#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--host",
default="0.0.0.0",
help="A host to bind development server. "
"(default 0.0.0.0)")
parser.add_argument("--port",
type=int,
default=5000,
help="A port to bind development server. "
"(default 5000)")
args = config.process_args("CEAGLE",
parser=parser,
<|code_end|>
, generate the next line using the imports in this file:
import argparse
from oss_lib import config
from ceagle import app
from ceagle import config as cfg
and context (functions, classes, or occasionally code) from other files:
# Path: ceagle/app.py
# def versions():
# def not_found(error):
# def handle_unknown_service(ex):
#
# Path: ceagle/config.py
# DEFAULT_CONF_PATH = "/etc/ceagle/config.yaml"
# DEFAULT = {
# "use_fake_api_data": True,
# "services": {},
# }
# SCHEMA = {
# "use_fake_api_data": {"type": "boolean"},
# "services": {
# "type": "object",
# "properties": {
# "availability": {"type": "string"},
# "capacity": {"type": "string"},
# "cis": {"type": "string"},
# "health": {"type": "string"},
# "optimization": {"type": "string"},
# "performance": {"type": "string"},
# "security": {"type": "string"},
# "infra": {
# "type": "object",
# "patternProperties": {
# "\w+": {
# "type": "array",
# "uniqueItems": True,
# "items": {
# "type": "object",
# "properties": {
# "id": {
# "type": "string",
# "minLength": 1,
# },
# "title": {
# "type": "string",
# "minLength": 1,
# },
# "description": {
# "type": "string",
# "minLength": 1,
# },
# "urls": {
# "type": "array",
# "items": {
# "type": "array",
# "items": {
# "type": "string",
# "minLength": 8
# }
# }
# },
# },
# "required": ["id", "title", "description", "urls"],
# "additionalProperties": False,
# },
# },
# }
# }
# },
# "additionalProperties": False,
# },
# }
. Output only the next line. | default_config_path=cfg.DEFAULT_CONF_PATH, |
Based on the snippet: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
class TestCase(testtools.TestCase):
def setUp(self):
super(TestCase, self).setUp()
self.addCleanup(mock.patch.stopall)
<|code_end|>
, predict the immediate next line with the help of imports:
import copy
import json
import mock
import testtools
from oss_lib import config
from ceagle import app
from ceagle import config as cfg
and context (classes, functions, sometimes code) from other files:
# Path: ceagle/app.py
# def versions():
# def not_found(error):
# def handle_unknown_service(ex):
#
# Path: ceagle/config.py
# DEFAULT_CONF_PATH = "/etc/ceagle/config.yaml"
# DEFAULT = {
# "use_fake_api_data": True,
# "services": {},
# }
# SCHEMA = {
# "use_fake_api_data": {"type": "boolean"},
# "services": {
# "type": "object",
# "properties": {
# "availability": {"type": "string"},
# "capacity": {"type": "string"},
# "cis": {"type": "string"},
# "health": {"type": "string"},
# "optimization": {"type": "string"},
# "performance": {"type": "string"},
# "security": {"type": "string"},
# "infra": {
# "type": "object",
# "patternProperties": {
# "\w+": {
# "type": "array",
# "uniqueItems": True,
# "items": {
# "type": "object",
# "properties": {
# "id": {
# "type": "string",
# "minLength": 1,
# },
# "title": {
# "type": "string",
# "minLength": 1,
# },
# "description": {
# "type": "string",
# "minLength": 1,
# },
# "urls": {
# "type": "array",
# "items": {
# "type": "array",
# "items": {
# "type": "string",
# "minLength": 8
# }
# }
# },
# },
# "required": ["id", "title", "description", "urls"],
# "additionalProperties": False,
# },
# },
# }
# }
# },
# "additionalProperties": False,
# },
# }
. Output only the next line. | app.app.config["TESTING"] = True |
Predict the next line for this snippet: <|code_start|># Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
class TestCase(testtools.TestCase):
def setUp(self):
super(TestCase, self).setUp()
self.addCleanup(mock.patch.stopall)
app.app.config["TESTING"] = True
self.app = app.app.test_client()
def mock_config(self, update=None):
patch = mock.patch("oss_lib.config._CONF")
patch.start()
self.addCleanup(patch.stop)
<|code_end|>
with the help of current file imports:
import copy
import json
import mock
import testtools
from oss_lib import config
from ceagle import app
from ceagle import config as cfg
and context from other files:
# Path: ceagle/app.py
# def versions():
# def not_found(error):
# def handle_unknown_service(ex):
#
# Path: ceagle/config.py
# DEFAULT_CONF_PATH = "/etc/ceagle/config.yaml"
# DEFAULT = {
# "use_fake_api_data": True,
# "services": {},
# }
# SCHEMA = {
# "use_fake_api_data": {"type": "boolean"},
# "services": {
# "type": "object",
# "properties": {
# "availability": {"type": "string"},
# "capacity": {"type": "string"},
# "cis": {"type": "string"},
# "health": {"type": "string"},
# "optimization": {"type": "string"},
# "performance": {"type": "string"},
# "security": {"type": "string"},
# "infra": {
# "type": "object",
# "patternProperties": {
# "\w+": {
# "type": "array",
# "uniqueItems": True,
# "items": {
# "type": "object",
# "properties": {
# "id": {
# "type": "string",
# "minLength": 1,
# },
# "title": {
# "type": "string",
# "minLength": 1,
# },
# "description": {
# "type": "string",
# "minLength": 1,
# },
# "urls": {
# "type": "array",
# "items": {
# "type": "array",
# "items": {
# "type": "string",
# "minLength": 8
# }
# }
# },
# },
# "required": ["id", "title", "description", "urls"],
# "additionalProperties": False,
# },
# },
# }
# }
# },
# "additionalProperties": False,
# },
# }
, which may contain function names, class names, or code. Output only the next line. | defaults = copy.deepcopy(cfg.DEFAULT) |
Given the following code snippet before the placeholder: <|code_start|> }
if with_latest_run:
runbook['latest_run'] = get_single_run(False)
return runbook
def get_single_run(with_parent=True):
finished_at = datetime.datetime.now().isoformat()
started_at = (datetime.datetime.now() - datetime.timedelta(
minutes=random.randint(1, 20))).isoformat()
region_choices = [
"region_one", "region_two"
]
run = {
"id": str(random.randint(1, 1000)),
"created_at": started_at,
"updated_at": finished_at,
"user": "cloud_user",
"output": "SGVsbG8gV29ybGQhCg==",
"return_code": 0,
"parent": None,
"region": random.choice(region_choices),
}
if with_parent:
run["parent"] = get_single_runbook(False)
return run
<|code_end|>
, predict the next line using imports from the current file:
import datetime
import random
import flask
from ceagle.api_fake_data import base
and context including class names, function names, and sometimes code from other files:
# Path: ceagle/api_fake_data/base.py
# CONF = config.CONF
# def route(reg):
# def decorator(method):
# def __init__(self, name, endpoint):
# def _setup_routing(self):
# def _find_route(self, path):
# def default(self, path, *args, **kwargs):
# def get(self, path, **kwargs):
# def api_handler(fake):
# def real_function_handler(real):
# def choice_maker(*args, **kwargs):
# def randnum(from_num, to_num, round_by=2):
# class FakeClient(object):
. Output only the next line. | @base.api_handler |
Predict the next line after this snippet: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
CONF = config.CONF
FAKE_CLIENT_MAP = {
"security": security.Client,
}
class UnknownService(Exception):
pass
<|code_end|>
using the current file's imports:
from oss_lib import config
from ceagle.api import base
from ceagle.api_fake_data import security
import requests
and any relevant context from other files:
# Path: ceagle/api/base.py
# class Client(object):
# def __init__(self, name, endpoint):
# def __repr__(self):
#
# Path: ceagle/api_fake_data/security.py
# def _get_fake_issue(region, issue_type, days):
# def _get_issues(region, period):
# def _regions(self, query, api):
# def issues(self, query, region, period):
# def issues_all_regions(self, query, period):
# FAKE_ISSUES = {
# "region1": [
# _get_fake_issue("region1", "IssueType1", 2),
# _get_fake_issue("region1", "IssueType2", 8),
# ],
# "north-2.piedpiper.net": [
# _get_fake_issue("north-2.piedpiper.net", "IssueType1", 0),
# _get_fake_issue("north-2.piedpiper.net", "IssueType2", 2),
# _get_fake_issue("north-2.piedpiper.net", "IssueType2", 8),
# ],
# }
# PERIOD_MAP = {
# "day": 1,
# "week": 7,
# "month": 30,
# }
# REGION_R = r"(?P<region>[a-z\d\-\.\_]+)"
# PERIOD_R = r"(?P<period>day|week|month)"
# class Client(base.FakeClient):
. Output only the next line. | class Client(base.Client): |
Given snippet: <|code_start|>PERIOD_MAP = {
"day": 1,
"week": 7,
"month": 30,
}
REGION_R = r"(?P<region>[a-z\d\-\.\_]+)"
PERIOD_R = r"(?P<period>day|week|month)"
def _get_issues(region, period):
issues = []
if region:
all_issues = FAKE_ISSUES.get(region)
if all_issues is None:
flask.abort(404)
else:
all_issues = sum(FAKE_ISSUES.values(), [])
now = datetime.datetime.now()
try:
discovered_before = (now - datetime.timedelta(
days=PERIOD_MAP[period])).isoformat("T")
except KeyError:
flask.abort(404)
for issue in all_issues:
if issue["discovered_at"] >= discovered_before:
issues.append(issue)
return issues
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import datetime
import flask
from ceagle.api_fake_data import base
and context:
# Path: ceagle/api_fake_data/base.py
# CONF = config.CONF
# def route(reg):
# def decorator(method):
# def __init__(self, name, endpoint):
# def _setup_routing(self):
# def _find_route(self, path):
# def default(self, path, *args, **kwargs):
# def get(self, path, **kwargs):
# def api_handler(fake):
# def real_function_handler(real):
# def choice_maker(*args, **kwargs):
# def randnum(from_num, to_num, round_by=2):
# class FakeClient(object):
which might include code, classes, or functions. Output only the next line. | class Client(base.FakeClient): |
Given the following code snippet before the placeholder: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
class CmdTestCase(test.TestCase):
@mock.patch("ceagle.cmd.argparse.ArgumentParser")
@mock.patch("oss_lib.config.process_args")
@mock.patch("ceagle.cmd.app.app")
def test_main(self, mock_app, mock_process, mock_parser):
mock_process.return_value.configure_mock(
host="10.0.0.2",
port=80,
debug=False,
)
<|code_end|>
, predict the next line using imports from the current file:
import mock
from ceagle import cmd
from tests.unit import test
and context including class names, function names, and sometimes code from other files:
# Path: ceagle/cmd.py
# def main():
#
# Path: tests/unit/test.py
# class TestCase(testtools.TestCase):
# def setUp(self):
# def mock_config(self, update=None):
# def post(self, *args, **kwargs):
# def put(self, *args, **kwargs):
# def delete(self, *args, **kwargs):
# def get(self, *args, **kwargs):
. Output only the next line. | cmd.main() |
Given the code snippet: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
class ModuleTestCase(test.TestCase):
def test_api_handler_fake(self):
self.mock_config({"use_fake_api_data": True})
fake = lambda: "fake"
real = lambda: "real"
<|code_end|>
, generate the next line using the imports in this file:
import mock
from ceagle.api_fake_data import base
from tests.unit import test
and context (functions, classes, or occasionally code) from other files:
# Path: ceagle/api_fake_data/base.py
# CONF = config.CONF
# def route(reg):
# def decorator(method):
# def __init__(self, name, endpoint):
# def _setup_routing(self):
# def _find_route(self, path):
# def default(self, path, *args, **kwargs):
# def get(self, path, **kwargs):
# def api_handler(fake):
# def real_function_handler(real):
# def choice_maker(*args, **kwargs):
# def randnum(from_num, to_num, round_by=2):
# class FakeClient(object):
#
# Path: tests/unit/test.py
# class TestCase(testtools.TestCase):
# def setUp(self):
# def mock_config(self, update=None):
# def post(self, *args, **kwargs):
# def put(self, *args, **kwargs):
# def delete(self, *args, **kwargs):
# def get(self, *args, **kwargs):
. Output only the next line. | self.assertEqual("fake", base.api_handler(fake)(real)()) |
Predict the next line for this snippet: <|code_start|># not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
CONF = config.CONF
bp_status = flask.Blueprint("status", __name__)
bp_region_status = flask.Blueprint("region", __name__)
def get_status_helper(period, region=None):
result = {}
key_map = {
"health": {"key": "health", "arg": "fci"},
"availability": {"key": "availability", "arg": "availability"}
}
for service_name in ["health", "availability"]:
if service_name not in CONF["services"]:
continue
<|code_end|>
with the help of current file imports:
import flask
from oss_lib import config
from ceagle.api import client
from ceagle.api_fake_data import fake_status
and context from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api_fake_data/fake_status.py
# RESPONSE_TOTAL_NULL_PROBABILITY = 10
# HEALTH_NULL_PROBABILITY = 5
# PERFORMANCE_NULL_PROBABILITY = 5
# AVAILABILITY_NULL_PROBABILITY = 5
# STATUS_NULL_PROBABILITY = 20
# def validate_period(period):
# def generate_timestamps(period):
# def lucky(probability):
# def generate_values(period_or_timestamps,
# ratio=1, null_probability=20, integer=False):
# def generate_service_data(period, service, null_allowed):
# def generate_region_data(region, period, service, null_allowed):
# def generate_status_data(period, service):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
, which may contain function names, class names, or code. Output only the next line. | service_client = client.get_client(service_name) |
Given the code snippet: <|code_start|> key_map = {
"health": {"key": "health", "arg": "fci"},
"availability": {"key": "availability", "arg": "availability"}
}
for service_name in ["health", "availability"]:
if service_name not in CONF["services"]:
continue
service_client = client.get_client(service_name)
if region:
uri = "/api/v1/region/%s/%s/%s" % (region, service_name, period)
else:
uri = "/api/v1/%s/%s" % (service_name, period)
resp, code = service_client.get(uri)
if code != 200:
# FIXME ADD LOGS HERE
continue
for r, value in resp[key_map[service_name]["key"]].items():
result.setdefault(r, {"sla": None, "availability": None,
"health": None, "performance": None})
result[r][service_name] = value[key_map[service_name]["arg"]]
return {"period": period, "status": result}
@bp_status.route("/<period>")
<|code_end|>
, generate the next line using the imports in this file:
import flask
from oss_lib import config
from ceagle.api import client
from ceagle.api_fake_data import fake_status
and context (functions, classes, or occasionally code) from other files:
# Path: ceagle/api/client.py
# CONF = config.CONF
# FAKE_CLIENT_MAP = {
# "security": security.Client,
# }
# class UnknownService(Exception):
# class Client(base.Client):
# def get(self, uri="/", **kwargs):
# def get_client(service_name):
#
# Path: ceagle/api_fake_data/fake_status.py
# RESPONSE_TOTAL_NULL_PROBABILITY = 10
# HEALTH_NULL_PROBABILITY = 5
# PERFORMANCE_NULL_PROBABILITY = 5
# AVAILABILITY_NULL_PROBABILITY = 5
# STATUS_NULL_PROBABILITY = 20
# def validate_period(period):
# def generate_timestamps(period):
# def lucky(probability):
# def generate_values(period_or_timestamps,
# ratio=1, null_probability=20, integer=False):
# def generate_service_data(period, service, null_allowed):
# def generate_region_data(region, period, service, null_allowed):
# def generate_status_data(period, service):
# def get_status(period):
# def get_status_health(period):
# def get_status_performance(period):
# def get_status_availability(period):
# def get_region_status(region, period):
# def get_region_status_health(region, period):
# def get_region_status_performance(region, period):
# def get_region_status_availability(region, period):
. Output only the next line. | @fake_status.get_status |
Next line prediction: <|code_start|> stamps.append("%sT%.2i:00" % (day, hour))
return stamps
def lucky(probability):
"""Return a boolean status with given probability.
:param probability: int <= 100,
0 will always cause False result
:rtype: bool
"""
if probability:
return random.randint(1, 100) <= probability
return False
def generate_values(period_or_timestamps,
ratio=1, null_probability=20, integer=False):
if type(period_or_timestamps) == list:
timestamps = period_or_timestamps
else:
timestamps = generate_timestamps(period_or_timestamps)
if timestamps:
data = []
data_avg = []
for ts in timestamps:
if lucky(null_probability):
data.append([ts, None])
else:
if not integer:
<|code_end|>
. Use current file imports:
(import datetime
import random
import flask
from ceagle.api_fake_data import base
from ceagle.api_fake_data import fake_regions)
and context including class names, function names, or small code snippets from other files:
# Path: ceagle/api_fake_data/base.py
# CONF = config.CONF
# def route(reg):
# def decorator(method):
# def __init__(self, name, endpoint):
# def _setup_routing(self):
# def _find_route(self, path):
# def default(self, path, *args, **kwargs):
# def get(self, path, **kwargs):
# def api_handler(fake):
# def real_function_handler(real):
# def choice_maker(*args, **kwargs):
# def randnum(from_num, to_num, round_by=2):
# class FakeClient(object):
#
# Path: ceagle/api_fake_data/fake_regions.py
# REGIONS_NUM = 4
# def regions(detailed=False):
# def get_regions(detailed):
. Output only the next line. | value = base.randnum(.7, 1) * ratio |
Based on the snippet: <|code_start|>
fci_data = generate_values(period, 1, null_probability)[0]
time_data = generate_values(period, 1, null_probability)[0]
size_data = generate_values(
period, 50, null_probability, integer=True)[0]
count_data = generate_values(
period, 50, null_probability, integer=True)[0]
return {
"fci": random.randint(0, 100) * 0.01,
"response_time": base.randnum(.1, 2.5),
"response_size": random.randint(2000, 5000),
"api_calls_count": random.randint(200, 500),
"fci_data": fci_data,
"response_time_data": time_data,
"response_size_data": size_data,
"api_calls_count_data": count_data
}
elif service == "performance":
null_probability = null_allowed and PERFORMANCE_NULL_PROBABILITY or 0
data, avg = generate_values(period, 1, null_probability)
return {"data": data, "duration": avg}
elif service == "availability":
null_probability = null_allowed and AVAILABILITY_NULL_PROBABILITY or 0
data, avg = generate_values(period, 1, null_probability)
return {"availability_data": data, "availability": avg}
def generate_region_data(region, period, service, null_allowed):
<|code_end|>
, predict the immediate next line with the help of imports:
import datetime
import random
import flask
from ceagle.api_fake_data import base
from ceagle.api_fake_data import fake_regions
and context (classes, functions, sometimes code) from other files:
# Path: ceagle/api_fake_data/base.py
# CONF = config.CONF
# def route(reg):
# def decorator(method):
# def __init__(self, name, endpoint):
# def _setup_routing(self):
# def _find_route(self, path):
# def default(self, path, *args, **kwargs):
# def get(self, path, **kwargs):
# def api_handler(fake):
# def real_function_handler(real):
# def choice_maker(*args, **kwargs):
# def randnum(from_num, to_num, round_by=2):
# class FakeClient(object):
#
# Path: ceagle/api_fake_data/fake_regions.py
# REGIONS_NUM = 4
# def regions(detailed=False):
# def get_regions(detailed):
. Output only the next line. | data = fake_regions.regions(detailed=True).get(region) |
Here is a snippet: <|code_start|># under the License.
REGIONS_NUM = 4
def regions(detailed=False):
"""Generate fake regions."""
tpl = itertools.cycle(["west-%i.hooli.net", "north-%i.piedpiper.net",
"east-%i.hooli.net", "south-%i.piedpiper.net"])
idx = itertools.count(1)
srv = itertools.cycle([
["health", "performance", "cis"],
["health", "availability", "performance", "cis", "security"],
["health"]])
result = {} if detailed else []
for i in range(REGIONS_NUM):
region = next(tpl) % next(idx)
if detailed:
result[region] = {"services": next(srv)}
else:
result.append(region)
return result
<|code_end|>
. Write the next line using the current file imports:
import itertools
import flask
from ceagle.api_fake_data import base
and context from other files:
# Path: ceagle/api_fake_data/base.py
# CONF = config.CONF
# def route(reg):
# def decorator(method):
# def __init__(self, name, endpoint):
# def _setup_routing(self):
# def _find_route(self, path):
# def default(self, path, *args, **kwargs):
# def get(self, path, **kwargs):
# def api_handler(fake):
# def real_function_handler(real):
# def choice_maker(*args, **kwargs):
# def randnum(from_num, to_num, round_by=2):
# class FakeClient(object):
, which may include functions, classes, or code. Output only the next line. | @base.api_handler |
Predict the next line for this snippet: <|code_start|># Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
bp = flask.Blueprint("runbooks", __name__)
@bp.route("/runbooks", methods=["GET"])
@bp.route("/region/<region>/runbooks",
methods=["GET", "POST"])
<|code_end|>
with the help of current file imports:
import flask
from ceagle.api_fake_data import fake_runbooks
and context from other files:
# Path: ceagle/api_fake_data/fake_runbooks.py
# def get_single_runbook(with_latest_run=True):
# def get_single_run(with_parent=True):
# def handle_runbooks(region=None):
# def handle_single_runbook(region, book_id):
# def run_runbook(region, book_id):
# def runbook_runs(region=None):
# def single_runbook_run(region, run_id):
, which may contain function names, class names, or code. Output only the next line. | @fake_runbooks.handle_runbooks |
Next line prediction: <|code_start|> """
is_file = os.path.isfile(notebook_or_folder)
is_dir = os.path.isdir(notebook_or_folder)
if not (is_file or is_dir):
raise ValueError(
'{} is neither an existing file nor a folder.'
.format(notebook_or_folder)
)
if is_file:
return [notebook_or_folder]
# Now we know the input is a directory
if not recursive:
return glob('{}/*.ipynb'.format(notebook_or_folder))
# Recursive case
return [
os.path.join(folder, filename)
for folder, _, filenames in os.walk(notebook_or_folder)
# Skip folders that start with .
if not os.path.basename(folder).startswith('.')
for filename in fnmatch.filter(filenames, '*.ipynb')
]
def init_exporter(extract_images, execute, **exporter_config):
"""
Returns an initialized exporter.
"""
<|code_end|>
. Use current file imports:
(from docopt import docopt, DocoptExit
from glob import glob
from textwrap import wrap
from collections import defaultdict
from traitlets.config import Config
from .exporters import InteractExporter
import os
import re
import sys
import subprocess
import json
import fnmatch
import nbformat)
and context including class names, function names, or small code snippets from other files:
# Path: nbinteract/exporters.py
# class InteractExporter(HTMLExporter):
# """
# nbconvert Exporter that converts a notebook to an HTML page with widgets
# enabled.
# """
# spec = Unicode(
# 'SamLau95/nbinteract-image/master',
# help='BinderHub spec for Jupyter image.'
# ).tag(config=True)
#
# base_url = Unicode(
# 'https://mybinder.org', help='Base Binder URL.'
# ).tag(config=True)
#
# provider = Unicode('gh', help='BinderHub provider.').tag(config=True)
#
# button_at_top = Bool(
# True, 'If False, only widget cell buttons are generated.'
# ).tag(config=True)
#
# def __init__(self, config=None, **kw):
# """
# Public constructor
#
# Kwargs:
# config (traitlets.Config): User configuration instance.
#
# spec (str): BinderHub spec for Jupyter image. Must be in the
# format: `${username}/${repo}/${branch}` or
# `${username}/${repo}`, in which case `branch` defaults to
# `main`. Defaults to 'SamLau95/nbinteract-image/master'.
#
# base_url (str): Base Binder URL. Defaults to
# 'https://mybinder.org'.
#
# provider (str): BinderHub provider. Defaults to 'gh' for GitHub.
#
# template_file (str):
# Template to use when exporting. Valid templates:
#
# 'full': Outputs a complete standalone HTML page with default
# styling. Automatically loads the nbinteract JS library.
#
# 'local': Like 'full', but uses a local copy of the JS package
# instead of the live one. Used for development only.
#
# 'partial': Outputs an HTML partial that can be embedded in
# another page. Automatically loads the nbinteract JS library.
#
# 'plain': Outputs an HTML partial to embed in another page. The
# partial does not include the nbinteract JS library; the
# embedding page must load and initialize the nbinteract JS
# library itself.
#
# button_at_top (bool): If True (default), generates a button to
# start widgets at the top of the notebook as well as one button
# per widget cell. If False, only widget cell buttons are
# generated.
#
# extra_loaders (list[Jinja Loader]): ordered list of Jinja loader to
# find templates. Will be tried in order before the default
# FileSystem ones.
# """
# # nbconvert 6 expects the full path for 5.x style .tpl files
# if 'template_file' in kw:
# kw['template_file'] = os.path.join(
# os.path.dirname(__file__), 'templates',
# kw['template_file'] + '.tpl')
# if config is not None:
# if config.InteractExporter.has_key('template_file'):
# config.InteractExporter.template_file = os.path.join(
# os.path.dirname(__file__), 'templates',
# config.InteractExporter.template_file + '.tpl')
#
# super(InteractExporter, self).__init__(config=config, **kw)
#
# # Set variables that will be available in the template
# self.environment.globals['spec'] = self.spec
# self.environment.globals['base_url'] = self.base_url
# self.environment.globals['provider'] = self.provider
# self.environment.globals['button_at_top'] = self.button_at_top
#
# @default('template_file')
# def _template_file_default(self):
# return os.path.join(
# os.path.dirname(__file__), 'templates', 'full.tpl')
#
# @validate('spec')
# def _valid_spec(self, proposal):
# spec = proposal['value']
# spec_parts = len(spec.split(SPEC_DIVIDER))
# if spec_parts == 3:
# return spec
# elif spec_parts == 2:
# return spec + '/main'
# else:
# raise TraitError(
# 'spec must contain two or three components but only got '
# '{} (original spec: {})'.format(spec_parts, spec)
# )
. Output only the next line. | config = Config(InteractExporter=exporter_config) |
Next line prediction: <|code_start|> * (weight_k * drk + weight_j * drj)
/ (dens_mu[i] * dens_re_std)
/ n_vertices
)
if dist_squared > 0.0:
grad_coeff = -2.0 * a * b * pow(dist_squared, b - 1.0)
grad_coeff /= a * pow(dist_squared, b) + 1.0
else:
grad_coeff = 0.0
for d in range(dim):
grad_d = clip(grad_coeff * (current[d] - other[d]))
if densmap_flag:
# FIXME: grad_cor_coeff might be referenced before assignment
grad_d += clip(2 * grad_cor_coeff * (current[d] - other[d]))
current[d] += grad_d * alpha
if move_other:
other[d] += -grad_d * alpha
epoch_of_next_sample[i] += epochs_per_sample[i]
n_neg_samples = int(
(n - epoch_of_next_negative_sample[i]) / epochs_per_negative_sample[i]
)
for p in range(n_neg_samples):
<|code_end|>
. Use current file imports:
(import numpy as np
import numba
import umap.distances as dist
from umap.utils import tau_rand_int
from tqdm.auto import tqdm)
and context including class names, function names, or small code snippets from other files:
# Path: umap/utils.py
# @numba.njit("i4(i8[:])")
# def tau_rand_int(state):
# """A fast (pseudo)-random number generator.
#
# Parameters
# ----------
# state: array of int64, shape (3,)
# The internal state of the rng
#
# Returns
# -------
# A (pseudo)-random int32 value
# """
# state[0] = (((state[0] & 4294967294) << 12) & 0xFFFFFFFF) ^ (
# (((state[0] << 13) & 0xFFFFFFFF) ^ state[0]) >> 19
# )
# state[1] = (((state[1] & 4294967288) << 4) & 0xFFFFFFFF) ^ (
# (((state[1] << 2) & 0xFFFFFFFF) ^ state[1]) >> 25
# )
# state[2] = (((state[2] & 4294967280) << 17) & 0xFFFFFFFF) ^ (
# (((state[2] << 3) & 0xFFFFFFFF) ^ state[2]) >> 11
# )
#
# return state[0] ^ state[1] ^ state[2]
. Output only the next line. | k = tau_rand_int(rng_state) % n_vertices |
Here is a snippet: <|code_start|> return 0.0
else:
return float(n_features - num_true_true) / (n_features)
@numba.njit()
def sparse_sokal_michener(ind1, data1, ind2, data2, n_features):
num_true_true = arr_intersect(ind1, ind2).shape[0]
num_non_zero = arr_union(ind1, ind2).shape[0]
num_not_equal = num_non_zero - num_true_true
return (2.0 * num_not_equal) / (n_features + num_not_equal)
@numba.njit()
def sparse_sokal_sneath(ind1, data1, ind2, data2):
num_true_true = arr_intersect(ind1, ind2).shape[0]
num_non_zero = arr_union(ind1, ind2).shape[0]
num_not_equal = num_non_zero - num_true_true
if num_not_equal == 0.0:
return 0.0
else:
return num_not_equal / (0.5 * num_true_true + num_not_equal)
@numba.njit()
def sparse_cosine(ind1, data1, ind2, data2):
aux_inds, aux_data = sparse_mul(ind1, data1, ind2, data2)
result = 0.0
<|code_end|>
. Write the next line using the current file imports:
import locale
import numba
import numpy as np
from umap.utils import norm
and context from other files:
# Path: umap/utils.py
# @numba.njit()
# def norm(vec):
# """Compute the (standard l2) norm of a vector.
#
# Parameters
# ----------
# vec: array of shape (dim,)
#
# Returns
# -------
# The l2 norm of vec.
# """
# result = 0.0
# for i in range(vec.shape[0]):
# result += vec[i] ** 2
# return np.sqrt(result)
, which may include functions, classes, or code. Output only the next line. | norm1 = norm(data1) |
Given the following code snippet before the placeholder: <|code_start|> linkage = metric_kwds.get("linkage", "average")
if linkage == "average":
linkage = np.mean
elif linkage == "complete":
linkage = np.max
elif linkage == "single":
linkage = np.min
else:
raise ValueError(
"Unrecognized linkage '%s'. Please choose from "
"'average', 'complete', or 'single'" % linkage
)
for c_i in range(n_components):
dm_i = data[component_labels == c_i]
for c_j in range(c_i + 1, n_components):
dist = linkage(dm_i[:, component_labels == c_j])
distance_matrix[c_i, c_j] = dist
distance_matrix[c_j, c_i] = dist
else:
for label in range(n_components):
component_centroids[label] = data[component_labels == label].mean(axis=0)
if scipy.sparse.isspmatrix(component_centroids):
warn(
"Forcing component centroids to dense; if you are running out of "
"memory then consider increasing n_neighbors."
)
component_centroids = component_centroids.toarray()
if metric in SPECIAL_METRICS:
<|code_end|>
, predict the next line using imports from the current file:
from warnings import warn
from sklearn.manifold import SpectralEmbedding
from sklearn.metrics import pairwise_distances
from sklearn.metrics.pairwise import _VALID_METRICS as SKLEARN_PAIRWISE_VALID_METRICS
from umap.distances import pairwise_special_metric, SPECIAL_METRICS
from umap.sparse import SPARSE_SPECIAL_METRICS, sparse_named_distances
import numpy as np
import scipy.sparse
import scipy.sparse.csgraph
and context including class names, function names, and sometimes code from other files:
# Path: umap/distances.py
# def pairwise_special_metric(X, Y=None, metric="hellinger", kwds=None):
# if callable(metric):
# if kwds is not None:
# kwd_vals = tuple(kwds.values())
# else:
# kwd_vals = ()
#
# @numba.njit(fastmath=True)
# def _partial_metric(_X, _Y=None):
# return metric(_X, _Y, *kwd_vals)
#
# return pairwise_distances(X, Y, metric=_partial_metric)
# else:
# special_metric_func = named_distances[metric]
# return parallel_special_metric(X, Y, metric=special_metric_func)
#
# SPECIAL_METRICS = (
# "hellinger",
# "ll_dirichlet",
# "symmetric_kl",
# "poincare",
# hellinger,
# ll_dirichlet,
# symmetric_kl,
# poincare,
# )
#
# Path: umap/sparse.py
# def arr_unique(arr):
# def arr_union(ar1, ar2):
# def arr_intersect(ar1, ar2):
# def sparse_sum(ind1, data1, ind2, data2):
# def sparse_diff(ind1, data1, ind2, data2):
# def sparse_mul(ind1, data1, ind2, data2):
# def general_sset_intersection(
# indptr1,
# indices1,
# data1,
# indptr2,
# indices2,
# data2,
# result_row,
# result_col,
# result_val,
# right_complement=False,
# mix_weight=0.5,
# ):
# def general_sset_union(
# indptr1,
# indices1,
# data1,
# indptr2,
# indices2,
# data2,
# result_row,
# result_col,
# result_val,
# ):
# def sparse_euclidean(ind1, data1, ind2, data2):
# def sparse_manhattan(ind1, data1, ind2, data2):
# def sparse_chebyshev(ind1, data1, ind2, data2):
# def sparse_minkowski(ind1, data1, ind2, data2, p=2.0):
# def sparse_hamming(ind1, data1, ind2, data2, n_features):
# def sparse_canberra(ind1, data1, ind2, data2):
# def sparse_bray_curtis(ind1, data1, ind2, data2): # pragma: no cover
# def sparse_jaccard(ind1, data1, ind2, data2):
# def sparse_matching(ind1, data1, ind2, data2, n_features):
# def sparse_dice(ind1, data1, ind2, data2):
# def sparse_kulsinski(ind1, data1, ind2, data2, n_features):
# def sparse_rogers_tanimoto(ind1, data1, ind2, data2, n_features):
# def sparse_russellrao(ind1, data1, ind2, data2, n_features):
# def sparse_sokal_michener(ind1, data1, ind2, data2, n_features):
# def sparse_sokal_sneath(ind1, data1, ind2, data2):
# def sparse_cosine(ind1, data1, ind2, data2):
# def sparse_hellinger(ind1, data1, ind2, data2):
# def sparse_correlation(ind1, data1, ind2, data2, n_features):
# def approx_log_Gamma(x):
# def log_beta(x, y):
# def log_single_beta(x):
# def sparse_ll_dirichlet(ind1, data1, ind2, data2):
# SPARSE_SPECIAL_METRICS = {
# sparse_hellinger: "hellinger",
# sparse_ll_dirichlet: "ll_dirichlet",
# }
. Output only the next line. | distance_matrix = pairwise_special_metric( |
Given the following code snippet before the placeholder: <|code_start|> distance_matrix = np.zeros((n_components, n_components), dtype=np.float64)
linkage = metric_kwds.get("linkage", "average")
if linkage == "average":
linkage = np.mean
elif linkage == "complete":
linkage = np.max
elif linkage == "single":
linkage = np.min
else:
raise ValueError(
"Unrecognized linkage '%s'. Please choose from "
"'average', 'complete', or 'single'" % linkage
)
for c_i in range(n_components):
dm_i = data[component_labels == c_i]
for c_j in range(c_i + 1, n_components):
dist = linkage(dm_i[:, component_labels == c_j])
distance_matrix[c_i, c_j] = dist
distance_matrix[c_j, c_i] = dist
else:
for label in range(n_components):
component_centroids[label] = data[component_labels == label].mean(axis=0)
if scipy.sparse.isspmatrix(component_centroids):
warn(
"Forcing component centroids to dense; if you are running out of "
"memory then consider increasing n_neighbors."
)
component_centroids = component_centroids.toarray()
<|code_end|>
, predict the next line using imports from the current file:
from warnings import warn
from sklearn.manifold import SpectralEmbedding
from sklearn.metrics import pairwise_distances
from sklearn.metrics.pairwise import _VALID_METRICS as SKLEARN_PAIRWISE_VALID_METRICS
from umap.distances import pairwise_special_metric, SPECIAL_METRICS
from umap.sparse import SPARSE_SPECIAL_METRICS, sparse_named_distances
import numpy as np
import scipy.sparse
import scipy.sparse.csgraph
and context including class names, function names, and sometimes code from other files:
# Path: umap/distances.py
# def pairwise_special_metric(X, Y=None, metric="hellinger", kwds=None):
# if callable(metric):
# if kwds is not None:
# kwd_vals = tuple(kwds.values())
# else:
# kwd_vals = ()
#
# @numba.njit(fastmath=True)
# def _partial_metric(_X, _Y=None):
# return metric(_X, _Y, *kwd_vals)
#
# return pairwise_distances(X, Y, metric=_partial_metric)
# else:
# special_metric_func = named_distances[metric]
# return parallel_special_metric(X, Y, metric=special_metric_func)
#
# SPECIAL_METRICS = (
# "hellinger",
# "ll_dirichlet",
# "symmetric_kl",
# "poincare",
# hellinger,
# ll_dirichlet,
# symmetric_kl,
# poincare,
# )
#
# Path: umap/sparse.py
# def arr_unique(arr):
# def arr_union(ar1, ar2):
# def arr_intersect(ar1, ar2):
# def sparse_sum(ind1, data1, ind2, data2):
# def sparse_diff(ind1, data1, ind2, data2):
# def sparse_mul(ind1, data1, ind2, data2):
# def general_sset_intersection(
# indptr1,
# indices1,
# data1,
# indptr2,
# indices2,
# data2,
# result_row,
# result_col,
# result_val,
# right_complement=False,
# mix_weight=0.5,
# ):
# def general_sset_union(
# indptr1,
# indices1,
# data1,
# indptr2,
# indices2,
# data2,
# result_row,
# result_col,
# result_val,
# ):
# def sparse_euclidean(ind1, data1, ind2, data2):
# def sparse_manhattan(ind1, data1, ind2, data2):
# def sparse_chebyshev(ind1, data1, ind2, data2):
# def sparse_minkowski(ind1, data1, ind2, data2, p=2.0):
# def sparse_hamming(ind1, data1, ind2, data2, n_features):
# def sparse_canberra(ind1, data1, ind2, data2):
# def sparse_bray_curtis(ind1, data1, ind2, data2): # pragma: no cover
# def sparse_jaccard(ind1, data1, ind2, data2):
# def sparse_matching(ind1, data1, ind2, data2, n_features):
# def sparse_dice(ind1, data1, ind2, data2):
# def sparse_kulsinski(ind1, data1, ind2, data2, n_features):
# def sparse_rogers_tanimoto(ind1, data1, ind2, data2, n_features):
# def sparse_russellrao(ind1, data1, ind2, data2, n_features):
# def sparse_sokal_michener(ind1, data1, ind2, data2, n_features):
# def sparse_sokal_sneath(ind1, data1, ind2, data2):
# def sparse_cosine(ind1, data1, ind2, data2):
# def sparse_hellinger(ind1, data1, ind2, data2):
# def sparse_correlation(ind1, data1, ind2, data2, n_features):
# def approx_log_Gamma(x):
# def log_beta(x, y):
# def log_single_beta(x):
# def sparse_ll_dirichlet(ind1, data1, ind2, data2):
# SPARSE_SPECIAL_METRICS = {
# sparse_hellinger: "hellinger",
# sparse_ll_dirichlet: "ll_dirichlet",
# }
. Output only the next line. | if metric in SPECIAL_METRICS: |
Predict the next line for this snippet: <|code_start|> elif linkage == "single":
linkage = np.min
else:
raise ValueError(
"Unrecognized linkage '%s'. Please choose from "
"'average', 'complete', or 'single'" % linkage
)
for c_i in range(n_components):
dm_i = data[component_labels == c_i]
for c_j in range(c_i + 1, n_components):
dist = linkage(dm_i[:, component_labels == c_j])
distance_matrix[c_i, c_j] = dist
distance_matrix[c_j, c_i] = dist
else:
for label in range(n_components):
component_centroids[label] = data[component_labels == label].mean(axis=0)
if scipy.sparse.isspmatrix(component_centroids):
warn(
"Forcing component centroids to dense; if you are running out of "
"memory then consider increasing n_neighbors."
)
component_centroids = component_centroids.toarray()
if metric in SPECIAL_METRICS:
distance_matrix = pairwise_special_metric(
component_centroids,
metric=metric,
kwds=metric_kwds,
)
<|code_end|>
with the help of current file imports:
from warnings import warn
from sklearn.manifold import SpectralEmbedding
from sklearn.metrics import pairwise_distances
from sklearn.metrics.pairwise import _VALID_METRICS as SKLEARN_PAIRWISE_VALID_METRICS
from umap.distances import pairwise_special_metric, SPECIAL_METRICS
from umap.sparse import SPARSE_SPECIAL_METRICS, sparse_named_distances
import numpy as np
import scipy.sparse
import scipy.sparse.csgraph
and context from other files:
# Path: umap/distances.py
# def pairwise_special_metric(X, Y=None, metric="hellinger", kwds=None):
# if callable(metric):
# if kwds is not None:
# kwd_vals = tuple(kwds.values())
# else:
# kwd_vals = ()
#
# @numba.njit(fastmath=True)
# def _partial_metric(_X, _Y=None):
# return metric(_X, _Y, *kwd_vals)
#
# return pairwise_distances(X, Y, metric=_partial_metric)
# else:
# special_metric_func = named_distances[metric]
# return parallel_special_metric(X, Y, metric=special_metric_func)
#
# SPECIAL_METRICS = (
# "hellinger",
# "ll_dirichlet",
# "symmetric_kl",
# "poincare",
# hellinger,
# ll_dirichlet,
# symmetric_kl,
# poincare,
# )
#
# Path: umap/sparse.py
# def arr_unique(arr):
# def arr_union(ar1, ar2):
# def arr_intersect(ar1, ar2):
# def sparse_sum(ind1, data1, ind2, data2):
# def sparse_diff(ind1, data1, ind2, data2):
# def sparse_mul(ind1, data1, ind2, data2):
# def general_sset_intersection(
# indptr1,
# indices1,
# data1,
# indptr2,
# indices2,
# data2,
# result_row,
# result_col,
# result_val,
# right_complement=False,
# mix_weight=0.5,
# ):
# def general_sset_union(
# indptr1,
# indices1,
# data1,
# indptr2,
# indices2,
# data2,
# result_row,
# result_col,
# result_val,
# ):
# def sparse_euclidean(ind1, data1, ind2, data2):
# def sparse_manhattan(ind1, data1, ind2, data2):
# def sparse_chebyshev(ind1, data1, ind2, data2):
# def sparse_minkowski(ind1, data1, ind2, data2, p=2.0):
# def sparse_hamming(ind1, data1, ind2, data2, n_features):
# def sparse_canberra(ind1, data1, ind2, data2):
# def sparse_bray_curtis(ind1, data1, ind2, data2): # pragma: no cover
# def sparse_jaccard(ind1, data1, ind2, data2):
# def sparse_matching(ind1, data1, ind2, data2, n_features):
# def sparse_dice(ind1, data1, ind2, data2):
# def sparse_kulsinski(ind1, data1, ind2, data2, n_features):
# def sparse_rogers_tanimoto(ind1, data1, ind2, data2, n_features):
# def sparse_russellrao(ind1, data1, ind2, data2, n_features):
# def sparse_sokal_michener(ind1, data1, ind2, data2, n_features):
# def sparse_sokal_sneath(ind1, data1, ind2, data2):
# def sparse_cosine(ind1, data1, ind2, data2):
# def sparse_hellinger(ind1, data1, ind2, data2):
# def sparse_correlation(ind1, data1, ind2, data2, n_features):
# def approx_log_Gamma(x):
# def log_beta(x, y):
# def log_single_beta(x):
# def sparse_ll_dirichlet(ind1, data1, ind2, data2):
# SPARSE_SPECIAL_METRICS = {
# sparse_hellinger: "hellinger",
# sparse_ll_dirichlet: "ll_dirichlet",
# }
, which may contain function names, class names, or code. Output only the next line. | elif metric in SPARSE_SPECIAL_METRICS: |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.