Get an instance of Api Networkv6 services facade.
3169
def create_api_network_ipv6(self):
        """"""

        return ApiNetworkIPv6(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
1232262
def instance_admin_api(self):
        """"""
        if self._instance_admin_api is None:
            self._instance_admin_api = InstanceAdminClient(
                credentials=self.credentials, client_info=_CLIENT_INFO
            )
        return self._instance_admin_api
1228999
def get_network_instances(self, name=''):
        """"""

        output = self._show_vrf()
        vrfs = {}
        all_vrf_interfaces = {}
        for vrf in output:
            if (vrf.get('route_distinguisher', '') == "<not set>" or
                    vrf.get('route_distinguisher', '') == 'None'):
                vrf['route_distinguisher'] = u''
            else:
                vrf['route_distinguisher'] = py23_compat.text_type(vrf['route_distinguisher'])
            interfaces = {}
            for interface_raw in vrf.get('interfaces', []):
                interface = interface_raw.split(',')
                for line in interface:
                    if line.strip() != '':
                        interfaces[py23_compat.text_type(line.strip())] = {}
                        all_vrf_interfaces[py23_compat.text_type(line.strip())] = {}

            vrfs[py23_compat.text_type(vrf['name'])] = {
                          u'name': py23_compat.text_type(vrf['name']),
                          u'type': u'L3VRF',
                          u'state': {
                              u'route_distinguisher': vrf['route_distinguisher'],
                          },
                          u'interfaces': {
                              u'interface': interfaces,
                          },
            }
        all_interfaces = self.get_interfaces_ip().keys()
        vrfs[u'default'] = {
            u'name': u'default',
            u'type': u'DEFAULT_INSTANCE',
            u'state': {
                u'route_distinguisher': u'',
            },
            u'interfaces': {
                u'interface': {
                    k: {} for k in all_interfaces if k not in all_vrf_interfaces.keys()
                },
            },
        }

        if name:
            if name in vrfs:
                return {py23_compat.text_type(name): vrfs[name]}
            return {}
        else:
            return vrfs
1198061
def get_instantiated_service(self, name):
        
        if name not in self.instantiated_services:
            raise UninstantiatedServiceException
        return self.instantiated_services[name]
520516
def create_api_equipment(self):
        """"""
        return ApiEquipment(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
506387
def _get_client():
        """"""
        return utils.get_client(url=CONFIG.HNV.url,
                                username=CONFIG.HNV.username,
                                password=CONFIG.HNV.password,
                                allow_insecure=CONFIG.HNV.https_allow_insecure,
                                ca_bundle=CONFIG.HNV.https_ca_bundle)
1330392
def get_instance(self, payload):
        
        return DomainInstance(self._version, payload, account_sid=self._solution['account_sid'], )
80884
def create_api_object_type(self):
        """"""

        return ApiObjectType(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
1207378
def get_api(self, name=None):
        """"""
        if name is None:
            try:
                return self.conf.get("api").copy()
            except:  # NOQA
                raise Exception(f"Couldn't find the API configuration")
780410
def get_api_services_by_name(self):
        """"""
        if not self.services_by_name:
            self.services_by_name = dict({s.get('name'): s for s in self.conf
                                          .get("api")
                                          .get("services")})
        return self.services_by_name
975757
def update(self, networkipv6s):
        

        data = {'networks': networkipv6s}
        networkipv6s_ids = [str(networkipv6.get('id'))
                            for networkipv6 in networkipv6s]

        return super(ApiNetworkIPv6, self).put('api/v3/networkv6/%s/' %
                                               ';'.join(networkipv6s_ids), data)
1101057
def create_api_vlan(self):
        """"""
        return ApiVlan(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
486416
def get_instance(self, payload):
        
        return MemberInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            channel_sid=self._solution['channel_sid'],
        )
1056876
def get_instance(self, payload):
        
        return BuildInstance(self._version, payload, service_sid=self._solution['service_sid'], )
1301113
public static ip6tunnelparam get(nitro_service service) throws Exception{
		ip6tunnelparam obj = new ip6tunnelparam();
		ip6tunnelparam[] response = (ip6tunnelparam[])obj.get_resources(service);
		return response[0];
	}
1320863
def create(self, ipv6s):
        

        data = {'ips': ipv6s}
        return super(ApiIPv6, self).post('api/v3/ipv6/', data)
941011
def get_by_id(self, id_networkv6):
        

        uri = 'api/networkv4/%s/' % id_networkv6
        return super(ApiNetworkIPv6, self).get(uri)