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 main_menu(user_data, contacts_dict, groups_dict, file_path,
current_user):
os.system('clear')
if len(contacts_dict) > 0:
options = inquirer.prompt([inquirer.List('choice',
message='Choose Option',
choices=['Manage Contacts',
'Manage Groups', 'Follow Up',
'Logout'])])
else:
ManageContacts.manage_contacts_menu(user_data, contacts_dict,
groups_dict, file_path,
current_user)
if options['choice'] == 'Manage Contacts':
os.system('clear')
ManageContacts.manage_contacts_menu(user_data, contacts_dict,
groups_dict, file_path,
current_user)
elif options['choice'] == 'Manage Groups':
os.system('clear')
Groups.groups_menu(user_data, groups_dict, file_path,
contacts_dict, current_user)
elif options['choice'] == 'Follow Up':
os.system('clear')
FollowUp.follow_up_menu(contacts_dict, current_user, user_data,
groups_dict, file_path)
elif options['choice'] == 'Logout':
print("Goodbye.")
exit()
class scheduler_test1(unittest.TestCase):
def setUp(self):
self.g = Groups("groups.json")
def test1_find(self):
"""
"""
grp = self.g.find("5555-5555")
self.assertEqual(grp.name, "Living room")
self.assertEqual(len(grp.devices), 2)
def test1_iterate(self):
"""
"""
grp = self.g.find("5555-5555")
self.assertEqual(grp.name, "Living room")
#for dev in grp.devices:
# print dev
self.assertEqual(grp.devices[0], '1111-1111')
self.assertEqual(grp.devices[1], '2222-2222')
def tearDown(self):
pass
class Manufacturing(DataAccumulator):
"""
Manufacturing requirements
self.groups = {
<group>: description,
<group>: description,
<group>: description,
<group>: description,
}
"""
def __init__(self):
super(Manufacturing, self).__init__()
self._set_data_descriptor("manufacturing")
self._set_data_url("http://www.eve-markets.net/detail.php?typeid=%s#industry")
self.groups = Groups()
self.groups.load_data()
def _get_for_unit_count(self, div):
for_unit_count = 1
for sub_div in div.find_all('div'):
if sub_div.get('class')[0] == 'displaylist_footer_multi':
digits = 3
while for_unit_count == 1 and digits > 0:
try:
for_unit_string = sub_div.find_all('span')[0].string[10:10 + digits]
for_unit_count = int(for_unit_string)
except ValueError, e:
print "Could not find number"
digits -= 1
return for_unit_count
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 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 __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):
self.d = Downloader(wait=0.0)
self.m = Manufacturing()
self.p = Prices()
self.g = Groups()
self.results = {}
def __init__(self):
super(Manufacturing, self).__init__()
self._set_data_descriptor("manufacturing")
self._set_data_url("http://www.eve-markets.net/detail.php?typeid=%s#industry")
self.groups = Groups()
self.groups.load_data()
def post(self, *args):
if 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()
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 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, **params):
XFeatures.__init__(self, **params)
Groups.__init__(self, **params)
Public.__init__(self, **params)
Node.__init__(self, **params)
mod = 'mod4'
my_gaps = 15
my_term = 'urxvtc'
script_path = os.path.expanduser('~/.scripts/')
hostname = subprocess.run(['hostname'], stdout = subprocess.PIPE).stdout.decode('utf-8').replace('\n', '')
wmname = 'LG3D'
bring_front_click = True
cursor_warp = False
follow_mouse_focus = True
auto_fullscreen = True
# Groups
obj_groups = Groups()
groups = obj_groups.init_groups()
# Key bindings
obj_keys = Keys()
keys = obj_keys.init_keys(my_term, script_path, mod)
# Mouse bindings and options
obj_mouse = Mouses()
mouse = obj_mouse.init_mouse()
# group key bindings
keys = Groups.add_group_key_bindings(groups, keys, mod)
obj_rules = Rules()
dgroups_app_rules = obj_rules.init_rules()
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 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
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
class AddressBook(object):
"""
Address Book containing people, groups and members
It offers APIs for storing, retreiving and searching people and groups
"""
def __init__(self):
self._people = People()
self._groups = Groups()
self._members = Members(self._people, self._groups)
def addPerson(self, firstName, lastName, emailAddresses, phoneNumbers):
"""
Add person to phone book
:param firstName: First name of the person
:param lastName: Last name of the person
:param emailAddresses: List of email addresses
:param phoneNumbers: List of phone numbers
:return: A dictionary of person
:exception If the person with same first name and last name already exists
:exception If the email and phone number is not a list
"""
return self._people.addPerson(firstName, lastName, emailAddresses,
phoneNumbers)
def addGroup(self, name):
"""
Add group to address book
:param name: Name of the group
:return: Name of the group
:exception: if the group already exists
"""
return self._groups.addGroup(name)
def addMember(self, groupName, personFirstName, personLastName):
"""
Add a person to group
:param groupName: Group name
:param personFirstName: First name of person
:param personLastName: Last name of person
:return: True if saved, Flase otherwise
"""
return self._members.addMember(groupName, personFirstName,
personLastName)
def getGroupMembers(self, groupName):
"""
Get the list of group members
:param groupName: Name of the group
:return: None if invalid group, else list of people in the group
"""
group = self._groups.getGroup(groupName)
if group:
peopleKeys = self._members.findPeople(group)
people = [self._people.findPerson(person) for person in peopleKeys]
return people
return None
def getGroups(self, firstName, lastName):
"""
Get the list of groups
:param firstName: First name of the person
:param lastName: Last name of the person
:return: List of group names else None if person does not exist
"""
person = self._people.findPerson(firstName + lastName)
if person:
group = self._members.findGroups(person['firstName'] +
person['lastName'])
return group
return None
def findPersonByName(self, **kwargs):
"""
Find the person by name
:param kwargs: firstName, lastName or both
:return: list of people found
"""
return self._people.findPeople(**kwargs)
def findPersonByEmail(self, emailAddress):
"""
Find the person by email
:param emailAddress: Email address
:return: List of people with the given email address
"""
firstNameLastNameList = self._people.findByEmail(emailAddress)
return [self._people.findPerson(p) for p in firstNameLastNameList]
def get(self, request, username, password, fromDate, toDate, node):
self.tableStart("GetGroupDetails", username, password)
data = Groups().details(username, node)
return self.tableEnd(request, data)
def setUp(self):
self.g = Groups("groups.json")
def __init__(self, **params):
XFeatures.__init__(self, **params)
Groups.__init__(self, **params)
Public.__init__(self, **params)
Node.__init__(self, **params)
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)
def get(self, request, username, password, fromDate, toDate, node):
self.tableStart("GetGroupSummary", username, password)
data = Groups().summary(username, node)
return self.tableEnd(request, data)
class ResourceApi:
# course = Courses()
groups = Groups()
users = Users()
courses = Courses()
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 testgroups(self):
group_page = Groups(self.driver).open()
group_page.createGroup('Ali')
common.check_error(self)
def __init__(self):
self._people = People()
self._groups = Groups()
self._members = Members(self._people, self._groups)
class ProfitChecker:
__metaclass__ = ABCMeta
def __init__(self):
self.d = Downloader(wait=0.0)
self.m = Manufacturing()
self.p = Prices()
self.g = Groups()
self.results = {}
def start(self):
self.all_valid_ids = self.m.fetch_all_valid_ids()
self.m.load_data()
self.p.load_data()
self.g.load_data()
self.p.warm_up(self.all_valid_ids)
def check_manufacturing_cost(self, type_id):
requirements = self.m.get_full_requirements_dict(type_id)
requirement_ids = requirements.keys()
prices = self.p.get_component_prices(requirement_ids, price_type=PriceType.SELL_PERCENTILE)
cost = 0
for requirement_id in requirement_ids:
cost += requirements[requirement_id] * prices[requirement_ids.index(requirement_id)]
return cost
def check_reprocessing_value(self, type_id):
requirements = self.m.get_full_reprocessing_dict(type_id)
requirement_ids = requirements.keys()
prices = self.p.get_component_prices(requirement_ids, price_type=PriceType.SELL_PERCENTILE)
value = 0
for requirement_id in requirement_ids:
value += requirements[requirement_id] * prices[requirement_ids.index(requirement_id)]
return value
def check_profit_bulk(self, type_ids=None):
if not type_ids:
type_ids = self.all_valid_ids
f = open('type_ids.txt', 'w')
for type_id in type_ids:
f.write(str(type_id) + "\n")
f.close()
final_ids = self.filter_type_ids(type_ids)
for type_id in final_ids:
self.check_profit(type_id)
@abstractmethod
def filter_type_ids(self, type_ids):
pass
@abstractmethod
def check_profit(self, type_id):
pass
def add_basics_to_result(self, result, type_id):
component = self.m.data[type_id]
group_name = "Unknown"
if component.group_id in self.g.data:
group_name = self.g.data[component.group_id]
result['name'] = component.name
result['group'] = group_name
result['volume'] = component.volume
return result
def write_output(self, filename):
type_ids = self.results.keys()
if len(type_ids) > 0:
f = open(filename, 'w')
if type(self.results[type_ids[0]]) == type([]):
# We are writing a list of results within each type_id
column_names = self.results[type_ids[0]][0].keys()
column_names.sort()
for key in column_names:
f.write(key + ",")
f.write('\n')
type_ids = self.results.keys()
type_ids.sort()
for type_id in type_ids:
for entry in self.results[type_id]:
for key in column_names:
f.write(str(entry[key]) + ",")
f.write('\n')
else:
# We have a single result for each type_id
column_names = self.results[type_ids[0]].keys()
column_names.sort()
for key in column_names:
f.write(key + ",")
f.write('\n')
type_ids = self.results.keys()
type_ids.sort()
for type_id in type_ids:
for key in column_names:
f.write(str(self.results[type_id][key]) + ",")
f.write('\n')
f.close()
print "Calculated profitability for " + str(len(type_ids)) + " items!"
@abstractmethod
def filter_results(self):
pass
def finish(self, filename):
self.write_output(filename)
self.p.finish()
self.m.finish()
self.g.finish()
def test_day_validation(self):
result = Groups.day_validation({'group': 'friends', 'days': '3'}, '3')
self.assertEqual(result,
True,
msg=f"day_validation('3'), result: \
{result}, expected: True")
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
from groups import Groups
groups = Groups()
groups.add_group("1", ["A"], ["B"], 2)
groups.add_group("2", ["E"], ["C", "D"], 1)
groups.add_group("3", ["H"], ["F", "G"], 2)
groups.add_group("4", [], ["I", "J", "K"], 2)
groups.add_group("CB", [], ["CB"], 0)
groups.add_inter_group_connection("1", "B", "2", "D", 8)
groups.add_inter_group_connection("1", "B", "4", "J", 14)
groups.add_inter_group_connection("2", "C", "3", "G", 8)
groups.add_inter_group_connection("3", "F", "4", "K", 13)
groups.add_inter_group_connection("CB", "CB", "1", "B", 10)
groups.add_inter_group_connection("CB", "CB", "2", "C", 10)
groups.add_inter_group_connection("CB", "CB", "3", "F", 10)
groups.add_inter_group_connection("CB", "CB", "4", "J", 10)
start_node_group = input("Enter start node group:")
start_node = input("Enter start node:")
end_node_group = input("Enter end node group:")
end_node = input("Enter end node:")
print()
path_length, path = groups.find_path(start_node_group, start_node,
end_node_group, end_node)
print(f"Total cost: {path_length}")
