def delete_section_helper(section_id): student_section_manager = StudentSectionRequestManager(Repository(sqldb())) student_section_manager.delete(data={"section_id": section_id}) # Delete section r_manager = SectionRequestManager(Repository(sqldb())) section_success = r_manager.delete(data={"section_id": section_id}) return section_success
class Game(Resource): def __init__(self): self._repository = Repository() self._validator = MovePieceValidator() def post(self): new_game = GameModel() uid = self._repository.insert(new_game) return {'uid': uid, 'game': new_game.to_dict()}, HTTPStatus.CREATED def get(self, uid): # if not uid: # return 404 return self._repository.fetch(uid).to_dict(), 200 def patch(self, uid): req = reqparse.request body = req.get_json() success, errors = self._validator.validate(body) if not success: return {"errors": errors}, HTTPStatus.BAD_REQUEST game = self._repository.fetch(uid) if body['player'] != game.current_player_turn: # return 404 pass piece = game.find_piece_at(*body['currentCoordinate']) if body['piece'] != piece.kind: # return 404 pass
def test_repository_add_remove_has_not(self): repo = Repository(repo_name) doc = test_doc(repo) repo.remove_document(doc) self.assertFalse(repo.has_document_uuid(doc.uuid))
def test_repository_add_search_keyword_success(self): repo = Repository(repo_name) doc = test_doc(repo) result = repo.search_keywords('jungle') self.assertEqual(len(result), 1)
def main(): # type: () -> None listener = Listener(WORKER_SOCKET_NAME, 'AF_UNIX') try: Door.initialize() name_to_add = None print('Worker started') while True: conn = listener.accept() print('connection accepted from', listener.last_accepted) msg = conn.recv() print('Message: ', msg) command = msg['type'] value = msg['value'] if command == 'read': process_read_command(value, name_to_add) name_to_add = None elif command == 'add': name_to_add = process_add_command(value) else: Repository.log_message( 'error', 'Unknown command: {}'.format(command)) finally: Door.cleanup() listener.close()
class TestRepositoryJSON(unittest.TestCase): def setUp(self): self.temp_file = tempfile.NamedTemporaryFile() self.repo = Repository(JSONAdapter(self.temp_file.name)) def tearDown(self): self.temp_file.close() def test_set_get(self): self.repo["id"] = "value" self.repo["id1"] = "value1" self.assertEqual("value", self.repo["id"]) self.assertEqual("value1", self.repo["id1"]) def test_items(self): self.repo["id"] = "value" self.repo["id1"] = "value1" self.assertEqual([('id', 'value'), ('id1', 'value1')], list(self.repo.items())) def test_persistance(self): self.repo["id"] = "value" self.repo["id1"] = "value1" self.repo.store() new_repo = Repository(JSONAdapter(self.temp_file.name)) self.assertEqual([('id', 'value'), ('id1', 'value1')], list(new_repo.items())) self.assertEqual("value", new_repo["id"]) self.assertEqual("value1", new_repo["id1"])
def get_lead_time(release: release.Release, repo: repository.Repository) -> timedelta: if len(repo.get_releases()) == 1: commit_times = [ datetime.timestamp(c.get_date()) - datetime.timestamp(repo.get_creation_time()) for c in repo.get_commits() ] else: releases = repo.get_releases() release_index = None for index, r in enumerate(releases): if r.get_id() == release.get_id(): release_index = index break if release_index != None: if release_index < len(releases) - 1: prev_release = releases[release_index + 1] else: return timedelta(seconds=0) else: return timedelta(seconds=0) commits = get_commits_between_releases(release, prev_release, repo) commit_times = [ datetime.timestamp(c.get_date()) - datetime.timestamp(prev_release.get_creation_time()) for c in commits ] # Stop disvision by zero if len(commit_times) == 0: return timedelta(seconds=sum(commit_times)) return timedelta(seconds=sum(commit_times) / len(commit_times))
class TestRepository(unittest.TestCase): def setUp(self): self.repo = Repository() def test_default_adapter(self): self.assertTrue(self.repo.adapter) def test_load(self): self.assertTrue(self.repo.load) def test_set_get(self): self.repo["id"] = "value" self.repo["id1"] = "value1" self.assertEqual("value", self.repo["id"]) self.assertEqual("value1", self.repo["id1"]) def test_items(self): self.repo["id"] = "value" self.repo["id1"] = "value1" self.assertEqual([('id', 'value'), ('id1', 'value1')], list(self.repo.items())) def test_store(self): self.repo.store()
def get_class_repositories(self, class_dir): repos = [] class_path = os.path.join(self.home_dir, class_dir) if not directory_exists(class_path, ssh=self.ssh): return repos for name in list_directory(class_path, ssh=self.ssh): path = os.path.join(class_path, name) if directory_exists(path, ssh=self.ssh) and name.endswith('.git'): assignment, _ = os.path.splitext(name) if self.ssh is not None: repos.append( Repository(path, assignment, is_bare=True, is_local=False, ssh=self.ssh, student_username=self.username)) else: repos.append( Repository(path, assignment, is_bare=True, student_username=self.username)) return repos
def setUp(self): self.__repo=Repository() self.__groups={} self.__idlist=[] self.__assignmentDict={} self.__undoRedo=UndoRedo() self.__control=controllerStudent(self.__repo,self.__undoRedo)
def create_course(): success = "Course Creation Failed" if request.method == 'POST': cleaned_data = clean_data(request) r_manager = CourseRequestManager(Repository(sqldb())) # Separate the data into course and section part course_data = {} section_data = {} for key, value in cleaned_data.items(): if key.startswith("courses"): course_data[key] = value else: section_data[key] = value # Add course first course_success = r_manager.add(course_data) if course_success: # Get the course_id course_results, course_field_names = r_manager.read( criteria=course_data) course_info = convert_sql(course_results, course_field_names) course_id = course_info[0]["course_id"] section_data["course_id"] = course_id # add the section to the course section_manager = SectionRequestManager(Repository(sqldb())) section_success = section_manager.add(section_data) if section_success: success = "HOORAY! Course and Section Successfully Created" else: r_manager.delete(course_data) success = "Section Creation Failed, Course Deleted" return {'success': success}
class BaseHaskiAction(object): """This class is the abstract base class for Haski tasks. """ __metaclass__ = ABCMeta def __init__(self): self._repository = Repository() @abstractmethod def __call__(self, namespace): """This method is invoked by argparse and should do the actuall work. By default, it is abstract and does nothing, so it forces you to implement it. """ pass def get_commit(self, namespace): """This function gets the commit wanted commit on which an action is to be performed. """ commit = self._repository.get_commit(namespace.revision) return commit def get_repository_location(self): """Returns the directory where this repository is located. """ return self._repository.get_path()
def test_status_untracked_files(self): path, content = ('1.txt', '1\n') write_to_file(path, content) repo = Repository() untracked_files = repo.get_untracked_files() self.assertEqual(untracked_files, ['1.txt']) Command.cmd_status()
def add_endpoint(my_request): if not my_request.pmh_url: return None endpoint_with_this_id = Endpoint.query.filter( Endpoint.repo_request_id == my_request.id).first() if endpoint_with_this_id: print u"one already matches {}".format(my_request.id) return None raw_endpoint = my_request.pmh_url clean_endpoint = raw_endpoint.strip() clean_endpoint = clean_endpoint.strip("?") clean_endpoint = re.sub(u"\?verb=.*$", "", clean_endpoint, re.IGNORECASE) print u"raw endpoint is {}, clean endpoint is {}".format( raw_endpoint, clean_endpoint) matching_endpoint = Endpoint() matching_endpoint.pmh_url = clean_endpoint repo_matches = my_request.matching_repositories() if repo_matches: matching_repo = repo_matches[0] print u"yay! for {} {} matches repository {}".format( my_request.institution_name, my_request.repo_name, matching_repo) else: print u"no matching repository for {}: {}".format( my_request.institution_name, my_request.repo_name) matching_repo = Repository() # overwrite stuff with request matching_repo.institution_name = my_request.institution_name matching_repo.repository_name = my_request.repo_name matching_repo.home_page = my_request.repo_home_page matching_endpoint.repo_unique_id = matching_repo.id matching_endpoint.email = my_request.email matching_endpoint.repo_request_id = my_request.id matching_endpoint.ready_to_run = True matching_endpoint.set_identify_and_initial_query() db.session.merge(matching_endpoint) db.session.merge(matching_repo) print u"added {} {}".format(matching_endpoint, matching_repo) print u"see at url http://unpaywall.org/sources/repository/{}".format( matching_endpoint.id) safe_commit(db) print "saved" print "now sending email" # get the endpoint again, so it gets with all the meta info etc matching_endpoint = Endpoint.query.get(matching_endpoint.id) matching_endpoint.contacted_text = "automated welcome email" matching_endpoint.contacted = datetime.datetime.utcnow().isoformat() safe_commit(db) send_announcement_email(matching_endpoint) print "email sent" return matching_endpoint
def setUp(self): self.__undoRedo = UndoRedo() self.__students = Repository() self.__assignments = Repository() self.__grades = Repository() self.__ui = UI(self.__students, self.__assignments, self.__grades, self.__undoRedo)
def test_rm_no_cached(self): entries = Repository().index.entries self.assertIn(self.path, entries) Command.cmd_rm(self.path, False) entries = Repository().index.entries self.assertNotIn(self.path, entries) self.assertFalse(os.path.exists(self.path))
def query_china_user(first, after): r1 = Repository.query_pinned() r2 = Repository.query_popular() q = """ {{ search(first: {},{} query: "{}", type: USER) {{ pageInfo {{ endCursor hasNextPage hasPreviousPage startCursor }} edges {{ node {{ ... on User {{ login name url {} {} }} }} }} }} }} """.format(first, after, config.user_query, r1, r2) return q
def test_status_untracked_files(self): path, content = ('1.txt', '1\n') write_to_file(path, content) repo = Repository() untracked_files = repo.get_untracked_files() self.assertEqual(untracked_files, ['1.txt']) Command.cmd_status()
def __init__(self, filename=None): if not filename: raise FileRepositoryException("Please set a filename") self._filename = filename Repository.__init__(self) self._load()
class Token: def __init__(self): self.repo = Repository(METRICS_NETWORK_ID) def process_token(self, daemon_id): print("process_token::daemon_id: ", daemon_id); result = {} token = secrets.token_urlsafe(64) exist_info = self.daemon_id_exist(daemon_id=daemon_id) if exist_info.get('status', False): qry = "UPDATE daemon_token set token = %s WHERE daemon_id = %s " updt_info = self.repo.execute(qry, [token, daemon_id]) print(updt_info) if updt_info[0] > 0: return {"token": token} else: return {"error": "unable to generate token"} ctime_epoch = calendar.timegm(time.gmtime()) expiration = ctime_epoch + (6 * 60 * 60) qry = "INSERT INTO daemon_token (daemon_id, token, expiration, row_updated, row_created) " \ "VALUES(%s, %s, %s, %s, %s)" res = self.repo.execute(qry, [daemon_id, token, expiration, dt.utcnow(), dt.utcnow()]) if len(res) > 0 and res[0] > 0: result["token"] = token return result def daemon_id_exist(self, daemon_id): print("daemon_id_exist::daemon_id: ", daemon_id); qry = "SELECT * FROM daemon_token WHERE daemon_id = %s" res = self.repo.execute(qry, [daemon_id]) if len(res) > 0: return {'status': True, "token": res[0]['token']} return {'status': False}
def test_repository_add_search_keyword_success(self): repo = Repository(repo_name) doc = test_doc(repo) result = repo.search_keywords('jungle') self.assertEqual(len(result), 1)
def test_repository_add_remove_has_not(self): repo = Repository(repo_name) doc = test_doc(repo) repo.remove_document(doc) self.assertFalse(repo.has_document_uuid(doc.uuid))
def initialize(self): undoStack = Stack() redoStack = Stack() self.__valid_movie = ValidMovie() self.__valid_client = ValidClient() self.__valid_rental = ValidRental() self.__movies_repository = Repository() self.__clients_repository = Repository() self.__rentals_repository = Repository() self.__service_movies = ServiceMovies(self.__movies_repository, self.__valid_movie, undoStack, redoStack, self.__rentals_repository) self.__service_clients = ServiceClients(self.__clients_repository, self.__valid_client, undoStack, redoStack, self.__rentals_repository) self.__service_rentals = ServiceRentals(self.__movies_repository, self.__clients_repository, self.__rentals_repository, self.__valid_rental, undoStack, redoStack) self.__service_movies.generate_movies() self.__service_clients.generate_client() self.__service_rentals.rent_movie(1, 1, 1, '1/1/1', '2/1/1') self.__service_rentals.return_movie(1, '3/1/1') self.__service_rentals.rent_movie(3, 1, 1, '5/1/1', '10/1/1') self.__service_rentals.return_movie(3, '15/1/1') self.__service_rentals.rent_movie(2, 2, 2, '2/2/2', '3/3/3') self.__service_rentals.return_movie(2, '7/2/2') self.__service_rentals.rent_movie(4, 3, 4, '1/1/1', '2/1/1') self.__service_rentals.return_movie(4, '2/1/1')
def cmd_checkout(branch): b = Branch() b.switch_branch(branch) repo = Repository() pre_entries = dict(repo.index.entries) repo.rebuild_index_from_commit(repo.branch.head_commit) repo.rebuild_working_tree(pre_entries)
def edit_item_page(itemid): webPage = SetWebPageVM() if webPage.isLoggedIn: repo = Repository() item = repo.getItemById(itemid) return render_template('edititem.html', edititem=item, WebPage=webPage) return redirect('/')
def app_setup(app): app.config['CELERY_ACCEPT_CONTENT'] = ['json'] app.config['CELERY_TASK_SERIALIZER'] = 'json' app.config['CELERY_RESULT_SERIALIZER'] = 'json' app.config['CELERY_BROKER_URL'] = 'redis://localhost:6379/2' app.config['CELERY_BACKEND'] = 'redis://localhost:6379/3' app.config['CELERY_QUEUES'] = ( Queue('transplant', Exchange('transplant'), routing_key='transplant'), ) app.src_dir = tempfile.mkdtemp(dir=test_temp_dir) app.dst_dir = tempfile.mkdtemp(dir=test_temp_dir) app.config['TRANSPLANT_WORKDIR'] = tempfile.mkdtemp(dir=test_temp_dir) app.config['TRANSPLANT_REPOSITORIES'] = [{ 'name': 'test-src', 'path': app.src_dir }, { 'name': 'test-dst', 'path': app.dst_dir }] app.src = Repository.init(app.src_dir) app.dst = Repository.init(app.dst_dir) _set_test_file_content(app.src_dir, "Hello World!\n") app.src.commit("Initial commit", addremove=True, user="******") app.dst.pull(app.src_dir, update=True)
def validate_name(self, min_length, model, parameter): if len(parameter) < min_length: message = "The name should be at least {} symbols" raise Exception(message.format(min_length)) repository = Repository(self.__db_name) if repository.is_name_used(model, parameter): raise Exception("This name is already taken")
def test_generate_id(self): repo = Repository() uids = [] for i in range(1000): uid = repo.add_item(1) self.assertNotIn(uid, uids) uids.append(uid)
def test_reset_default(self): Command.cmd_reset(self.first_commit, is_soft=False, is_hard=False) self.assertEqual(Branch().head_commit, self.first_commit) repo = Repository() uncommitted_files = repo.get_uncommitted_files() unstaged_files = repo.get_unstaged_files() self.assertFalse(uncommitted_files['modified']) self.assertIn(self.path, unstaged_files['modified'])
def delete_item_page(itemid): webPage = SetWebPageVM() repo = Repository() item = repo.getItemById(itemid) if webPage.isLoggedIn: if item.user == login_session['username']: repo.deleteFromDatabase(item) return redirect('/')
def test_reset_default(self): Command.cmd_reset(self.first_commit, is_soft=False, is_hard=False) self.assertEqual(Branch().head_commit, self.first_commit) repo = Repository() uncommitted_files = repo.get_uncommitted_files() unstaged_files = repo.get_unstaged_files() self.assertFalse(uncommitted_files['modified']) self.assertIn(self.path, unstaged_files['modified'])
def setup_hacker_scrape(db_name): content_provider = lambda url: requests.get(url).text repository = Repository(db_name) repository.create_table() scrape_manager = ScrapeManager(content_provider) ranker = HeaderRanker() return HackerScrape(repository, scrape_manager, ranker)
def main(): repository = Repository() repository.mapp.randomize() repository.random_sensors(SENSORS_COUNT, SENSORS_MAX_POWER) controller = Controller(repository) ui = UI(controller) ui.run()
class TwitterDataProcess(): def __init__(self, topics, file_name): self.file_name = file_name self.topics = topics self.tweets = [] self.repository = Repository() self.process_tweets() @staticmethod def compact_tweet_text(tweet_text): return tweet_text.replace('\n', ' ').replace('\r', '').lower() @staticmethod def to_dictionary(coordinate): keys = ["Lat", "Lng"] return dict(zip(keys, coordinate)) def check_key_words(self, topic_key, tweet_text): if re.search(topic_key, tweet_text): for word in self.topics.get(topic_key): if re.search(word, tweet_text): return True return False def process_tweets(self): self.tweets = [] with open(self.file_name, "r") as tweets_file: for line in tweets_file: tweet = dict() tweet_valid = False try: if line.strip() != '': raw_tweet = json.loads(line) text = TwitterDataProcess.compact_tweet_text(raw_tweet['text']) for topic_key in self.topics: if self.check_key_words(topic_key, text): tweet_valid = True tweet[topic_key] = True else: tweet[topic_key] = False if tweet_valid: tweet['text'] = text tweet['lang'] = raw_tweet['lang'] tweet['city'] = raw_tweet['place']['name'] if raw_tweet['place'] is not None else None if raw_tweet['geo'] is None: tweet['coordinates'] = False else: tweet['coordinates'] = True tweet.update(TwitterDataProcess.to_dictionary(raw_tweet['geo']['coordinates'])) self.tweets.append(tweet) if len(self.tweets) > 1000: self.repository.save_many(self.tweets) self.tweets = [] except Exception as e: print(str(e)) continue self.repository.save_many(self.tweets)
def cmd_diff(cached=False, use_less=True): if cached: res = Repository().diff_between_index_and_head_tree() else: res = Repository().diff_between_working_tree_and_index() if use_less: less_str(res) else: print res
def get_name_as_in_ADS(target_name, names_in_result: []): """For presentation in the UI, figures out how to capitalize a name The user may have typed in the query names in all lowercase. For the large banner at the top of the page, it would be nice to format the names more properly. Rather than just defaulting to first-letter-uppercase, we can use our ADS data to present the name in a form (or one of the forms) ADS has for the name. This means we may also pick up diacritics. Looks through all the publications belonging to the name and how the author's name appears in those publications. Grabs (one of) the most-detailed forms. If it contains more given names than the target names, truncates the list. Shortens given names to initials if the target name has an initial at that position.""" # Unique-ify names_in_result names_in_result = list(set(names_in_result)) repo = Repository(can_skip_refresh=True) names_in_result = [ADSName.parse(name) for name in names_in_result] orcid = is_orcid_id(target_name) if orcid: record = repo.get_author_record_by_orcid_id(target_name) else: target_name = ADSName.parse(target_name) record = repo.get_author_record(target_name) aliases = record.appears_as.keys() aliases = [ADSName.parse(alias) for alias in aliases] # Remove all aliases that aren't consistent with any of the name forms # used in the set of possible chains. E.g. if the user searched for # "Last" and all chains terminate at "Last, B.", then we shouldn't view # "Last, I." as a viable alias. aliases = [alias for alias in aliases if alias in names_in_result] # Grab the most-detailed alias. As tie-breaker, choose the form with the # most publications. alias = sorted([(a.level_of_detail, len(record.appears_as[a.original_name]), a.original_name) for a in aliases])[-1][-1] alias = ADSName.parse(alias, preserve=True) if orcid: gns = alias.given_names else: # Trim it down to size gns = alias.given_names if len(gns) > len(target_name.given_names): gns = gns[:len(target_name.given_names)] # Ensure we have initials where we need them gns = [ gn if len(tgn) > 1 else gn[0] for gn, tgn in zip(gns, target_name.given_names) ] final_name = ADSName.parse(alias.last_name, *gns, preserve=True) return final_name.full_name
def add_endpoint(my_request): if not my_request.pmh_url: return None endpoint_with_this_id = Endpoint.query.filter(Endpoint.repo_request_id==my_request.id).first() if endpoint_with_this_id: print u"one already matches {}".format(my_request.id) return None raw_endpoint = my_request.pmh_url clean_endpoint = raw_endpoint.strip() clean_endpoint = clean_endpoint.strip("?") clean_endpoint = re.sub(u"\?verb=.*$", "", clean_endpoint, re.IGNORECASE) print u"raw endpoint is {}, clean endpoint is {}".format(raw_endpoint, clean_endpoint) matching_endpoint = Endpoint() matching_endpoint.pmh_url = clean_endpoint repo_matches = my_request.matching_repositories() if repo_matches: matching_repo = repo_matches[0] print u"yay! for {} {} matches repository {}".format( my_request.institution_name, my_request.repo_name, matching_repo) else: print u"no matching repository for {}: {}".format( my_request.institution_name, my_request.repo_name) matching_repo = Repository() # overwrite stuff with request matching_repo.institution_name = my_request.institution_name matching_repo.repository_name = my_request.repo_name matching_repo.home_page = my_request.repo_home_page matching_endpoint.repo_unique_id = matching_repo.id matching_endpoint.email = my_request.email matching_endpoint.repo_request_id = my_request.id matching_endpoint.ready_to_run = True matching_endpoint.set_identify_and_initial_query() db.session.merge(matching_endpoint) db.session.merge(matching_repo) print u"added {} {}".format(matching_endpoint, matching_repo) print u"see at url http://unpaywall.org/sources/repository/{}".format(matching_endpoint.id) safe_commit(db) print "saved" print "now sending email" # get the endpoint again, so it gets with all the meta info etc matching_endpoint = Endpoint.query.get(matching_endpoint.id) matching_endpoint.contacted_text = "automated welcome email" matching_endpoint.contacted = datetime.datetime.utcnow().isoformat() safe_commit(db) send_announcement_email(matching_endpoint) print "email sent" return matching_endpoint
class Weather: def __init__(self, apikey, cities): self.cities = cities self.api = OpenWeatherAPI(apikey) self.repo = Repository() def forecast(self): for city in self.cities: self.repo.push("weather|" + city, self.api.three_hour_forecast(city))
def __init__(self, repoid, repoConfig, maxFileLength=1024*1024*1024*2, retryTime=3, socketTimeout=5): Repository.__init__(self, repoid) self.repoConfig = repoConfig self.cachedir = None self.expireTime = None self.enabled = bool(repoConfig.enabled) self.maxFileLength = maxFileLength self.retryTime = retryTime self.socketTimeout = socketTimeout
def post_add_item(): webPage = SetWebPageVM() if webPage.isLoggedIn: repo = Repository() repo.addItemToDatabase(request.form['name'], request.form['description'], request.form['category'], login_session['username']) return redirect('/') return render_template('additem.html', WebPage=webPage)
def run_tests(student_repo: Repository, test_repo: Repository, report_repo: Repository, call_action_path, student: Student, email_queue: Queue): starting_dir = os.getcwd() code_tempdir = TemporaryDirectory() test_tempdir = TemporaryDirectory() report_tempdir = TemporaryDirectory() code_path = code_tempdir.name test_path = test_tempdir.name report_path = report_tempdir.name report_file_path = '' tmp_report_repo = None try: tmp_report_repo = report_repo.clone_to(report_path) student_repo.clone_to(code_path) test_repo.clone_to(test_path) except CommandError as e: error = 'Failed to clone:\n{0}'.format(e) report_failure(error, student.email_address, student_repo.assignment, email_queue, report_file_path, tmp_report_repo) os.chdir(starting_dir) return report_filename = 'report-{0}.txt'.format(strftime('%Y-%m-%d-%H:%M:%S-%Z')) for item in os.listdir(report_path): item_path = os.path.join(report_path, item) if os.path.isdir(item_path) and student.username in item: report_file_path = os.path.join(item_path, report_filename) break os.chdir(test_path) try: output = call_action(call_action_path, code_path, student.first_name, student.last_name, student.username, student.email_address) except CommandError as e: error = '!!! ERROR: SCRIPT RETURNED NON-ZERO EXIT CODE !!!\n\n' error += str(e) report_failure(error, student.email_address, student_repo.assignment, email_queue, report_file_path, tmp_report_repo) os.chdir(starting_dir) return write_report(report_file_path, output, tmp_report_repo) email_subject = student_repo.assignment + ' submission test results' email_queue.put(Email(student.email_address, email_subject, output)) os.chdir(starting_dir)
def main(argv): config_file = None read_only = False verbose = False try: # -h (optional), -c (mandatory, hence 'c:'), -r (optional) opts, args = getopt.getopt(argv,"hc:rv",[]) except getopt.GetoptError: print 'repository.py [-h] [-r] [-v] -c <cfgfile>' sys.exit(2) for opt, arg in opts: if opt == '-h': print 'repository.py [-h] [-r] [-v] -c <cfgfile>' sys.exit(0) elif opt in ("-c", "--cfgfile"): config_file = arg elif opt == '-r': read_only = True elif opt == '-v': verbose = True if config_file is None: print 'repository.py [-h] [-r] [-v] -c <cfgfile>' sys.exit(2) if verbose: print 'Using cfg file:', config_file repository = Repository(config_file, verbose) config = ConfigParser.RawConfigParser() config.read(config_file) sensor_names = config.get("sensors", "names").strip().split(',') if verbose: print 'Sensor names:', sensor_names sensors = [] for name in sensor_names: if verbose: print 'Adding sensor:', name sensors.append(Sensor(name, config_file)) for sensor in sensors: if verbose: print 'Reading sensor', sensor.sensor_id readings = sensor.get_readings() if readings is not None: if read_only: s=json.dumps(readings, sort_keys=True, indent=4, separators=(',', ': ')) print s else: repository.save_readings(readings) print 'Done'
def cmd_add(workspace, file): if file == '.': file_list = [] for root, dirs, files in os.walk('.'): if ".git" in dirs: dirs.remove('.git') for file in files: file_list.append(os.path.join(root[2:], file)) Repository(workspace).stage(file_list) else: Repository(workspace).stage([file])
def get_repo(self, name): repo = self.db.get("SELECT id FROM repositories WHERE distro_id = %s AND name = %s", self.id, name) if not repo: return repo = Repository(self.pakfire, repo.id) repo._distro = self return repo
def repositories(self): _repos = self.db.query("SELECT id FROM repositories WHERE distro_id = %s", self.id) repos = [] for repo in _repos: repo = Repository(self.pakfire, repo.id) repo._distro = self repos.append(repo) return sorted(repos)
def prepare_mock_repositories(self): self.src_dir = tempfile.mkdtemp() self.dst_dir = tempfile.mkdtemp() self.workdir = tempfile.mkdtemp() self.src = Repository.init(self.src_dir) self.dst = Repository.init(self.dst_dir) self._set_test_file_content(self.src_dir, "Hello World!\n") self.src.commit("Initial commit", addremove=True) self.dst.pull(self.src_dir, update=True)
def transplant(self, src_dir, dst_dir, items): src_repo = Repository(src_dir) dst_repo = Repository(dst_dir) try: for item in items: self._transplant_item(src_repo, dst_repo, item) tip = dst_repo.id(id=True) logger.info('tip: %s', tip) return {'tip': tip} finally: self._cleanup(dst_repo)
def test_status_unstaged_files(self): file_list = [('1.txt', '1\n'), ('2.txt', '2\n')] for path, content in file_list: write_to_file(path, content) Command.cmd_add(path) write_to_file(file_list[0][0], '11\n') os.remove(file_list[1][0]) repo = Repository() unstaged_files = repo.get_unstaged_files() self.assertEqual(unstaged_files['modified'], [file_list[0][0]]) self.assertEqual(unstaged_files['deleted'], [file_list[1][0]]) Command.cmd_status()
def getLocally(): logger = logging.getLogger(__name__) logger.setLevel(logging.WARNING) file_handler = logging.FileHandler('mergehistory.log') logger.addHandler(file_handler) session = getSession() line_number = 0 with gzip.open(zipfile,"rb") as input_file: for line in input_file: line_number += 1 try: user_repositories = json.loads(line) for repo in user_repositories: if "created_at" in repo and repo["created_at"]: year = repo["created_at"][:4] is_success = Repository.update(session, repo['id'], creation_date = year, main_lang = repo['language']) if is_success: logger.info('%d %s %s' %(repo['id'] , year , repo['language'])) else: logger.warning(str(line_number) + ':' + str(repo['id']) +' update was unsuccessful') else: print repo logger.info('user repos updated') session.commit() file_handler.flush() except: logger.error(str(line_number) + ':' + line) logging.shutdown()
def print_repos(prefix): paths = os.listdir(os.path.join(config.REPO_ROOT, prefix)) print "\n[ Repositories in %s ]" % os.path.join(config.REPO_ROOT, prefix) paths.sort() for path in paths: if Repository.exists(os.path.join(config.REPO_ROOT, prefix, path)): print path
def predict(self, x_test): desktops = Repository.get_data('desktops') mobiles_sample = x_test merge_key = 'anonymous_c2' mobiles_sample = mobiles_sample[['device_id', merge_key]].set_index( [merge_key, 'device_id']) desktops_sample = desktops[['cookie_id', merge_key]].set_index([merge_key]) merge_data = mobiles_sample.join(desktops_sample).reset_index(1) return merge_data
def cmd_reset(commit_sha1, is_soft=False, is_hard=False): repo = Repository() pre_entries = dict(repo.index.entries) repo.update_head_commit(commit_sha1) if not is_soft: repo.rebuild_index_from_commit(commit_sha1) if is_hard: repo.rebuild_working_tree(pre_entries)
def createRepository(self): self.repository = Repository(self.appdir) self.repository.set_minecraft_target(self.minecraft_target) # Check if local packages repository exists and load it too if os.path.isfile(self.appdir + os.sep + 'local-packages.json'): self.repository.populate('', False) self.repository.populate(self.appdir + os.sep + 'local-packages.json') else: self.repository.populate('', True)
def test_status_uncommitted_files(self): file_list = [('1.txt', '1\n'), ('2.txt', '2\n')] for path, content in file_list: write_to_file(path, content) Command.cmd_add(path) Command.cmd_commit('first ci') write_to_file(file_list[0][0], '11\n') Command.cmd_rm(file_list[1][0]) new_path = '3.txt' new_content = '3\n' write_to_file(new_path, new_content) Command.cmd_add('.') repo = Repository() uncommitted_files = repo.get_uncommitted_files() self.assertEqual(uncommitted_files['modified'], [file_list[0][0]]) self.assertEqual(uncommitted_files['deleted'], [file_list[1][0]]) self.assertEqual(uncommitted_files['new file'], [new_path]) Command.cmd_status()
def backup(): parser = argparse.ArgumentParser(description="Backup utility") parser.add_argument("repos", nargs='+') parser.add_argument('--pendrive', action='store_const', const=PendriveStorage(), default=DropboxStorage(), help="use pendrive as storage", dest="storage") args = parser.parse_args() args.storage.start() for (location, repo) in Repository.read_repos_from_file("/etc/gitbackup.conf").items(): if any([os.path.samefile(location, rep_dir) for rep_dir in args.repos]): repo.send_data_to(args.storage.name) args.storage.stop()
def clone(name): repo_url = get_repo_url(name) repo_dir = get_repo_dir(name) repo_base_url = get_repo_base_url(name) if not os.path.exists(repo_dir): logger.info('cloning repository "%s"', name) repository = Repository.clone(repo_base_url, repo_dir) else: logger.info('repository "%s" is already cloned', name) repository = Repository(repo_dir) repository.set_config({ "paths": { "default": repo_url, "base": repo_base_url } }) return repository
def __init__(self, path): """To instantiantate a stash, provide a path that points to a location somewhere in a repository. """ # Check if the patches path exists, and in case it does not, create it. if not os.path.exists(self.STASH_PATH): os.mkdir(self.STASH_PATH) self.repository = Repository(path) super(Stash, self).__init__()
def get(self, training=None): training = training or Training() parts = Participants() org = Organization() sched = Schedules() when = When() costs = Costs() list_catg = [(item.value, item.name) for item in CategoryType] with Session(database='training') as session: repo = Repository(session) operator = repo.get_all(coll_name='organization', conditions={}, projection={'org_identity': 1, 'org_name': 1, '_id': 0}) list_op = [(item['org_identity'], item['org_name']) for item in operator] return self.render_response("training/add.html", training=training, list_catg=list_catg, list_op=list_op, parts=parts, org=org, sched=sched, when=when, costs=costs)
def _run_create(self, options, args): """ Create the repository. Save the yaml descriptor. """ prefix, name = __parse_prefix_name(args[0]) print "Name = %s" % name if prefix: print "Prefix = %s" % prefix print "Fisheye = %s" % options.fisheye repo = Repository(prefix, name, options.fisheye) if Repository.exists(repo.path_to_repo): raise CommandError('A repository named "%s" already exists.' % repo.path) try: __check_path_dir(repo) print 'Creating the repository ...' repo.create() print 'Created the repository' print repo.apache_conf apache_conf.process_to_file(repo.apache_conf, {'repopath' : repo.path, 'users' : ', '.join(repo.users()), 'apache_authz_path' : repo.apache_authz}) print "Created apache conf" __write_repository_yaml(repo) print "CREATED repository at %s." % repo.path if options.fisheye: __write_repository_fisheyeauth(repo) fisheye_admin = FisheyeAdmin(password=config.FISHEYE_ADMIN_PW) if fisheye_admin.create_repository(repo, __get_description()): print "Successfully created a fisheye instance for %s" % repo.name except Exception, e: raise CommandError("Failed to create the repository at %s\n" % repo.path_to_repo, "The original error was: %s: %s" % (type(e), e))
def _run_commit(self, options, args): """Commit the repository yaml descriptor file.""" prefix, name = __parse_prefix_name(args[0]) try: repo = __load_repository_from_yaml(prefix, name) except CommandError: repo = Repository(prefix, name) if not Repository.exists(repo.path_to_repo): raise CommandError('Cannot commit a descriptor for a repo that doesn\'t exist.') if(options.add): __add_yaml(repo) __checkin_yaml(repo, "Committing yaml descriptor for %s." % repo.path)