示例#1
0
    def __init__(self, url=None, session_id=None):

        #Record the names of the files created by the plugin so we can
        #display them to the user.
        self.files    = []

        #A mapping from attr ID to attr object. Makes searching for attributes
        #easier 
        self.attr_id_map = {}

        self.connection = JsonConnection(url)
        write_output("Connecting...")
        if session_id is not None:
            write_output("Using existing session %s"% session_id)
            self.connection.session_id=session_id
        else:
            self.connection.login()

        #Dictionaries, keyed on their name, where all the nodes, links & groups will go
        self.hydra_nodes = {}
        self.hydra_links = {}
        self.hydra_groups = {}
        self.hydra_group_members = {}

        #Generators of NEGATIVE IDS for the nodes & links. 
        #Negative IDS are used as temporary client-side IDS until the network
        #is saved, at which point the resources will be given permanent, positive IDS.
        self.node_ids  = temp_ids()
        self.link_ids  = temp_ids()
        self.group_ids = temp_ids() # A group is an institution.
    
        #A mapping from the name of a type to the type itself.
        self.type_name_map = {}

        self.num_steps = 3
示例#2
0
    def get_network_data(self, network_id, scenario_id):
        """
            Retrieve the network, identify the parameters to set, 
            set them and run the model. Then identify the results
            and set them back on the network.
        """

        write_output("Retrieving Network")
        write_progress(2, self.num_steps)
        if network_id is not None:

            if scenario_id is None:
                raise HydraPluginError("A scenario ID must be specified.")

            #The network ID can be specified to get the network...
            try:
                network_id = int(network_id)
                network = self.connection.call(
                    'get_network', {
                        'network_id': network_id,
                        'scenario_ids': [int(scenario_id)]
                    })

                write_output("Network retrieved")
            except Exception, e:
                log.exception(e)
                raise HydraPluginError("Network %s not found." % network_id)
示例#3
0
    def __init__(self, url=None, session_id=None):

        self.json_net = None

        self.warnings = []
        self.files    = []
        self.template = None
        self.attributes = []
        self.attr_name_map = {}

        self.nodes = {}
        self.links = {}
        self.groups = {}
        
        self.node_id  = PluginLib.temp_ids()
        self.link_id  = PluginLib.temp_ids()
        self.group_id  = PluginLib.temp_ids()

        self.connection = JsonConnection(url)
        if session_id is not None:
            write_output("Using existing session %s"% session_id)
            self.connection.session_id=session_id
        else:
            self.connection.login()

        #3 steps: start, read, save 
        self.num_steps = 3
示例#4
0
    def __init__(self, url=None, session_id=None):

        self.json_net = None

        self.warnings = []
        self.files = []
        self.template = None
        self.attributes = []
        self.attr_name_map = {}

        self.nodes = {}
        self.links = {}
        self.groups = {}

        self.node_id = PluginLib.temp_ids()
        self.link_id = PluginLib.temp_ids()
        self.group_id = PluginLib.temp_ids()

        self.connection = JsonConnection(url)
        if session_id is not None:
            write_output("Using existing session %s" % session_id)
            self.connection.session_id = session_id
        else:
            self.connection.login()

        #3 steps: start, read, save
        self.num_steps = 3
示例#5
0
    def import_scenario(self):
        
        for n in self.network.nodes:
            self.hydra_nodes[n.name] = n
        for l in self.network.links:
            self.hydra_links[l.name] = l
        for g in self.network.resourcegroups:
            self.hydra_groups[g.name] = g

        hydra_group_members = []
        for j_inst in self._network.institutions:
            group_id = self.hydra_groups[j_inst.name].id

            for n in j_inst.nodes:
                hydra_group_members.append(
                {
                    'ref_key':'NODE',
                    'ref_id' : self.hydra_nodes[n.name]['id'],
                    'group_id' : group_id, 
                }
                )

            for l in j_inst.links:
                hydra_group_members.append(
                {
                    'ref_key':'LINK',
                    'ref_id' : self.hydra_links[l.name]['id'],
                    'group_id' : group_id, 
                }
                )
            for i in j_inst.institutions:
                hydra_group_members.append(
                {
                    'ref_key':'GROUP',
                    'ref_id' : self.hydra_groups[i.name]['id'],
                    'group_id' : group_id, 
                }
                )

        scenario = dict(
            name = "Baseline",
            description = "Scenario imported from the import app",
            network_id = self.network.id,
            resourcegroupitems = hydra_group_members,
            resourcescenarios  = []
        )

        write_output("Finished Writing Output.")

        self.scenario = self.connection.call('add_scenario', {
            'network_id': self.network.id,
            'scen':scenario})

        return self.scenario
示例#6
0
    def fetch_remote_network(self):
        """
            Request the hobbes network from the hobbes server
        """
        write_output("Fetching Network") 
        write_progress(2, self.num_steps)

        net_response = requests.get("http://cwn.casil.ucdavis.edu/network/get") #JSON Network
        #http://cwn.casil.ucdavis.edu/excel/create?prmname=SR_CLE    #XLS

        if net_response.status_code != 200:
            raise HydraPluginError("A connection error has occurred with status code: %s"%net_response.status_code)

        self.json_net = json.loads(net_response.content)
示例#7
0
    def fetch_remote_network(self):
        """
            Request the hobbes network from the hobbes server
        """
        write_output("Fetching Network")
        write_progress(2, self.num_steps)

        net_response = requests.get(
            "http://cwn.casil.ucdavis.edu/network/get")  #JSON Network
        #http://cwn.casil.ucdavis.edu/excel/create?prmname=SR_CLE    #XLS

        if net_response.status_code != 200:
            raise HydraPluginError(
                "A connection error has occurred with status code: %s" %
                net_response.status_code)

        self.json_net = json.loads(net_response.content)
示例#8
0
    def __init__(self, url=None, session_id=None):

        #Record the names of the files created by the plugin so we can
        #display them to the user.
        self.files = []

        #A mapping from attr ID to attr object. Makes searching for attributes
        #easier
        self.attr_id_map = {}

        self.connection = JsonConnection(url)
        write_output("Connecting...")
        if session_id is not None:
            write_output("Using existing session %s" % session_id)
            self.connection.session_id = session_id
        else:
            self.connection.login()

        self.network = None

        self.num_steps = 3
示例#9
0
    def write_network(self, network, target_dir):
        write_output("Writing network to file")
        write_progress(3, self.num_steps)

        if self.as_xml is False:
            file_name = "network_%s.json" % (network['name'])
            self.files.append(os.path.join(target_dir, file_name))

            network_file = open(os.path.join(target_dir, file_name), 'w')
            network_file.write(
                json.dumps(network,
                           sort_keys=True,
                           indent=4,
                           separators=(',', ': ')))
        else:
            file_name = "network_%s.xml" % (network['name'])
            self.files.append(os.path.join(target_dir, file_name))

            network_file = open(os.path.join(target_dir, file_name), 'w')
            json_network = {'network': network}
            network_file.write(json2xml(json_network))

        write_output("Network Written to %s " % (target_dir))
示例#10
0
                        plug-in connects.''')
    parser.add_argument(
        '-c',
        '--session-id',
        help='''Session ID. If this does not exist, a login will be
                        attempted based on details in config.''')
    return parser


if __name__ == '__main__':
    parser = commandline_parser()
    args = parser.parse_args()
    jp_runner = ModelRunner(url=args.server_url, session_id=args.session_id)
    errors = []
    try:
        write_output("Starting App")
        write_progress(1, jp_runner.num_steps)

        validate_plugin_xml(os.path.join(__location__, 'plugin.xml'))

        jp_runner.get_network_data(args.network_id, args.scenario_id)
        jp_runner.run_model()
        message = "Model Run Complete"
    except HydraPluginError as e:
        message = "An error has occurred"
        errors = [e.message]
        log.exception(e)
    except Exception, e:
        message = "An error has occurred"
        log.exception(e)
        errors = [e]
示例#11
0
    def import_network_topology(self, project_id=None):
        """
            Read the file containing the network data and send it to
            the server.
        """

        if self.json_net is None:
            self.fetch_remote_network()

        for node in self.json_net:
            props = node['properties']
            node_type = props['type']
            node_coords = node['geometry']['coordinates']
            
            tmp_node_id = self.node_id.next()

            #TODO: HACK. WHy are there 2 coordinates for the node?
            if isinstance(node_coords[0], list):
                #log.debug("Using 1st coords of %s (%s)", node_coords, props['type'])
                node_coords = node_coords[0]

            #log.info("X=%s, y=%s",node_coords[0], node_coords[1]) 
            node = dict(
                id = tmp_node_id,
                name = props['prmname'],
                x = str(node_coords[0]), #swap these if they are lat-long, not x-y
                y = str(node_coords[1]),
                description = props['description'],
                attributes = [],
                types = [{'template_id':self.template.id,
                          'id':node_type}]
            )
            self.nodes[props['prmname']] = node

            #ATTRIBUTES

            #Find the matching type
            for t in self.template.types:
                if t.name == node_type:
                    node['types'][0]['id'] = t.id
                    #Assign the attributes to the node
                    for tattr in t.typeattrs:
                        node['attributes'].append(
                            {'attr_id':tattr.attr_id}
                        )

            inlinks = [o['link_prmname'] for o in props.get('origins', [])]
            for linkname in inlinks:
                if linkname not in self.links:
                    link = dict(
                        id=self.link_id.next(),
                        name = linkname,
                        node_2_id = tmp_node_id,
                        attributes = [],
                        description = "",
                    )
                    self.links[linkname] = link
                else:
                    link = self.links[linkname]
                    link['node_2_id'] = tmp_node_id


            outlinks = [o['link_prmname'] for o in props.get('terminals', [])]
            for linkname in outlinks:
                if linkname not in self.links:
                    link = dict(
                        id=self.link_id.next(),
                        name = linkname,
                        node_1_id = tmp_node_id,
                        attributes = [],
                        description = "",
                    )
                    self.links[linkname] = link
                else:
                    link = self.links[linkname]
                    link['node_1_id'] = tmp_node_id

            node_groups = props['regions']

        project = self.fetch_project(project_id)
        project_id = project.id

        write_output("Saving Network") 
        write_progress(3, self.num_steps) 

        for t in self.template.types:
            if t.name == 'HobbesNetwork':
                network_type = t.id
        hydra_network = {
            'name' : "HOBBES Network (%s)"%datetime.now(),
            'description' : "Hobbes Network, imported directly from the web API",
            'nodes': self.nodes.values(),
            'links': self.links.values(),
            'project_id' : project_id,
            'projection':'EPSG:2229',
            'groups'   : [],
            'scenarios': [],
            'types'    : [{'template_id':self.template.id,
                          'id':network_type}]
        }

        #The network ID can be specified to get the network...
        self.network = self.connection.call('add_network', {'net':hydra_network})
        return self.network
示例#12
0
    def import_network(self, template_id, project_id):
        write_output("Writing network to file")
        write_progress(3, self.num_steps)

        for j_node in self._network.nodes:
            
            log.info("Node: %s", j_node.component_type)
            node_type = self.type_name_map.get(j_node.component_type)

            y = j_node.y
            if y > 800000:
                y = y - 1000000
            elif y > 400000:
                y = y - 400000

            node = dict(
                id = self.node_ids.next(),
                name = j_node.name,
                description = " Node",
                x    = str(j_node.x),
                y    = str(y),
                attributes = [],
                types = [{'template_id':int(template_id), 'id':int(node_type.id)}]
            )
            self.hydra_nodes[j_node.name] = node

        for j_link in self._network.links:
            link_type = self.type_name_map.get(j_link.component_type)
            log.info("Link: %s", j_link.component_type)
            link = dict(
                id = self.link_ids.next(),
                name = j_link.name,
                description = " Link",
                node_1_id = self.hydra_nodes[j_link.start_node.name]['id'],
                node_2_id = self.hydra_nodes[j_link.end_node.name]['id'],
                attributes = [],
                types = [{'template_id':int(template_id), 'id':link_type.id}]
            )
            self.hydra_links[j_link.name] = link


        for j_inst in self._network.institutions:
            group_type = self.type_name_map.get(j_inst.component_type)
            log.info("Group: %s", j_inst.component_type)
            group = dict(
                id = self.group_ids.next(),
                name = j_inst.name,
                description = "A  Model Institution",
                attributes = [],
                types = [{'template_id':int(template_id), 'id':group_type.id}]
            )
            self.hydra_groups[j_inst.name] = group

        project = self.fetch_project(project_id)
        project_id = project.id

        network_type = self.type_name_map.get('Network')

        hydra_network = {
            'name' : " Network (%s)"%datetime.now(),
            'description' : " Network, imported directly from the prototype",
            'nodes': self.hydra_nodes.values(),
            'links': self.hydra_links.values(),
            'project_id' : project_id,
            'projection':'EPSG:2229',
            'resourcegroups': self.hydra_groups.values(),
            'scenarios': [],
            'types' : [{'template_id':int(template_id), 'id':network_type.id}],
        }

        self.network = self.connection.call('add_network', {'net':hydra_network})
        return self.network
示例#13
0
    def import_network_topology(self, project_id=None):
        """
            Read the file containing the network data and send it to
            the server.
        """

        if self.json_net is None:
            self.fetch_remote_network()

        for node in self.json_net:
            props = node['properties']
            node_type = props['type']
            node_coords = node['geometry']['coordinates']

            tmp_node_id = self.node_id.next()

            #TODO: HACK. WHy are there 2 coordinates for the node?
            if isinstance(node_coords[0], list):
                #log.debug("Using 1st coords of %s (%s)", node_coords, props['type'])
                node_coords = node_coords[0]

            #log.info("X=%s, y=%s",node_coords[0], node_coords[1])
            node = dict(
                id=tmp_node_id,
                name=props['prmname'],
                x=str(
                    node_coords[0]),  #swap these if they are lat-long, not x-y
                y=str(node_coords[1]),
                description=props['description'],
                attributes=[],
                types=[{
                    'template_id': self.template.id,
                    'id': node_type
                }])
            self.nodes[props['prmname']] = node

            #ATTRIBUTES

            #Find the matching type
            for t in self.template.types:
                if t.name == node_type:
                    node['types'][0]['id'] = t.id
                    #Assign the attributes to the node
                    for tattr in t.typeattrs:
                        node['attributes'].append({'attr_id': tattr.attr_id})

            inlinks = [o['link_prmname'] for o in props.get('origins', [])]
            for linkname in inlinks:
                if linkname not in self.links:
                    link = dict(
                        id=self.link_id.next(),
                        name=linkname,
                        node_2_id=tmp_node_id,
                        attributes=[],
                        description="",
                    )
                    self.links[linkname] = link
                else:
                    link = self.links[linkname]
                    link['node_2_id'] = tmp_node_id

            outlinks = [o['link_prmname'] for o in props.get('terminals', [])]
            for linkname in outlinks:
                if linkname not in self.links:
                    link = dict(
                        id=self.link_id.next(),
                        name=linkname,
                        node_1_id=tmp_node_id,
                        attributes=[],
                        description="",
                    )
                    self.links[linkname] = link
                else:
                    link = self.links[linkname]
                    link['node_1_id'] = tmp_node_id

            node_groups = props['regions']

        project = self.fetch_project(project_id)
        project_id = project.id

        write_output("Saving Network")
        write_progress(3, self.num_steps)

        for t in self.template.types:
            if t.name == 'HobbesNetwork':
                network_type = t.id
        hydra_network = {
            'name': "HOBBES Network (%s)" % datetime.now(),
            'description':
            "Hobbes Network, imported directly from the web API",
            'nodes': self.nodes.values(),
            'links': self.links.values(),
            'project_id': project_id,
            'projection': 'EPSG:2229',
            'groups': [],
            'scenarios': [],
            'types': [{
                'template_id': self.template.id,
                'id': network_type
            }]
        }

        #The network ID can be specified to get the network...
        self.network = self.connection.call('add_network',
                                            {'net': hydra_network})
        return self.network