def __init__(self):
self.template = Template()
self.template.add_version("2010-09-09")
self.template.add_description(
"Create IAM users, groups and policies for environments")
parameters = Parameters()
for param in parameters.values():
self.template.add_parameter(param)
groups = Groups(parameters=parameters)
for res in groups.values():
self.template.add_resource(res)
roles = RolesAndPolicies(parameters=parameters, groups=groups)
for res in roles.values():
self.template.add_resource(res)
users = Users(parameters=parameters, groups=groups, roles=roles)
for res in users.values():
self.template.add_resource(res)
outputs = Outputs(groups=groups, roles=roles, users=users)
for res in outputs.values():
self.template.add_output(res)
def __init__(self, access_token=''):
self.Account = Account(access_token=access_token)
self.Apps = Apps(access_token=access_token)
self.Audio = Audio(access_token=access_token)
self.Auth = Auth(access_token=access_token)
self.Board = Board(access_token=access_token)
self.Database = Database(access_token=access_token)
self.Docs = Docs(access_token=access_token)
self.Other = Other(access_token=access_token)
self.Fave = Fave(access_token=access_token)
self.Friends = Friends(access_token=access_token)
self.Gifts = Gifts(access_token=access_token)
self.Groups = Groups(access_token=access_token)
self.Likes = Likes(access_token=access_token)
self.Market = Market(access_token=access_token)
self.Messages = Messages(access_token=access_token)
self.Newsfeed = Newsfeed(access_token=access_token)
self.Notes = Notes(access_token=access_token)
self.Notifications = Notifications(access_token=access_token)
self.Pages = Pages(access_token=access_token)
self.Photos = Photos(access_token=access_token)
self.Places = Places(access_token=access_token)
self.Polls = Polls(access_token=access_token)
self.Search = Search(access_token=access_token)
self.Stats = Stats(access_token=access_token)
self.Status = Status(access_token=access_token)
self.Storage = Storage(access_token=access_token)
self.Users = Users(access_token=access_token)
self.Utils = Utils(access_token=access_token)
self.Video = Video(access_token=access_token)
self.Wall = Wall(access_token=access_token)
self.Widgets = Widgets(access_token=access_token)
def __init__(self, platform_name, nodes):
self.system_settings = nodes.system_settings
self._nodes = nodes
if platform_name in PLATFORM_NAMING_CONVENTIONS:
name = PLATFORM_NAMING_CONVENTIONS[platform_name]
else:
name = str(platform_name) + ' Platform'
super(Platform, self).__init__(name, platform_name, 'platforms')
groups_db_file = None
error_db_file = None
if platform_name != 'virgins':
db_path = os.path.join('platforms', platform_name)
groups_db_file = os.path.join(db_path, 'groups.db')
error_db_file = os.path.join(db_path, 'default_error.db')
LOGGER.debug("Creating Default Groups")
default_groups = OrderedDict()
default_groups['inactive_group'] = Group('Inactive Group',
platform_name, self._nodes)
self.groups = Groups(self._nodes,
platform_name,
db_file=groups_db_file,
defaults=default_groups)
self.error = NodeError(system_settings=self.system_settings,
db_file=error_db_file)
def __init__(self, username=None, password=None):
self.general = General(self)
self.model = Model(self)
self.actions = Actions(self)
self.groups = Groups(self)
self.customers = Customers(self)
self.segments = Segments(self)
self.integrations = Integrations(self)
if username and password:
self.general.login(username, password)
def post(self, *args):
try:
if len(args) > 0:
name = args[0]
group = Groups(name)
for key, value in self.request.arguments.iteritems():
if key in ("repo_addr", "repo_user", "repo_passwd"):
setattr(group, key, value[0])
group.save()
else:
group = Groups(self.get_argument('name'))
group.repo_addr = self.get_argument('repo_addr')
group.repo_user = self.get_argument('repo_user')
group.repo_passwd = self.get_argument('repo_passwd')
group.save()
self.write(cyclone.escape.json_encode({'status': 'ok'}))
except Exception, e:
self.write(
cyclone.escape.json_encode({
'status': 'fail',
'error': str(e)
}))
def get(self, *args):
if len(args) > 1:
name = args[0]
groups = [Groups(name)]
else:
groups = Groups.get_all()
groups_json = []
for group in groups:
group_json = {}
for attr in ('name', 'repo_addr', 'repo_user', 'repo_passwd'):
group_json.update({attr: getattr(group, attr)})
groups_json.append(group_json)
self.write(cyclone.escape.json_encode(groups_json))
def execute(cfg):
users = Users(cfg).run()
base.storage('users', users)
groups = Groups(cfg).run()
base.storage('groups', groups)
members = GroupsMembers(cfg, users, groups).run()
base.storage('groups-members', members)
projects = Projects(cfg, users['target'], groups['target']).run()
base.storage('projects', projects)
Repositories(cfg, projects['source']).run()
def __init__(self,
username=None,
password=None,
timeout=TIMEOUT,
url=DEFAULT_URL):
self.general = General(self)
self.model = Model(self)
self.actions = Actions(self)
self.groups = Groups(self)
self.customers = Customers(self)
self.segments = Segments(self)
self.integrations = Integrations(self)
self.timeout = timeout
self._url = url
if username and password:
self.general.login(username, password)
def execute(cfg):
# cachepath = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),'cache')
users = Users(cfg).run()
#with open(cachepath + '/users.json','r') as f:
# users = json.load(f)
groups = Groups(cfg).run()
#with open( cachepath + '/groups.json','r') as f:
# groups = json.load(f)
members = GroupsMembers(cfg, users, groups).run()
projects = Projects(cfg, users, groups).run()
# with open( cachepath + '/projects.json','r') as f:
# projects = json.load(f)
Repositories(cfg, projects).run()
def __init__(self):
self._people = People()
self._groups = Groups()
self._members = Members(self._people, self._groups)
def get(self, request, username, password, fromDate, toDate, node):
self.tableStart("GetGroupSummary", username, password)
data = Groups().summary(username, node)
return self.tableEnd(request, data)
def clickGroups(self):
self.find_elements_by_locator(locators['groups']).click()
return Groups(self.driver)
settings = json.load(
open("json/settings.json", "r", encoding='utf-8', errors='ignore'))
except FileNotFoundError:
raise FileNotFoundError('No such file as settings.json')
messages = settings['messages']
replies_commands = list(settings['messages'].keys())
images_base_dir = settings['images_base_dir']
# This will parse the AllSides JSON for now
allsides_json = json.load(open('json/allsides.json', 'r'))
# parse bias json
side_dict = json.load(open('json/bias.json', 'r', errors='ignore'))
# parse groups json
groups = Groups('json/groups.json')
# Initializes the Telegram Bot
bot = telebot.TeleBot(bot_token)
# /start and /help commands
# This is the starting message (which comes from settings.json)
# This also outputs the commands if someone types /help
# If we don't have a reply set, do nothing.
@bot.message_handler(commands=['help', 'start']) # list of commands to handle
def send_welcome(message):
"""
This function handles a list of commands in settings.json and returns a string.
"""
def repository(self):
group = Groups(self.group_name)
res = []
for attr in ('repo_addr', 'repo_user', 'repo_passwd'):
res.append(getattr(group, attr))
return res
def list_s():
print(students)
#prints list with the youngest students in each group
def filtr():
print("\nsid\tgid\tage\tname\n------------------------------------------")
for gid in groups.get_gid_list():
for stud in students.youngest(gid):
print(stud)
#reading from files
try:
with open("groups.obj","rb") as gfile:
groups = pickle.load(gfile)
except IOError:
groups = Groups()
try:
with open("students.obj","rb") as sfile:
students = pickle.load(sfile)
except IOError:
students = Students()
#UI realisation
commands = {11: add_g, 12: add_s, 21: remove_g, 22: remove_s, 31: list_g, 32: list_s, 4: filtr}
while True:
try:
comm = str(input("\n1. Add\n2. Remove\n3. List\n4. Filter\n0. Done\nEnter command: "))
if comm == '1' or comm == '2':
comm += str(input("\n1. Group\n2. Student\n0. Back\nEnter command: "))
def get(self, request, username, password, fromDate, toDate, node):
self.tableStart("GetGroupDetails", username, password)
data = Groups().details(username, node)
return self.tableEnd(request, data)
class ResourceApi:
# course = Courses()
groups = Groups()
users = Users()
courses = Courses()
from bindings import Keys, Mouses
from groups import Groups
from scratchpad import Scratchpad, DropDown_Keys
from rules import Rules
from screens import Screens
from aesthetics import Layout_Aesthetics, Widget_Aesthetics, Extension_Aesthetics
##### INIT #####
if __name__ in ["config", "__main__"]:
# Init objects
obj_keys = Keys()
obj_mouse_touch = Mouses()
obj_groups = Groups()
obj_rules = Rules()
obj_screens = Screens()
obj_scratchpad = Scratchpad()
obj_dd_keys = DropDown_Keys()
obj_widget_aesthetics = Widget_Aesthetics()
obj_layout_aesthetics = Layout_Aesthetics()
obj_extension_aesthetics = Extension_Aesthetics()
# Init qtile variables
keys = obj_keys.init_keys()
mouse = obj_mouse_touch.init_mouse()
floating_layout = obj_layout_aesthetics.floating_layout
def testgroups(self):
group_page = Groups(self.driver).open()
group_page.createGroup('Ali')
common.check_error(self)
opts = dict(getopt.getopt(sys.argv[1:], 'hs:d:g:')[0])
except getopt.GetoptError:
usage()
if '-h' in opts:
usage()
try:
srcSys = opts['-s']
dstSys = opts['-d']
grpNam = opts['-g']
except KeyError:
usage()
# create a group itself
grp = Groups()
try:
srcGid = grp.by_name(srcSys, grpNam)['id']
except KeyError:
usage("Group with name '%s' doesn't exist in the source system" % grpNam)
dstGid = grp.add(dstSys, grpNam)['id']
# add members to the group
add_members(grp, srcGid, dstGid)
# copy projects with their members from the source group to the destination one
prj = Projects()
for p in prj.by_namespace(srcSys, srcGid):
add_members(prj, p['id'], prj.add(dstSys, p['name'], namespace_id = dstGid, **filter_dict(p,
'description',
'issues_enabled',
def cayley_graph(self,
side="right",
simple=False,
elements=None,
generators=None,
connecting_set=None):
r"""
Return the Cayley graph for this finite semigroup.
INPUT:
- ``side`` -- "left", "right", or "twosided":
the side on which the generators act (default:"right")
- ``simple`` -- boolean (default:False):
if True, returns a simple graph (no loops, no labels,
no multiple edges)
- ``generators`` -- a list, tuple, or family of elements
of ``self`` (default: ``self.semigroup_generators()``)
- ``connecting_set`` -- alias for ``generators``; deprecated
- ``elements`` -- a list (or iterable) of elements of ``self``
OUTPUT:
- :class:`DiGraph`
EXAMPLES:
We start with the (right) Cayley graphs of some classical groups::
sage: D4 = DihedralGroup(4); D4
Dihedral group of order 8 as a permutation group
sage: G = D4.cayley_graph()
sage: show(G, color_by_label=True, edge_labels=True)
sage: A5 = AlternatingGroup(5); A5
Alternating group of order 5!/2 as a permutation group
sage: G = A5.cayley_graph()
sage: G.show3d(color_by_label=True, edge_size=0.01, edge_size2=0.02, vertex_size=0.03)
sage: G.show3d(vertex_size=0.03, edge_size=0.01, edge_size2=0.02, vertex_colors={(1,1,1):G.vertices()}, bgcolor=(0,0,0), color_by_label=True, xres=700, yres=700, iterations=200) # long time (less than a minute)
sage: G.num_edges()
120
sage: w = WeylGroup(['A',3])
sage: d = w.cayley_graph(); d
Digraph on 24 vertices
sage: d.show3d(color_by_label=True, edge_size=0.01, vertex_size=0.03)
Alternative generators may be specified::
sage: G = A5.cayley_graph(generators=[A5.gens()[0]])
sage: G.num_edges()
60
sage: g=PermutationGroup([(i+1,j+1) for i in range(5) for j in range(5) if j!=i])
sage: g.cayley_graph(generators=[(1,2),(2,3)])
Digraph on 120 vertices
If ``elements`` is specified, then only the subgraph
induced and those elements is returned. Here we use it to
display the Cayley graph of the free monoid truncated on
the elements of length at most 3::
sage: M = Monoids().example(); M
An example of a monoid: the free monoid generated by ('a', 'b', 'c', 'd')
sage: elements = [ M.prod(w) for w in sum((list(Words(M.semigroup_generators(),k)) for k in range(4)),[]) ]
sage: G = M.cayley_graph(elements = elements)
sage: G.num_verts(), G.num_edges()
(85, 84)
sage: G.show3d(color_by_label=True, edge_size=0.001, vertex_size=0.01)
We now illustrate the ``side`` and ``simple`` options on
a semigroup::
sage: S = FiniteSemigroups().example(alphabet=('a','b'))
sage: g = S.cayley_graph(simple=True)
sage: g.vertices()
['a', 'ab', 'b', 'ba']
sage: g.edges()
[('a', 'ab', None), ('b', 'ba', None)]
::
sage: g = S.cayley_graph(side="left", simple=True)
sage: g.vertices()
['a', 'ab', 'b', 'ba']
sage: g.edges()
[('a', 'ba', None), ('ab', 'ba', None), ('b', 'ab', None),
('ba', 'ab', None)]
::
sage: g = S.cayley_graph(side="twosided", simple=True)
sage: g.vertices()
['a', 'ab', 'b', 'ba']
sage: g.edges()
[('a', 'ab', None), ('a', 'ba', None), ('ab', 'ba', None),
('b', 'ab', None), ('b', 'ba', None), ('ba', 'ab', None)]
::
sage: g = S.cayley_graph(side="twosided")
sage: g.vertices()
['a', 'ab', 'b', 'ba']
sage: g.edges()
[('a', 'a', (0, 'left')), ('a', 'a', (0, 'right')), ('a', 'ab', (1, 'right')), ('a', 'ba', (1, 'left')), ('ab', 'ab', (0, 'left')), ('ab', 'ab', (0, 'right')), ('ab', 'ab', (1, 'right')), ('ab', 'ba', (1, 'left')), ('b', 'ab', (0, 'left')), ('b', 'b', (1, 'left')), ('b', 'b', (1, 'right')), ('b', 'ba', (0, 'right')), ('ba', 'ab', (0, 'left')), ('ba', 'ba', (0, 'right')), ('ba', 'ba', (1, 'left')), ('ba', 'ba', (1, 'right'))]
::
sage: s1 = SymmetricGroup(1); s = s1.cayley_graph(); s.vertices()
[()]
TESTS::
sage: SymmetricGroup(2).cayley_graph(side="both")
Traceback (most recent call last):
...
ValueError: option 'side' must be 'left', 'right' or 'twosided'
.. TODO::
- Add more options for constructing subgraphs of the
Cayley graph, handling the standard use cases when
exploring large/infinite semigroups (a predicate,
generators of an ideal, a maximal length in term of the
generators)
- Specify good default layout/plot/latex options in the graph
- Generalize to combinatorial modules with module generators / operators
AUTHORS:
- Bobby Moretti (2007-08-10)
- Robert Miller (2008-05-01): editing
- Nicolas M. Thiery (2008-12): extension to semigroups,
``side``, ``simple``, and ``elements`` options, ...
"""
from sage.graphs.digraph import DiGraph
from monoids import Monoids
from groups import Groups
if not side in ["left", "right", "twosided"]:
raise ValueError(
"option 'side' must be 'left', 'right' or 'twosided'")
if elements is None:
assert self.is_finite(
), "elements should be specified for infinite semigroups"
elements = self
else:
elements = set(elements)
if simple or self in Groups():
result = DiGraph()
else:
result = DiGraph(multiedges=True, loops=True)
result.add_vertices(elements)
if connecting_set is not None:
generators = connecting_set
if generators is None:
if self in Monoids and hasattr(self, "monoid_generators"):
generators = self.monoid_generators()
else:
generators = self.semigroup_generators()
if isinstance(generators, (list, tuple)):
generators = dict((self(g), self(g)) for g in generators)
left = (side == "left" or side == "twosided")
right = (side == "right" or side == "twosided")
def add_edge(source, target, label, side_label):
"""
Skips edges whose targets are not in elements
Return an appropriate edge given the options
"""
if (elements is not self and target not in elements):
return
if simple:
result.add_edge([source, target])
elif side == "twosided":
result.add_edge([source, target, (label, side_label)])
else:
result.add_edge([source, target, label])
for x in elements:
for i in generators.keys():
if left:
add_edge(x, generators[i] * x, i, "left")
if right:
add_edge(x, x * generators[i], i, "right")
return result
class GitlabManager:
#"""This is the main Class"""
print('starting now to auth')
auth = Auth(username=logindetails.user, token=logindetails.token)
activeGitlab = auth.authorizeUser()
#create a Project object called project
project = Project(projects=activeGitlab.projects,
namespaces=activeGitlab.namespaces)
projpaths = project.listProjectsPaths()
print('These are your Projects')
for p in projpaths:
print(p)
#comment
for key in ProjectList:
projectname = key
#print(projectname)
projectnamespace = ProjectList[key]
#print(projectnamespace)
pathname = (projectnamespace + '/' + projectname)
pathnamelower = pathname.lower()
#print(pathnamelower)
#check if the projects on ProjectList exist on Gitlab - If not add them to Gitlab - If exists then write the standard pushrules
project_in_Gitlab = project.checkifprojectexistonGitlab(pathnamelower)
if project_in_Gitlab is None:
print('creating a new project called ' + pathnamelower)
newproj = project.createProject(namespace=projectnamespace,
name=projectname)
print(newproj.pushrules.get())
print(newproj.attributes)
else:
project.updateProjectpushrules(project_in_Gitlab)
print(
'The project ' + pathnamelower +
' already exists - no new project created - Push rules updated'
)
#check if the projects on Gitlab still remain on the ProjectList - if not remove them from Gitlab
for p in projpaths:
print(p['name'])
project_on_list = False
for key in ProjectList:
projectnameonlist = key
#print(projectnameonlist)
projectnamespaceonlist = ProjectList[key]
#print(projectnamespaceonlist)
pathname = (projectnamespaceonlist + '/' + projectnameonlist)
pathnamelower = pathname.lower()
#print(pathnamelower)
#check if the project on Gitlab exists on ProjectList - If not remove from Gitlab
if (p['name'] == pathnamelower):
project_on_list = True
print(
'setting Gitlab project on list to True-No action required'
)
break
if not (project_on_list):
print(
'removing the following project from Gitlab no longer on list '
+ p['name'].lower())
project.deleteProject(p['id'])
# create a Namespaces object called namespaces
namespaces = Namespaces(activeGitlab.namespaces)
namespaceList = namespaces.listNamespaces()
print('These are all the namespaces')
for n in namespaceList:
print(n)
# create a Groups object called groups
groups = Groups(activeGitlab.groups)
groupList = groups.listGroups()
print('These are all the groups')
for g in groupList:
print(g)
print('These are all the Members in the Group TestGitLabManage')
members = groups.listGroupMembers('TestGitLabManage')
for m in members:
print(m)
