def test_repo_fetch(self):
r = Repository("test/test_repo")
r.set_clone_url(self.clone_dir)
r.initialize()
self.assertFalse(os.path.exists(os.path.join(r.repo_path, 'new_file.txt')))
with open(os.path.join(self.clone_dir, "new_file.txt"), "w") as fd:
fd.write("blah")
orig_dir = os.getcwd()
os.chdir(self.clone_dir)
FNULL = open(os.devnull, 'w')
subprocess.call(["git", "add", "new_file.txt"], stdout=FNULL, stderr=subprocess.STDOUT)
subprocess.call(["git", "commit", "-m" "new file"], stdout=FNULL, stderr=subprocess.STDOUT)
os.chdir(orig_dir)
r.fetch()
# We need to switch to the correct branch in order to see the file
branches = r.get_branches()
for b in branches:
if b.name == "master":
r.set_branch(b)
break
self.assertTrue(os.path.exists(os.path.join(r.repo_path, 'new_file.txt')))
class Market(object):
def __init__(self):
self.repository = Repository("market.pkl")
self.itemsOnMarket = self.repository.get_data()
def _find_seller_by_item(self,item):
for seller, itemList in self.itemsOnMarket.items():
if item in itemList:
return seller
raise ValueError("Item: "+ str(item) + " not Found")
def buy(self, buyer, item):
buyer.cart.add(item)
# FIX ME returns string not class instance
seller = self._find_seller_by_item(item)
seller.kitch.patron_orders[buyer]= item
def offer(self,seller,item):
if seller not in self.itemsOnMarket.keys():
self.itemsOnMarket[seller] = []
if item not in self.itemsOnMarket[seller]:
self.itemsOnMarket[seller].append(item)
self.repository.save_data(self.itemsOnMarket)
def get_plates_for_sale(self):
p = []
for plateList in self.itemsOnMarket.values():
p += plateList
return p
def testTrees():
repository = Repository('d:\\geogit-repo')
trees = repository.trees()
for tree in trees:
print str(tree.path)
features = tree.features()
for feature in features:
print str(feature.path)
def test_repo_initialize(self):
r = Repository("test/test_repo")
# Check path
self.assertEqual(r.repo_path, os.path.join(self.repo_dir, "test_test_repo"))
r.set_clone_url(self.clone_dir)
r.initialize()
self.assertTrue(os.path.isdir(os.path.join(r.repo_path, '.git')), "initialization did not work - no .git-dir")
def test_repo(self):
repo = Repository('Jabref', 'jabref')
repo.scrape()
loader_repos = Loader('user')
i = 0
data_repos = loader_repos.load_data()
for x in data_repos:
i += 1
if i == 1:
self.assertEqual("1", x['total_pr'])
def test_repo(self):
repo = Repository('Jabref', 'jabref')
repo.scrape()
loader_repos = Loader('repo')
i = 0
data_repos = loader_repos.load_data()
for x in data_repos:
i += 1
if i == 1:
self.assertEqual("jabref", x['name'])
self.assertEqual("Jabref", x['login'])
def testLog():
repo = Repository('d:\\geogit-repo')
#get the log of the repo
log = repo.log()
for entry in log:
#each entry has a commit object, and a list of diffentries
print entry.commit
for diff in entry.diffset:
print diff
#that was done on the current branch, but we can use other branches as well
branches = repo.branches()
for branch in branches:
if branch is not None and isinstance(branch, str):
print branch
else:
pass
#let's have a look at the history of branch "mybranch"
branch = branches[1]
log = branch.log()
for entry in log:
print entry.commit
for diff in entry.diffset:
print diff
#let's explore the tree corresponding to the tip of that branch
#Tree is a tree object that points to the root tree in that snapshot
tree = log[0].commit.tree()
#we can see the subtrees it contains
trees = tree.trees()
for subtree in trees:
print subtree
#each subtree is a tree object itself, and we can see its trees and its features
features = trees[0].features()
for feature in features:
print feature
#and for each feature we can see its attributes
attrs = features[0].attributes()
for attr in attrs:
print attr
def test_repo(self):
repo = Repository('Jabref', 'jabref')
repo.scrape()
loader_repos = Loader('repo')
i = 0
data_repos = loader_repos.load_data()
for repo in data_repos:
loader_prs = Loader('pr')
loader_prs.set_login(repo['login'])
loader_prs.set_name(repo['name'])
data_prs = loader_prs.load_data()
for data_pr in data_prs:
i += 1
if i == 1:
self.assertEqual("24", data_pr['number'])
if i == 2:
self.assertEqual("20", data_pr['number'])
if i == 3:
self.assertEqual("16", data_pr['number'])
if i == 4:
self.assertEqual("15", data_pr['number'])
def test_repo_branches(self):
r = Repository("test/test_repo")
r.set_clone_url(self.clone_dir)
r.initialize()
branches = r.get_branches()
self.assertEqual(len(branches), 2)
self.assertEqual(branches[0].name, "branch2")
self.assertEqual(branches[1].name, "master")
def process_push(json_data):
info = json.loads(json_data)
try:
clone_url = info["repository"]["clone_url"]
repository_name = info["repository"]["full_name"]
ref = info["ref"]
except IndexError:
# Missing information in JSON, just ignore it
return
repo = Repository(repository_name)
if not os.path.exists(os.path.join(config.REPOSITORY_PATH, repository_name)):
repo.initialize()
repo.setup_env()
repo.pull(ref)
repo.reset_env()
def testAddProposition(self):
repo = Repository("sentences.txt")
controller = Controller(repo)
assert controller.addProp("a") == False
assert controller.addProp("anna has apples") == False
assert controller.addProp("Unu doi trei") == True
assert repo.verifyPropositionFromText("a") == False
assert repo.verifyPropositionFromText("anna has apples") == False
assert repo.verifyPropositionFromText("Unu doi trei") == False
assert repo.verifyPropositionFromText("Unu doi trei patru") == True
def __init__(self):
self.repository = Repository("market.pkl")
self.itemsOnMarket = self.repository.get_data()
def testGetLettersEnd(self):
repo = Repository("sentences.txt")
controller = Controller(repo)
assert controller.GetLettersEnd("") == False
assert controller.GetLettersEnd("doi patru") == ['d', 'i', 'p', 'u']
def main():
try:
opts, args = getopt.gnu_getopt(
sys.argv[1:], "", ['gpgkey=', 'pool=', 'origin=', 'version='])
except getopt.GetoptError, e:
usage(e)
kws = {'pool': 'pool', 'version': '1.0', 'origin': 'turnkeylinux'}
gpgkey = None
for opt, val in opts:
if opt == '--gpgkey':
gpgkey = val
else:
kws[opt[2:]] = val
if not args:
usage()
if len(args) != 2:
usage("bad number of arguments")
path, release = args
repo = Repository(path, release, **kws)
repo.generate_release(gpgkey)
if __name__ == "__main__":
main()
def main():
repo = Repository("sentences.txt")
controller = Controller(repo)
MenuUI(controller, repo.getFileName())
def main():
try:
opts, args = getopt.gnu_getopt(sys.argv[1:], "",
['gpgkey=', 'pool=', 'origin=', 'version='])
except getopt.GetoptError, e:
usage(e)
kws = {'pool': 'pool', 'version': '1.0', 'origin': 'turnkeylinux'}
gpgkey = None
for opt, val in opts:
if opt == '--gpgkey':
gpgkey = val
else:
kws[opt[2:]] = val
if not args:
usage()
if len(args) != 2:
usage("bad number of arguments")
path, release = args
repo = Repository(path, release, **kws)
repo.generate_release(gpgkey)
if __name__ == "__main__":
main()
repo.setup_env()
repo.pull(ref)
repo.reset_env()
if not os.path.isdir(config.VIRTENV_PATH):
os.makedirs(config.VIRTENV_PATH)
#process_push(json.dumps({ "repository": { "clone_url": "https://github.com/yzzyx/photoshop.git",
# "full_name": "yzzyx/photoshop", },
# "ref": "refs/heads/master" }))
variable_list = { "git_clone_url": "https://github.com/yzzyx/photoshop.git",
"git_repository_full_name": "yzzyx/photoshop",
"date": strftime(config.DATETIME_STR, localtime()) }
repo = Repository("yzzyx/photoshop")
repo.set_clone_url("https://github.com/yzzyx/photoshop.git")
repo.initialize()
repo.setup_env()
repo.fetch()
branches = repo.get_branches()
for b in branches:
# Check if we already have this data
if not b.cached_data:
print "Not cached: %s %s" % (b.name, strftime(config.DATETIME_STR,localtime(b.last_updated)))
(rv, total, failed, output) = handlers.handler.process_handlers()
b.failed_tests = failed
b.total_tests = total
b.output_log = output
from repo import Repository
#---------------------------REPOSITORIO SERVIDOR-----------------------------------------------------
#repositorio = Repository('10.25.163.18','5432','repositorio','repositorios','cl_rincao','cesar','senha')
#---------------------------REPOSITORIO CLIENTE-----------------------------------------------------
repositorio = Repository('localhost', '5432', 'repositorio', 'repositorios',
'cl_rincao', 'cesar', 'senha')
#----------------CRIANDO REPOSITORIO-----------------------
#repositorio.init()
repositorio.config('cesar', '*****@*****.**')
#---------------CRIANDO REPOSITORIO - IMPORTANDO DADOS DO BANCO------------------
#repositorio.branches['master'].pg_import_schema('10.25.163.18','5432','cl_rincao','dominios','cesar','senha')
#repositorio.branches['master'].add()
#repositorio.branches['master'].commit('inicio de projeto')
#print repositorio.branches['cesar'].log()
#print repositorio.branches['master'].merge('cesar')
#---------------NOVO BRANCH--------------------------------------------
#repositorio.add_branch('cesar')
#print repositorio.branches['cesar'].log()
#---------------CLONANDO O REPOSITORIO---------------------------------
#repositorio.clone('localhost','5432','repositorio','repositorios','cl_rincao','cesar','senha')
#repositorio.config('cesar','*****@*****.**')
#---------------PUSH PULL --------------------------
#repositorio.branches['cesar'].pull('cesar')
#repositorio.branches['cesar'].push('cesar')
class Service():
def __init__(self, name):
self._repository = Repository(name)
def _getPlayers(self):
return self._repository._getPlayers()
def _getPlayer1(self):
return self._repository._getPlayer1()
def _getPlayer2(self):
return self._repository._getPlayer2()
def _putPlane(self, cap, dire):
self._repository._putPlane(cap, dire)
def _getHp1(self):
return self._repository._getHp1()
def _getHp2(self):
return self._repository._getHp2()
def _getMask2(self):
return self._repository._getMask2()
def _playerMoves(self, x, y):
self._repository._playerMoves(x, y)
def _computerMoves(self):
'''
Function generates the most optimal move that can be made by the computer
and removes scenarios which are impossible after seeing the result of its move
output: pos_maxim - position where move was made + 1 (if the move hit)
0 (if the move did not hit)
'''
board = self._repository.Board
scenarios = self._repository.Scenarios
chances = []
for i in range(0, 64):
chances.append(0)
for scenario in scenarios:
for i in range(0, 64):
if scenario[i] == "1" and board[i] != "x":
chances[i] += 1
maxim = 0
pos_maxim = -1
for i in range(0, 64):
if chances[i] > maxim:
maxim = chances[i]
pos_maxim = i
if self._repository._computerHit(pos_maxim):
i = 0
while i < len(scenarios):
scenario = scenarios[i]
if scenario[pos_maxim] == "*":
scenarios.remove(scenario)
i -= 1
i += 1
return [pos_maxim, 1]
else:
i = 0
while i < len(scenarios):
scenario = scenarios[i]
if scenario[pos_maxim] == "1":
scenarios.remove(scenario)
i -= 1
i += 1
return [pos_maxim, 0]
# Check if we've slept enough
current_time = int(time.time())
if (current_time - cfg_values['last_ran']) < cfg_values['sleep']:
continue
cfg_values['last_ran'] = current_time
updated = True
clone_url = cfg_values['repository_url']
variable_list = {
"name": cfg_name,
"clone_url": clone_url,
}
repo = Repository(cfg_name)
repo.set_clone_url(clone_url)
repo.initialize()
repo.fetch()
branches = repo.get_branches()
for b in branches:
# Check if we already have this data
if b.cached_data:
continue
repo.set_branch(b)
# Load configuration file
def __init__(self, name):
self._repository = Repository(name)
@help.usage(__doc__)
def usage():
s = "Syntax: %s [-options] <path> <release> <component> <arch>" % sys.argv[0]
print >>sys.stderr, s
def main():
try:
opts, args = getopt.gnu_getopt(sys.argv[1:], "", ["pool=", "origin=", "version="])
except getopt.GetoptError, e:
usage(e)
kws = {"pool": "pool", "version": "1.0", "origin": "turnkeylinux"}
for opt, val in opts:
kws[opt[2:]] = val
if not args:
usage()
if len(args) != 4:
usage("bad number of arguments")
path, release, component, arch = args
repo = Repository(path, release, **kws)
repo.index(component, arch)
if __name__ == "__main__":
main()
def execute():
# request the system to collect data for a specific repository
if options.collect:
# scrape repository specified
repo = Repository(options.collect[0], args[0])
repo.scrape()
# scrape pull requests for this repository, including users
pr = PullRequest(options.collect[0], args[0])
pr.scrape()
return
# list all repos collected
loader_repos = Loader('repo')
data_repos = loader_repos.load_data()
if options.repos:
for data_repo in data_repos:
description = data_repo['login'] + '/' + data_repo['name'] + ': ' + data_repo['description'] + ' (' + \
data_repo['watchers'] + ' of stars)'
print(description)
# list all pull requests from a repo (or summary)
if options.pullrequest or options.summary:
# list all repos for choosing
print("Repositories: ")
for data_repo in data_repos:
description = data_repo['login'] + '/' + data_repo['name']
print(description)
# choose and list pull requests
login_chosen = input("\nUsername (login): ")
name_chosen = input("Repository Name: ")
loader_prs = Loader('pr')
loader_prs.set_login(login_chosen)
loader_prs.set_name(name_chosen)
data_prs = loader_prs.load_data()
# output the detail
if options.pullrequest:
for data_pr in data_prs:
description = 'title: ' + data_pr['title'] + ', number: ' + data_pr['number'] + ', state: ' + data_pr['state'] + ', by user: '******'user'] + ', commits: ' + data_pr['commits']
print(description)
# output summary
if options.summary:
pr_open = 0
pr_closed = 0
pr_users = []
smallest_number = 999999
oldest_date = ''
for data_pr in data_prs:
if data_pr['state'] == 'open':
pr_open += 1
if data_pr['state'] == 'closed':
pr_closed += 1
pr_users.append(data_pr['user'])
if int(data_pr['number']) < smallest_number:
smallest_number = int(data_pr['number'])
oldest_date = data_pr['created_at']
pr_users = len(set(pr_users))
print("\nRepository Summary:\n")
print("number of pull requests in 'open' state:", pr_open)
print("number of pull requests in 'closed' state:", pr_closed)
print("number of users:", pr_users)
print("date of the oldest pull request:", oldest_date)
# twitter data is located in user class
# create graphics given a repo, or create graphics considering all pull requests from all repos
if options.graph or options.allpr:
graph = Graph()
if options.graph:
graph.set_repo(options.graph[0], args[0])
graph.display()
# calculate the correlation between the data collected for a user
if options.usercorrelation:
loader_repos = Loader('user')
data_users = loader_repos.load_data()
for user in data_users:
co = np.corrcoef([int(user['followers']), int(user['following']), int(user['commit_last_year'])])
print("Correlation: ", co)
# calculate the correlation between all the numeric data in the pull requests for a repo
if options.inprcorrelation:
loader_repos = Loader('repo')
data_repos = loader_repos.load_data()
for repo in data_repos:
loader_prs = Loader('pr')
loader_prs.set_login(repo['login'])
loader_prs.set_name(repo['name'])
data_prs = loader_prs.load_data()
for data_pr in data_prs:
co = np.corrcoef([int(data_pr['number']), int(data_pr['commits']), int(data_pr['additions']), int(data_pr['deletions']), int(data_pr['changed_files'])])
print("Correlation: ", co)
from flask import Flask, request, redirect, jsonify
from flask_cors import CORS
from datetime import datetime
from threading import Thread
from util import generate_short_url
from repo import Repository
repository = Repository()
SHORT_URL_LENGTH = 7
app = Flask(__name__)
CORS(app)
@app.route('/')
def hello():
return "Hello, World!"
@app.route('/create')
def create_url():
url = request.args.get("url")
id = generate_short_url(SHORT_URL_LENGTH)
repository.add_url(url, id)
return jsonify(id=id)
@app.route('/<id>')
@help.usage(__doc__)
def usage():
s = "Syntax: %s [-options] <path> <release> <component> <arch>" % sys.argv[0]
print >> sys.stderr, s
def main():
try:
opts, args = getopt.gnu_getopt(sys.argv[1:], "",
['pool=', 'origin=', 'version='])
except getopt.GetoptError, e:
usage(e)
kws = {'pool': 'pool', 'version': '1.0', 'origin': 'turnkeylinux'}
for opt, val in opts:
kws[opt[2:]] = val
if not args:
usage()
if len(args) != 4:
usage("bad number of arguments")
path, release, component, arch = args
repo = Repository(path, release, **kws)
repo.index(component, arch)
if __name__ == "__main__":
main()
"""this module will execute the scraper and save the stats"""
from repo import Repository
REPOS = [line.rstrip('\n') for line in open("repositories.txt")]
for repo in REPOS:
print "Running on %s" % (repo)
r = Repository(repo)
r.start()
stats, folders = r.stats()
f = open(repo.replace('/', '-'), "w")
f.write("%s\n" % repo)
f.write("%d lines in total\n" % r.total_lines)
f.write("%d bytes in total\n" % r.total_bytes)
f.write("%s\n" % stats)
f.write(folders.encode('utf-8'))
f.close()
