def search_job_by_deadline(jobs,start,end,cursor1,cursor2): cursor1.execute(""" select a.Workno, g.GoodNo, g.GoodCd, i.GoodCd as 'RawMaterialCd', m4.Minorcd, a.OrderQty , a.DeliveryDate, --case when i.Class3 = '061038' then '단조' else 'HEX' end as Gubun, case when m3.minorNm = 'Forging' then 0 when m3.minorNm = 'Hex Bar' then 1 when m3.minorNm = 'Round Bar' then 2 when m3.MinorNm = 'Square Bar' then 3 when m3.MinorNm = 'VALVE 선작업' then 4 end as RawMaterialGubun, -- 소재사이즈 ISNULL(i.Size, 0) as RawMaterialSize, -- LOK FITTING 유무 case when g.Class3 = '061001' then 'Y' else 'N' end as LOKFITTINGYN, --LOK FITTING -- LOK FITTING 일때 반제품 품번 사이즈에 따른 기계배정 case when g.Class3 = '061001' and ((LEFT(REPLACE(g.GoodNo, RTRIM(m4.MinorNm),''),3) = '-1-') or (LEFT(REPLACE(g.GoodNo, RTRIM(m4.MinorNm),''),3) = '-2-') or (LEFT(REPLACE(g.GoodNo, RTRIM(m4.MinorNm),''),3) = '-3-') or (LEFT(REPLACE(g.GoodNo, RTRIM(m4.MinorNm),''),4) = '-2M-') or (LEFT(REPLACE(g.GoodNo, RTRIM(m4.MinorNm),''),4) = '-3M-') or (LEFT(REPLACE(g.GoodNo, RTRIM(m4.MinorNm),''),4) = '-4M-')) then 'Y' else 'N' end as LOKFITTINGSIZEYN, a.CloseDate, a.Credate, a.Moddate from TWorkreport_Han_Eng a inner join TGood g on a.Goodcd = g.GoodCd inner join TGood i on a.Raw_Materialcd = i.GoodCd left outer join TMinor m3 on i.Class3 = m3.MinorCd left outer join TMinor m4 on g.Class4 = m4.MinorCd where DeliveryDate between '20190101' and '20190131' and PmsYn = 'N' and ContractYn = '1' -- 단조 Hex Bar Round Bar Square Bar VALVE 선작업 and i.Class3 in ('061038', '061039', '061040', '061048', '061126') order by DeliveryDate """) row = cursor1.fetchone() while row: temp = Job.Job() temp2 = Job.Job() temp.setWorkNo(row[0]) temp.setGoodNo(row[1]) temp.setGoodCd(row[2]) goodcd = row[2] temp.setRawmaterialCd(row[3]) temp.setOrderQty(row[5]) temp.setDeliveryDate(row[6]) temp.setRawmaterialGubun(row[7]) temp.setSpec(row[8]) temp.setLOKFitting(row[9]) temp.setLOKFittingSize(row[10]) temp.setCycletime(search_cycle_time(cursor2, goodcd)) if(len(temp.getCycletime()) ==0): row = cursor1.fetchone() else: jobs.append(temp) row = cursor1.fetchone() total_number = len(jobs) print("the total # of job : %d"%(total_number))
def prepare_jobs(self): self.jobs = list() if self.single_file_list: if not os.path.isfile(self.single_file_list): raise FileNotFoundError("Couldn't find the bed file list ", self.single_file_list) command = '{executable} -i {bed_file_list} -o {merged_bed_file}'.\ format(executable = self.executable , bed_file_list = self.single_file_list, merged_bed_file = self.bp_candidates_bed_file ) job = Job.Job(command=command, output_directory=self.cluster_out_directory, job_name="final_bed_merge", time_limit=120, cores=1, memory=4096) self.jobs.append(job) return 0 for directory in self.input_files: output_directory = os.path.join(self.output_directory, os.path.basename(directory)) os.makedirs(output_directory, exist_ok=True) lib_bp_bed_files_list = os.path.join( directory, "candidate_bp_files_list.txt") merged_bed_file = os.path.join(output_directory, 'candidate_branchpoints.bed') self.list_of_merged_files.append(merged_bed_file) if not os.path.isfile(lib_bp_bed_files_list): raise FileNotFoundError("Could not find the bed file list", lib_bp_bed_files_list) command = '{executable} -i {bed_file_list} -o {merged_bed_file}'.\ format(executable = self.executable , bed_file_list = lib_bp_bed_files_list, merged_bed_file = merged_bed_file ) job = Job.Job(command=command, output_directory=self.cluster_out_directory, job_name=os.path.basename(directory), time_limit=120, cores=1, memory=4096) self.jobs.append(job) with open(self.merged_files, 'w') as list_stream: for bed_file in self.list_of_merged_files: print(bed_file, file=list_stream)
def __init__(self, kLookAhead, inputFile, numberOfMachines): self.numberOfMachines = numberOfMachines self.readFile = open(inputFile, 'r') self.jobs = [] self.lookAhead = kLookAhead self.sumJobTime = 0.0 line = self.readFile.readline() self.jobs = self.readFile.readlines() self.readFile.close() for i in range(len(self.jobs)): self.jobs[i] = Job.Job(int(float(self.jobs[i].replace('\n', ''))), self.numberOfMachines) self.sumJobTime += float(self.jobs[i]) self.MAXJOB = Job.Job(0, self.numberOfMachines)
def __init__(self, qubeJobObject): logger.debug('Initialize Controller') logger.debug('Incoming Qube Job Object: ' + str(qubeJobObject)) self.job = Job.Job() self.errors = [] self.job.qubejob = qubeJobObject self.loadOptions()
def start(self, count): print '\nFetching jobs from indeed.com' urlKeyword = "Computer Science" webURL = "http://www.indeed.com/jobs?q=" + urlKeyword + "&start=" for page in range(1, 2): page = (page - 1) * 10 url = "%s%d" % (webURL, page) target = Soup(urllib.urlopen(url), "html.parser") targetElements = target.findAll('div', attrs={'class': ' row result'}) if targetElements == []: break for element in targetElements: try: # creating a job instance to store details like job title, company, address, JobLink job = Job() company = element.find('span', attrs={'class': 'company'}) if company != None: job.companyName = company.getText().strip() title = element.find('a', attrs={'class': 'turnstileLink'}).attrs['title'] if title != None: job.jobTitle = title.strip() addr = element.find('span', attrs={'class': 'location'}) if addr != None: job.address = addr.getText().strip() job.homeURL = "http://www.indeed.com" job.jobLink = "%s%s" % (job.homeURL, element.find('a').get('href')) skillsElement = element.find('span', attrs={'class': 'experienceList'}) job.skills = self.utils.clean_process_summary(skillsElement) summaryElement = element.find('span', attrs={'class': 'summary'}) job.summary = self.utils.clean_process_summary(summaryElement) if ((job.jobLink != "") and (job.jobLink != None)): joburl = urllib.quote(job.jobLink.encode('utf8'), ':/') joblinkTarget = Soup(urllib.urlopen(joburl), "html.parser") summaryElement = joblinkTarget.find('span', attrs={'class': 'summary'}) job.summary.extend(self.utils.clean_process_summary(summaryElement)) if (job.jobTitle != None and job.jobLink != None): self.jobsFetched.append(job) job.id = count count += 1 # job.printDetails() except Exception as e: print e.message continue print "No. of jobs fetched: " + str(len(self.jobsFetched)) print 'Fetching jobs from indeed.com completed.' return self.jobsFetched
def worker(pool, name, start, end): name = threading.current_thread().name pool.makeActive(name) print '\nNow running: %s' % str(pool) j = Job.Job(name=name) cmd = j.renderJob(start=start, end=end) j.run(cmd) pool.makeInactive(name)
def initJob(): # Get the job object jobObject = qb.jobobj() job = Job.Job(logger) # Create our own Job Object job.loadOptions(jobObject) # Load the Qube Job into our job template return job
def start(self, count): print '\nFetching jobs from dice.com' webURL = "https://www.dice.com/jobs?q=Computer+Science&l=San+Jose%2C+CA" for page in range(1, 2): page = (page - 1) * 10 url = "%s%d" % (webURL, page) target = Soup(urllib.urlopen(url), "html.parser") targetElements = target.findAll( 'div', attrs={'class': 'complete-serp-result-div'}) if targetElements == []: break for element in targetElements: # creating a job instance to store details like job title, company, address, JobLink job = Job() title = element.find('span', attrs={'itemprop': 'title'}) if title != None: job.jobTitle = title.getText().strip() company = element.find('span', attrs={'class': 'compName'}) if company != None: job.companyName = company.getText().strip() addr = element.find('span', attrs={'class': 'jobLoc'}) if addr != None: job.address = addr.getText().strip() job.homeURL = "https://www.dice.com" sub = element.find('a', attrs={ 'itemprop': 'url' }).attrs['href'] job.jobLink = "%s%s" % (job.homeURL, sub) if ((job.jobLink != "") and (job.jobLink != None)): # joburl = urllib.quote(job.jobLink.encode('utf8'), ':/') joblinkTarget = Soup(urllib.urlopen(job.jobLink), "html.parser") summaryElement = joblinkTarget.find( 'div', attrs={'itemprop': 'description'}) job.summary = self.utils.clean_process_summary( summaryElement) if (job.jobTitle != None and job.jobLink != None and job.summary != []): self.jobsFetched.append(job) job.id = count count += 1 # job.printDetails() print "No. of jobs fetched: " + str(len(self.jobsFetched)) print 'Fetching jobs from dice.com completed.' return self.jobsFetched
def load_jobs(self, filename): '''Loads jobs from input file.''' with open(filename, 'r') as file: for line in file: if not line.startswith('JOB,PRIORITY,LENGTH'): data = line.rstrip().split(',') job = Job(data[0], int(data[1]), int(data[2])) self.__jobHeap.add((job.get_priority(), job.get_length()), job) file.close()
def newJob(self, from_reference, to_do): """ Starts a new Job in its own thread. The Object calling this method must be the endpoint of the Job. @param from_reference: the reference of the object from which the job is @param to_do: what has to be done """ self._updateUnitList() self.jobs.append(Job(from_reference, to_do, self)) self.jobs[len(jobs) - 1].start()
def add_new_process(self, now): self.server_chooser.set_decision_pars(self.servers) server_number = self.server_chooser.choose_server(None) temp_job = Job.Job(now, self.limit_time_generator.generate(), self.process_time_generator.generate(), 0) added = self.servers[server_number].add_new_job(temp_job) if not added: self.logger.add_log(temp_job.forward_cost, temp_job.enter_time, temp_job.enter_time, 'blocked') self.logger.add_sample(self.servers) return
def generate_tasks (self): for each in self.task_parameters: mode,\ startingTaskId,\ numJobs,\ rateOfJobGeneration,\ startingJobId,\ lowInstrBound,\ highInstrBound,\ lowMemBound,\ highMemBound = each if (mode == 'W'): # Note that job-task correspondence is one-to-one webTaskBucket = [] for taskId in xrange (startingTaskId, startingTaskId + numJobs): name = "Job%s-%s" % (0, taskId) reqInstr = int (random.uniform (lowInstrBound, highInstrBound)) reqMem = int (random.uniform (lowMemBound, highMemBound)) # JobId = 0, TaskId = taskId jobInTask = Job (name, reqInstr, reqMem, taskId, numJobs, 0) task = Task ("Task" + str(taskId), taskId, [jobInTask]) webTaskBucket.append(task) self.tasklist.append (webTaskBucket) elif (mode == 'S'): # Create a set of jobs for the task joblist = [] for jobId in xrange (startingJobId, startingJobId + numJobs): name = "Job%s-%s" % (jobId, startingTaskId) reqInstr = int (random.uniform (lowInstrBound, highInstrBound)) reqMem = int (random.uniform (lowMemBound, highMemBound)) joblist.append (Job (name, reqInstr, reqMem, startingTaskId, numJobs, jobId)) task = Task ("Task" + str(startingTaskId), startingTaskId, joblist) self.tasklist.append ([task])
def fixed_jobs(self, J, T, time, cpun, gpun, memb, nicb): jid = 1 jobs = [] for _ in range(J): tasks = [] tid = 1 for _ in range(T): tasks.append(Task(jid, tid, time, cpun, gpun, memb, nicb)) tid += 1 jobs.append(Job(jid, tasks)) jid += 1 return jobs
def dig(self, _course): jobs = [] url_r = requests.get(self.url_base + str(_course)) enconding = url_r.encoding if 'charset' in url_r.headers.get('content-type', '').lower() else None if url_r.status_code == 200: url_soup = BeautifulSoup(url_r.content, 'html.parser', from_encoding=enconding) tbody = url_soup.find('tbody') jobOffers = tbody.findChildren('td') for job in jobOffers: link = job.find('a', href=True)['href'] url_offer_r = requests.get(link) if url_offer_r.status_code == 200: job_s = BeautifulSoup(url_offer_r.content, 'html.parser') divHead = job_s.find(id='item_head') if divHead: jobTitle = divHead.findChild('strong').text else: jobTitle = "Not defined" divDates = job_s.find(id='type_dates') if divDates: jobType = divDates.findChild('strong').text dates = divDates.findAll('em') jobPublishment = dates[0].text jobExpire = dates[1].text else: jobType = "Not defined" jobPublishment = "Not defined" jobExpire = "Not defined" #---IMPLEMENT MAPS divLocation = job_s.find(id='item_location').find('strong') if divLocation: jobAddress = divLocation.text else: jobAddress = "Not defined" description = job_s.find(id='description').find('p').text divImgs = job_s.find(id='description').findChildren('img') infos = [] for count in range (3): infos.append(divImgs[count].get('alt','')) jobs.append(Job.Job(link, jobTitle, jobType, jobPublishment, jobExpire, jobAddress, description, infos)) return jobs
def main(): job_queue = [] # Read the threads and jobs information from file num_threads, num_jobs, process_times = read_input('testcases.txt') # Create jobs from process times for i in range(num_jobs): job = Job.Job(process_times[i]) job_queue.append(job) # Process the jobs in parallel process_jobs(num_threads, job_queue)
def prepare_jobs(self): command = "{executable} -f {fasta_file} -b {bed_file} " \ "-o {output_directory} -n {nucs}".format( executable = self.executable, fasta_file = self.fasta_file, bed_file = self.bed_file, output_directory = self.output_directory, nucs = self.number_of_nucleotides ) this_job = Job.Job(command = command , output_directory = self.cluster_out_directory , job_name = self.name, time_limit = self.run_time , cores = 1 , memory = self.memory) self.jobs.append(this_job)
def __define_pipeline(self, config): ''' 构造任务节点 __JOB['Node_Name']存储所有job对象 __Node存储头部和尾部节点 ''' for job_name, job_define in config["JOB"].items(): self.__JOB[job_name] = Job(job_define) self.__Node['Node_Name'].append(job_name) self.__Node['START'].append(job_name) self.__INPUT = {} self.__INPUT["prefix"] = isexists(isexists(config, "INPUT"), "prefix") self.__INPUT["suffix"] = isexists(isexists(config, "INPUT"), "suffix") self.__pipeline = {"INPUT": self.__INPUT, "JOB": self.__JOB}
def callback(ch, method, properties, body): print(' Delivery task recieved') job = Job() job = pickle.loads(body) d.arm_and_ready() d.deliver_package_to_address(job) d.reached_delivery_address() d.delivered_package() d.back_to_base(job) d.back_to_idle_state()
def getHPCEventJobFromEnv(self): tolog("getHPCEventJobFromEnv") try: # always use this filename as the new jobDef module name import newJobDef job = Job.Job() job.setJobDef(newJobDef.job) job.coreCount = 0 job.workdir = self.__jobSite.workdir job.experiment = self.getExperiment() # figure out and set payload file names job.setPayloadName(self.__thisExperiment.getPayloadName(job)) # reset the default job output file list which is anyway not correct job.outFiles = [] except Exception, e: pilotErrorDiag = "Failed to process job info: %s" % str(e) tolog("!!WARNING!!3000!! %s" % (pilotErrorDiag)) self.failJob(0, PilotErrors.ERR_UNKNOWN, job, pilotErrorDiag=pilotErrorDiag)
def ReadInput(filename): # read in the input file fp = open("input.txt", 'r') line = fp.readline().split() job_number = int(line[0]) machine_number = int(line[1]) jid = 0 jobList = [] # read all jobs and add to jobList while True: line = fp.readline() jid = jid + 1 if not line: break time = line.split() start = time[0] end = time[1] job = Job.Job(jid, start, end) # add job jobList.append(job) fp.close() return job_number, machine_number, jobList
# Selection setting (roulette_wheel) population_size = 10 #66 num_iteration = 70 crossover_rate = 1 #66 mutation_rate = 1 #66 elite_selection_size = int(population_size * 0.2) rank_selection_size = population_size * 2 - elite_selection_size rank_selection_num = population_size - elite_selection_size proba_list = rank_selection_get_proba_list(rank_selection_size) # --------------------Frame------------------------- # create jobs jobs = [] for i in range(len(wip.values)): #job len (100) jobs.append(Job(wip.iloc[i], eqp)) # create chromosomes chromosomes = [] for i in range(population_size): chromosomes.append(Chromosome(len(jobs))) #input () # create machines machines = [] for i in range(len(tool.values)): machines.append(Machine(tool.iloc[i])) #-------------------------------------------------- # 迭代 MakespanRecord = []
tolog("Current job workdir is: %s" % os.getcwd()) tolog("Site workdir is: %s" % jobSite.workdir) # get the experiment object thisExperiment = getExperiment(runJob.getExperiment()) tolog("RunJob will serve experiment: %s" % (thisExperiment.getExperiment())) # set the cache (used e.g. by LSST) #if runJob.getCache(): # thisExperiment.setCache(runJob.getCache()) #JR = JobRecovery() try: job = Job.Job() job.setJobDef(newJobDef.job) job.workdir = jobSite.workdir job.experiment = runJob.getExperiment() # figure out and set payload file names job.setPayloadName(thisExperiment.getPayloadName(job)) except Exception, e: pilotErrorDiag = "Failed to process job info: %s" % str(e) tolog("!!WARNING!!3000!! %s" % (pilotErrorDiag)) runJob.failJob(0, error.ERR_UNKNOWN, job, pilotErrorDiag=pilotErrorDiag) # prepare for the output file data directory # (will only created for jobs that end up in a 'holding' state)
pilotErrorDiag = "Cannot switch to FAX site mover for transferType=%s since faxredirector is not set" % (job['transferType']) pUtil.tolog("!!WARNING!!1234!! %s" % (pilotErrorDiag)) return None, None, pilotErrorDiag # convert the data into a file for child process to pick for running real job later try: f = open("Job_%s.py" % job['PandaID'], "w") print >>f, "job=", job f.close() except Exception,e: pilotErrorDiag = "[pilot] Exception caught: %s" % str(e) pUtil.tolog("!!WARNING!!1200!! %s" % (pilotErrorDiag), tofile=tofile) return None, None, pilotErrorDiag # create the new job newJob = Job.Job() newJob.setJobDef(job) # fill up the fields with correct values now newJob.mkJobWorkdir(self.__pilotWorkingDir) self.backupJobData(newJob, job) newJob.datadir = self.__jobSite.workdir + "/PandaJob_%s_data" % (newJob.jobId) newJob.experiment = self.__thisExperiment if job.has_key('logGUID'): logGUID = job['logGUID'] if logGUID != "NULL" and logGUID != "": newJob.tarFileGuid = logGUID pUtil.tolog("Got logGUID from server: %s" % (logGUID), tofile=tofile) else: pUtil.tolog("!!WARNING!!1200!! Server returned NULL logGUID", tofile=tofile) pUtil.tolog("Using generated logGUID: %s" % (newJob.tarFileGuid), tofile=tofile) else:
def set_job(self, name='A Job', rate=MIN_WAGE): """ Give a Job to Worker. """ self.job = Job.Job(name, rate)
def initial(self): job0 = Job.Job(0, 120, 1) job1 = Job.Job(1, 120, 1) job2 = Job.Job(2, 120, 1) job3 = Job.Job(3, 120, 1) job4 = Job.Job(4, 120, 1) job5 = Job.Job(5, 120, 1) job6 = Job.Job(6, 120, 1) job7 = Job.Job(7, 120, 1) job8 = Job.Job(8, 120, 1) job9 = Job.Job(9, 120, 1) job10 = Job.Job(10, 150, 1) job11 = Job.Job(11, 150, 1) job12 = Job.Job(12, 150, 1) job13 = Job.Job(13, 150, 1) job14 = Job.Job(14, 150, 1) job15 = Job.Job(15, 150, 1) job16 = Job.Job(16, 150, 1) job17 = Job.Job(17, 150, 1) job18 = Job.Job(18, 150, 1) job19 = Job.Job(19, 150, 1) job20 = Job.Job(20, 170, 1) job21 = Job.Job(21, 170, 1) job22 = Job.Job(22, 170, 1) job23 = Job.Job(23, 170, 1) job24 = Job.Job(24, 170, 1) job25 = Job.Job(25, 170, 1) job26 = Job.Job(26, 170, 1) job27 = Job.Job(27, 170, 1) job28 = Job.Job(28, 170, 1) job29 = Job.Job(29, 170, 1) self.jobs.append(job0) self.jobs.append(job1) self.jobs.append(job2) self.jobs.append(job3) self.jobs.append(job4) self.jobs.append(job5) self.jobs.append(job6) self.jobs.append(job7) self.jobs.append(job8) self.jobs.append(job9) self.jobs.append(job10) self.jobs.append(job11) self.jobs.append(job12) self.jobs.append(job13) self.jobs.append(job14) self.jobs.append(job15) self.jobs.append(job16) self.jobs.append(job17) self.jobs.append(job18) self.jobs.append(job19) self.jobs.append(job20) self.jobs.append(job21) self.jobs.append(job22) self.jobs.append(job23) self.jobs.append(job24) self.jobs.append(job25) self.jobs.append(job26) self.jobs.append(job27) self.jobs.append(job28) self.jobs.append(job29) cluster0 = Cluster.Cluster(0, 1000, 64) cluster1 = Cluster.Cluster(1, 1000, 64) cluster2 = Cluster.Cluster(2, 1000, 64) cluster3 = Cluster.Cluster(3, 1000, 64) cluster4 = Cluster.Cluster(4, 1000, 64) self.clusters.append(cluster0) self.clusters.append(cluster1) self.clusters.append(cluster2) self.clusters.append(cluster3) self.clusters.append(cluster4) self.n = len(self.jobs) self.m = len(self.clusters) self.bestSolution = [None] * self.n self.heuristic = [[None] * (self.m + 1)] * self.n for i in range(self.n): for j in range(self.m): self.heuristic[i][j] = 2 for i in range(self.n): self.heuristic[i][self.m] = 0.1 self.pheromone = [[None] * (self.m + 1)] * self.n for i in range(self.n): for j in range(self.m + 1): self.pheromone[i][j] = self.pheremoneInitialVal for i in range(self.numOfAnts): self.ants.append(Ant.Ant(self.n, self.m))
def halt(self): print("\nScheduler has been halted:") # Update the min with the remaining length current_key, current_job = self.__jobHeap.remove_min() self.__jobHeap.add((current_key[0], current_job.get_length()), current_job) # tmpHeap stores the job that is removed from the jobHeap tmpHeap = AdaptableHeapPriorityQueue() # nameDict is a dictionary that stores job names as keys and locators as values nameDict = {} # listJobs is a python list used to sort jobs listJobs = [] # prompt the user for how the table should be sorted srt = input("Sort by (j/p/l/h): ") print(self) try: while True: # Remove from jobHeap and print the job data if heap order is selected tmpKey, tmpJob = self.__jobHeap.remove_min() name = tmpJob.get_name() priority = tmpJob.get_priority() length = tmpJob.get_length() if(srt == 'h'): print(tmpJob) # Add the job from the jobHeap to the tmpHeap nameDict[name] = tmpHeap.add(tmpKey, tmpJob) # Add the job to the listJobs listJobs.append((name, priority, length)) except Empty: pass # Print the jobs based on the user input if other than heap order if srt == 'j': for j in sorted(listJobs, key=lambda jobs: jobs[0]): output = '{0:<20} '.format(j[0]) output += '{0:>10} '.format(j[1]) output += '{0:>10} '.format(j[2]) print(output) elif srt == 'p': for j in sorted(listJobs, key=lambda jobs: jobs[1]): output = '{0:<20} '.format(j[0]) output += '{0:>10} '.format(j[1]) output += '{0:>10} '.format(j[2]) print(output) elif srt == 'l': for j in sorted(listJobs, key=lambda jobs: jobs[2]): output = '{0:<20} '.format(j[0]) output += '{0:>10} '.format(j[1]) output += '{0:>10} '.format(j[2]) print(output) # Add new job newJob = input("New job? (y/n): ") if newJob == 'y': name = input("New job name: ") priority = int(input("New job priority: ")) length = int(input("New job length: ")) newJob = Job(name, priority, length) tmpHeap.add((priority, length), newJob) # Alter a job alter = input("Alter priority? (y/n): ") if alter == 'y': name = input("Job name: ") priority = int(input("New priority: ")) tmpKey, tmpJob = tmpHeap.remove(nameDict[name]) tmpJob.set_priority(priority) tmpHeap.add((priority, tmpKey[1]), tmpJob) # Restart the scheduler print("Restarting scheduler...") self.__jobHeap = tmpHeap
def prepare_jobs(self): self.jobs = list() if len(self.input_files) > 2: raise( ExtractBpFromSamRefJobGroupException( " Found too many sam files:"\ + "\n".join(self.input_files)) ) arguments = " -1 " + self.input_files[0] if len(self.input_files) == 2: arguments += " -2 " + self.input_files[1] arguments += " -o " + self.output_directory command = self.executable + arguments job = Job.Job(command=command, output_directory=self.cluster_out_directory, job_name="bp_from_bed_ref", time_limit=self.run_time, cores=1, memory=self.memory) self.jobs.append(job) if self.individual_lib_directory != "": library_directories = glob.glob(self.individual_lib_directory + "/*") library_names = map(os.path.basename, library_directories) self.individual_output_directory = os.path.join( self.output_directory, "individual_libraries") os.makedirs(self.individual_output_directory, exist_ok=True) for library_directory in library_directories: library_name = os.path.basename(library_directory) this_output_directory = os.path.join( self.individual_output_directory, library_name) os.makedirs(this_output_directory, exist_ok=True) if len(self.input_files) == 1: sam_file = os.path.join(library_directory, 'alignment.sam') if not os.path.isfile(sam_file): raise ( FileNotFoundError("Could not find the sam file " + sam_file)) arguments = " -1 " + sam_file + " -o " + this_output_directory elif len(self.input_files) == 2: sam_file_1 = os.path.join(library_directory, 'alignment_1.sam') sam_file_2 = os.path.join(library_directory, 'alignment_2.sam') if not os.path.isfile(sam_file_1): raise ( FileNotFoundError("Could not find the sam file " + sam_file_1)) if not os.path.isfile(sam_file_2): raise ( FileNotFoundError("Could not find the sam file " + sam_file_2)) arguments = " -1 " + sam_file_1 + " -2 " + sam_file_2 + " -o " + this_output_directory command = self.executable + arguments job = Job.Job(command=command, output_directory=self.cluster_out_directory, job_name="bp_from_bed_ref", time_limit=self.run_time, cores=1, memory=self.memory) self.jobs.append(job)
def prepare_jobs(self): self.jobs = list() if self.alignment_mode == "single": for directory in self.input_files: arranged_input_files = self.arrange_input_files(directory) for file in arranged_input_files: input_fastq = file.strand_1_file output_directory = os.path.join( self.output_directory, os.path.basename(directory), file.name) success_file = os.path.join(output_directory, self.run_success_file_name) if os.path.isfile(success_file): continue os.makedirs(output_directory, exist_ok=True) summary_file = os.path.join(output_directory, "%s.summary" % file.name) command = "{executable} -p {threads} {arguments} -x {reference} -o {output_directory} "\ " -U {input} &> {summary}".format(executable = self.executable ,\ threads = self.run_threads ,\ arguments = self.arguments ,\ output_directory = output_directory,\ reference = self.reference ,\ input = input_fastq ,\ summary = summary_file ) job = Job.Job(command=command, output_directory=self.cluster_out_directory, job_name=file.name, time_limit=self.run_time, cores=self.run_threads, memory=self.memory) self.jobs.append(job) else: for directory in self.input_files: arranged_input_files = self.arrange_input_files(directory) for file in arranged_input_files: input_1_fastq = file.strand_1_file input_2_fastq = file.strand_2_file output_directory = os.path.join( self.output_directory, os.path.basename(directory), file.name) success_file = os.path.join(output_directory, self.run_success_file_name) if os.path.isfile(success_file): continue os.makedirs(output_directory, exist_ok=True) summary_file = os.path.join(output_directory, "%s.summary" % file.name) command = "{executable} -p {threads} {arguments} -x {reference} -o {output_directory} "\ " -1 {input_1} -2 {input_2} &> {summary}".format(executable = self.executable ,\ threads = self.run_threads ,\ arguments = self.arguments ,\ reference = self.reference ,\ output_directory = output_directory,\ input_1 = input_1_fastq ,\ input_2 = input_2_fastq ,\ summary = summary_file ) job = Job.Job(command=command, output_directory=self.cluster_out_directory, job_name=file.name, time_limit=self.run_time, cores=self.run_threads, memory=self.memory) self.jobs.append(job)
reverse=True)) cncs = np.array(cncs) cncs_forging = CNC_shape.getForgingCNC(cncs) cncs_hex = CNC_shape.getHexCNC(cncs) cncs_valve = CNC_shape.getValveCNC(cncs) cncs_round = CNC_shape.getRoundCNC(cncs) cncs_square = CNC_shape.getSquareCNC(cncs) cncs_lok_forging = CNC_shape.getLokfittingForging(cncs) # 1,2,3,2m,3m,4m 단조 cncs_lok_hex = CNC_shape.getLokfittingHex(cncs) # 1,2,3,2m,3m,4m hex cncs_3941 = CNC_shape.get3941cnc(cncs) cncs_4042 = CNC_shape.get4042cnc(cncs) sorted_jobs = np.array(sorted_jobs) temp_job = Job.Job() for jobs in sorted_jobs: idx = 0 for job in jobs: if (job.getRawmaterialGubun() == 1 and job.getLOKFitting() == 'Y' and job.getLOKFittingSize() == 'N'): if (10 < job.getSpec() and 20 > job.getSpec()): temp_job = copy.deepcopy(job) job.setProcessCd(1) temp_job.setProcessCd(2) cncs_3941[0].setReservedTime(cncs_3941[0].getReservedTime() + job.getRequiredTime()[0] + interval_time) cncs_3941[0].jobAssign(job) cncs_3941[1].setReservedTime(cncs_3941[1].getReservedTime() +
def prepare_jobs(self): self.jobs = list() mate_1_option = " --norc " mate_2_option = " --nofw " if self.rna_strandness == 'R': mate_1_option = " --nofw " mate_2_option = " --norc " for directory in self.input_files: subdirectories = get_directories(directory) library_name = os.path.basename(directory) for subdir in subdirectories: arranged_input_files = self.arrange_input_files( os.path.join(subdir, "hisat") ) file = arranged_input_files[0] input_fastq = file.strand_1_file output_directory_base = os.path.join(self.libraries_directory , os.path.basename(directory), os.path.basename(subdir) ) if self.alignment_mode == "single": output_directory_1 = os.path.join(output_directory_base, 'align_bp_single_end') success_file_1 = os.path.join(output_directory_1, self.run_success_file_name) if os.path.isfile(success_file_1): continue else: output_directory_1 = os.path.join(output_directory_base, 'mate_1') output_directory_2 = os.path.join(output_directory_base, 'mate_2') os.makedirs(output_directory_2, exist_ok=True ) self.sam_files_2[library_name].append(os.path.join(output_directory_2, "alignment.sam")) success_file_1 = os.path.join(output_directory_1, self.run_success_file_name) success_file_2 = os.path.join(output_directory_2, self.run_success_file_name) if os.path.isfile(success_file_1) and os.path.isfile(success_file_2): continue summary_file_2 = os.path.join(output_directory_2, "%s.pipeline_summary"%file.name) self.sam_files_1[library_name].append(os.path.join(output_directory_1, "alignment.sam")) os.makedirs(output_directory_1, exist_ok=True ) summary_file_1 = os.path.join(output_directory_1, "%s.pipeline_summary"%file.name) command_1 = "{executable} -a \\\" {arguments} \\\" -x {reference} -o {output_directory} " \ "-p {threads} -U {input_fastq} &> {summary}".format( executable = self.executable, arguments = self.arguments + mate_1_option, reference = self.reference, output_directory = output_directory_1, threads = self.run_threads, input_fastq = input_fastq, summary = summary_file_1 ) job_1 = Job.Job(command = command_1 , output_directory = self.cluster_out_directory , job_name = file.name, time_limit = self.run_time , cores = self.run_threads , memory = self.memory) self.jobs.append(job_1) if self.alignment_mode == "paired": input_fastq_2 = file.strand_2_file command_2 = "{executable} -a \\\" {arguments}\\\" -x {reference} -o {output_directory} " \ "-p {threads} -U {input_fastq} &> {summary}".format( executable = self.executable, arguments = self.arguments + mate_2_option, reference = self.reference, output_directory = output_directory_2, threads = self.run_threads, input_fastq = input_fastq_2, summary = summary_file_2 ) job_2 = Job.Job(command = command_2 , output_directory = self.cluster_out_directory , job_name = file.name + "_2", time_limit = self.run_time , cores = self.run_threads , memory = self.memory) self.jobs.append(job_2)