returns a publically accessable url for the system to save in its records
 Params:
 +obj+:: the URL object that you want to retrive a public URL for
336936
def unauthenticated_url(obj = nil)
      obj = obj.url_for(:read).to_s.split("?")[0] if !obj.nil?
      obj
    end
733245
def url(ref)
      config = self.class.config(@repo, ref)

      lookup = config.keys.inject({}) do |acc, key|
        id = config[key]['id']
        acc[id] = config[key]['url']
        acc
      end

      lookup[@id]
    end
1224751
def get_public_url(self, doc_id, branch='master'):
        
        name, path_frag = self.get_repo_and_path_fragment(doc_id)
        return 'https://raw.githubusercontent.com/OpenTreeOfLife/' + name + '/' + branch + '/' + path_frag
65261
public String getAccessURL() {
    if (mUsePublicURL) {
      LOG.trace("Using public URL: " + mAccess.getPublicURL());
      return mAccess.getPublicURL();
    }
    LOG.trace("Using internal URL: " + mAccess.getInternalURL());
    return mAccess.getInternalURL();
  }
1043454
def get_public_ip_address(ip_address)
      params = {
          'command' => 'listPublicIpAddresses',
          'ipaddress' => ip_address
      }
      json = send_request(params)
      return nil unless json['publicipaddress']
      json['publicipaddress'].first
    end
1005897
def get_url(access_token, endpoint=ams_rest_endpoint, flag=True):
    '''
    '''
    return do_ams_get_url(endpoint, access_token, flag)
855311
def public_url(self):
        
        return "{storage_base_url}/{bucket_name}/{quoted_name}".format(
            storage_base_url=_API_ACCESS_ENDPOINT,
            bucket_name=self.bucket.name,
            quoted_name=quote(self.name.encode("utf-8")),
        )
1290940
def _get_url(self, resource, item, sys_id=None):
        

        url_str = '%(base_url)s/%(base_path)s/%(resource)s/%(item)s' % (
            {
                'base_url': self.base_url,
                'base_path': self.base_path,
                'resource': resource,
                'item': item
            }
        )

        if sys_id:
            return "%s/%s" % (url_str, sys_id)

        return url_str
1262992
def child_url_record(self, url: str, inline: bool=False,
                         link_type: Optional[LinkType]=None,
                         post_data: Optional[str]=None,
                         level: Optional[int]=None):
        '''
        '''
        url_record = URLRecord()
        url_record.url = url
        url_record.status = Status.todo
        url_record.try_count = 0
        url_record.level = self.url_record.level + 1 if level is None else level
        url_record.root_url = self.url_record.root_url or self.url_record.url
        url_record.parent_url = self.url_record.url
        url_record.inline_level = (self.url_record.inline_level or 0) + 1 if inline else 0
        url_record.link_type = link_type
        url_record.post_data = post_data

        return url_record
195100
def url
      @url ||= if @collection.nil?
                 relative_path
               else
                 ::Bunto::URL.new({
                   :template     => @collection.url_template,
                   :placeholders => placeholders,
                 })
               end.to_s.gsub(%r!/$!, "")
    end
319109
def url(self):
        
        if self._href is not None:
            return self._href
        if self.identifier:
            #  for some reason atlas does not use classifications here in the path when considering one classification
            path = '/'.join([self.parent.url.replace('classifications/', 'classficiation/'), self.identifier])
            return path
        raise exceptions.ClientError("Not able to determine object URL")
1151556
def get_resource_url(self):
        

        name = self.__class__.resource_name
        url = self.__class__.rest_base_url()

        if self.id is not None:
            return "%s/%s/%s" % (url, name, self.id)

        return "%s/%s" % (url, name)
814063
def get_public_dsn(self, scheme=None):
        
        if self.is_enabled():
            url = self.remote.get_public_dsn()
            if scheme:
                return '%s:%s' % (scheme, url)

            return url
583555
def _permalink(self, absolute=False, expand=True, **kwargs):
        
        return flask.url_for('entry',
                             entry_id=self._record.id,
                             category=self._record.category if expand else None,
                             slug_text=self._record.slug_text if expand else None,
                             _external=absolute,
                             **kwargs)
113538
def get_admin_url(obj, page=None):
    """"""
    if obj is None:
        return None

    if page is None:
        page = "change"
    if page not in ADMIN_ALL_PAGES:
        raise ValueError("Invalid page name '{}'. Available pages are: {}.".format(page, ADMIN_ALL_PAGES))

    app_label = obj.__class__._meta.app_label
    object_name = obj.__class__._meta.object_name.lower()

    if page in ADMIN_GLOBAL_PAGES:
        url_name = page
    else:
        url_name = "{}_{}_{}".format(app_label, object_name, page)

    if page == "app_list":
        url_args = (app_label,)
    elif page == "view_on_site":
        content_type = ContentType.objects.get_for_model(obj.__class__)
        url_args = (content_type, obj._get_pk_val())
    elif page in ADMIN_DETAIL_PAGES:
        url_args = (obj._get_pk_val(),)
    else:
        url_args = None

    return reverse("admin:{}".format(url_name), args=url_args)
525169
def _get_url(url):
        
        if isinstance(url, urlparse.ParseResult):
            return urlparse.urlunparse(url)
        else:
            return url
770065
def img_url(obj, profile_app_name, profile_model_name):
    
    try:
        content_type = ContentType.objects.get(
            app_label=profile_app_name,
            model=profile_model_name.lower()
        )
    except ContentType.DoesNotExist:
        return ""
    except AttributeError:
        return ""

    Profile = content_type.model_class()
    fields = Profile._meta.get_fields()
    profile = content_type.model_class().objects.get(user=obj.user)
    for field in fields:
        if hasattr(field, "upload_to"):
            return field.value_from_object(profile).url