def __init__(self, odooenv, name):
""" Busca el cliente en la estructura de directorios, pero si no lo
encuentra pide un directorio donde esta el repo que lo contiene
"""
# parent es siempre un objeto OdooEnv
self._parent = odooenv
self._name = name
# si estamos en test accedo a data
if name[0:5] == 'test_':
path = os.path.dirname(os.path.abspath(__file__))
path = path.replace('scripts', 'data')
manifest = self.get_manifest(path)
else:
manifest = self.get_manifest(BASE_DIR)
if not manifest:
msg.inf('Can not find client {} in this host. Please provide path '
'to repo\n where it is or hit Enter to exit.'
'\n'.format(self._name))
path = raw_input('path = ')
manifest = self.get_manifest(path)
if not manifest:
msg.err('Can not find client {} in this host'.format(name))
msg.inf('Client found!')
msg.inf('Name {}\nversion {}\n'.format(manifest.get('name'),
manifest.get('version')))
# Chequar que este todo bien
if not manifest.get('docker'):
msg.err('No images in manifest {}'.format(self.name))
if not manifest.get('repos'):
msg.err('No repos in manifest {}'.format(self.name))
self._port = manifest.get('port')
if not self._port:
msg.err('No port in manifest {}'.format(self.name))
self._version = manifest.get('version')[0:3]
if not self._version:
msg.err('No version tag in manifest {}'.format(self.name))
# Crear imagenes y repos
self._repos = []
for rep in manifest.get('repos'):
self._repos.append(Repo(rep))
self._images = []
for img in manifest.get('docker'):
self._images.append(Image(img))
# todo codigo repetido
# get first word of name in lowercase
name = manifest.get('name').lower()
if not self._name == name.split()[0]:
msg.err('You intend to install client {} but in manifest, '
'the name is {}'.format(self._name, manifest.get('name')))
def test_drop_piece(self):
board = np.zeros((6, 7))
row = 0
col = 0
piece = 1
ob = Repo()
ob.drop_piece(board, row, col, piece)
self.assertEqual(board[0][0], 1)
def test_pick_best_move(self):
board = np.zeros((6, 7))
board[0][0] = 2
board[0][1] = 2
board[0][2] = 2
AI = 2
ob = Service(Repo())
self.assertEqual(ob.pick_best_move(board, AI), 3)
def test_is_terminal_node(self):
board = np.zeros((6, 7))
board[0][0] = 1
board[0][1] = 1
board[0][2] = 1
board[0][3] = 1
ob = Service(Repo())
self.assertEqual(ob.is_terminal_node(board), True)
def test_score_position(self):
board = np.zeros((6, 7))
board[0][0] = 1
board[0][1] = 1
board[0][2] = 1
board[0][3] = 1
ob = Service(Repo())
self.assertEqual(ob.score_position(board, 1), 110)
def test_winning_move(self):
board = np.zeros((6, 7))
board[0][0] = 1
board[0][1] = 1
board[0][2] = 1
board[0][3] = 1
ob = Service(Repo())
self.assertEqual(ob.winning_move(board, 1), True)
def test_minimax(self):
board = np.zeros((6, 7))
board[0][0] = 2
board[0][1] = 2
board[0][2] = 2
board[0][3] = 2
ob = Service(Repo())
self.assertEqual(ob.minimax(board, 0, -math.inf, math.inf, True),
(None, 100000000000000))
def find_git_repos(dirpath, excludes, depth, name_for_parent=1):
"""Return list of directories containing a `.git` file or directory
Results matching globbing patterns in `excludes` will be ignored.
`depth` is how many directories deep to search (2 is the minimum in
most situations).
`name_for_parent` is which level of the directory hierarchy to name
the repo after relative to `.git` (1=immediate parent, 2=grandparent)
"""
start = time()
cmd = ['find', '-L', dirpath, '-name', '.git', '-maxdepth', str(depth)]
output = subprocess.check_output(cmd)
output = [
os.path.dirname(s.strip()) for s in decode(output).split('\n')
if s.strip()
]
results = []
for filepath in output:
ignore = False
for pattern in excludes:
if fnmatch(filepath, pattern):
ignore = True
break
if ignore:
continue
# Work out name for repo
if name_for_parent < 2: # ignore 0, it's pointless
name = os.path.basename(filepath)
else:
components = filepath.rstrip('/').split('/')
if name_for_parent >= len(components):
log.warning(
u'%s : `name_for_parent` is %d, but '
u'only %d levels in file tree', filepath, name_for_parent,
len(components))
name = os.path.basename(filepath)
else:
name = components[-(name_for_parent)]
results.append(Repo(name, filepath))
log.debug(u'%d repo(s) found in `%s` in %0.2fs', len(results), dirpath,
time() - start)
for r in results:
log.debug(' %r', r)
return results
def find_git_repos(dirpath, excludes, depth, uid, gids, name_for_parent=1):
"""Return list of directories containing a `.git` file or directory.
Results matching globbing patterns in `excludes` will be ignored.
`depth` is how many directories deep to search (2 is the minimum in
most situations).
`name_for_parent` is which level of the directory hierarchy to name
the repo after relative to `.git` (1=immediate parent, 2=grandparent)
"""
def _group(args, primary, operator=None):
"""Pair each arg with primary, then join pairs with operator."""
out = ['(']
for i, arg in enumerate(args):
if operator and i > 0 and i < len(args) - 1:
out.append(operator)
out += [primary, arg]
return out + [')']
start = time()
cmd = ['find', '-L', dirpath, '-maxdepth', str(depth)]
# excludes converted to `find` arguments
if excludes:
cmd += _group(excludes, '-name', '-o') + ['-prune', '-o']
# ignore unreadable directories
# https://unix.stackexchange.com/a/257058
cmd.append('(')
# ignore user-owned that we can't open
cmd += ['-uid', str(uid), '(', '-perm', '-u=rx', '-o', '-prune', ')']
# ignore group-owned that we can't open
cmd += ['-o'] + _group([str(n) for n in gids], '-gid')
cmd += ['(', '-perm', '-g=rx', '-o', '-prune', ')']
# ignore other-owned that we can't open
cmd += ['-o', '(', '-perm', '-o=rx', '-o', '-prune', ')']
# close "unreadable" group
cmd.append(')')
cmd += ['-name', '.git', '-print']
cmd = [utf8ify(s) for s in cmd]
try:
output = subprocess.check_output(cmd)
except Exception as err:
log.exception('failed: %r', err)
raise err
output = [
os.path.dirname(s.strip()) for s in decode(output).split('\n')
if s.strip()
]
results = []
for filepath in output:
ignore = False
for pattern in excludes:
if fnmatch(filepath, pattern):
ignore = True
break
if ignore:
continue
# Work out name for repo
if name_for_parent < 2: # ignore 0, it's pointless
name = os.path.basename(filepath)
else:
components = filepath.rstrip('/').split('/')
if name_for_parent >= len(components):
log.warning(
'%s : `name_for_parent` is %d, but '
'only %d levels in file tree', filepath, name_for_parent,
len(components))
name = os.path.basename(filepath)
else:
name = components[-(name_for_parent)]
results.append(Repo(name, filepath))
log.debug('%d repo(s) found in `%s` in %0.2fs', len(results), dirpath,
time() - start)
for r in results:
log.debug(' %r', r)
return results
from repos import Repo from service import Service from ui import UI from valid import Valid v = Valid() r = Repo() s = Service(r) ui = UI(s) ui.run()
def find_git_repos(dirpath,
excludes,
depth,
user_id,
group_ids,
name_for_parent=1):
"""Return list of directories containing a `.git` file or directory.
Results matching globbing patterns in `excludes` will be ignored.
`depth` is how many directories deep to search (2 is the minimum in
most situations).
`name_for_parent` is which level of the directory hierarchy to name
the repo after relative to `.git` (1=immediate parent, 2=grandparent)
"""
start = time()
# assemble excludes for find
excludes_for_find = []
# add excludes from config
if excludes:
excludes_for_find += ['('] + \
' -o '.join(['-name ' + exclude for exclude in excludes]).split(' ') + \
[')', '-prune', '-o']
# tell it to silently ignore folders it can't open
excludes_for_find.append('(')
# ignore user-owned that we can't open
excludes_for_find += [
'-uid',
str(user_id), '(', '-perm', '-u=rx', '-o', '-prune', ')'
]
excludes_for_find.append('-o')
# ignore group-owned that we can't open
excludes_for_find += ['('] + \
' -o '.join(['-gid ' + str(gid) for gid in group_ids]).split(' ') + \
[')', '(', '-perm', '-g=rx', '-o', '-prune', ')']
excludes_for_find.append('-o')
# ignore other-owned that we can't open
excludes_for_find += ['(', '-perm', '-o=rx', '-o', '-prune', ')']
excludes_for_find.append(')')
cmd = ['find', '-L', dirpath,
'-maxdepth', str(depth)] + \
excludes_for_find + \
['-name', '.git',
'-print']
output = subprocess.check_output(cmd)
output = [
os.path.dirname(s.strip()) for s in decode(output).split('\n')
if s.strip()
]
results = []
for filepath in output:
ignore = False
for pattern in excludes:
if fnmatch(filepath, pattern):
ignore = True
break
if ignore:
continue
# Work out name for repo
if name_for_parent < 2: # ignore 0, it's pointless
name = os.path.basename(filepath)
else:
components = filepath.rstrip('/').split('/')
if name_for_parent >= len(components):
log.warning(
u'%s : `name_for_parent` is %d, but '
u'only %d levels in file tree', filepath, name_for_parent,
len(components))
name = os.path.basename(filepath)
else:
name = components[-(name_for_parent)]
results.append(Repo(name, filepath))
log.debug(u'%d repo(s) found in `%s` in %0.2fs', len(results), dirpath,
time() - start)
for r in results:
log.debug(' %r', r)
return results
def test_get_next_open_row(self):
board = np.zeros((6, 7))
board[0][0] = 1
ob = Service(Repo())
r = ob.get_next_open_row(board, 0)
self.assertEqual(r, 1)
def test_get_valid_locations(self):
board = np.zeros((6, 7))
board[0][0] = 2
ob = Service(Repo())
self.assertEqual(ob.get_valid_locations(board), [0, 1, 2, 3, 4, 5, 6])
def test_is_valid_location(self):
board = np.zeros((6, 7))
board[0][0] = 1
col = 0
ob = Service(Repo())
self.assertEqual(ob.is_valid_location(board, col), True)
