Retrieves a partnership by its uri.

 @param [String] uri
 @param [Hash] options
 @return [Partnership]

 ====Examples
 @example
   partnership = @coach.partnership_by_uri '/CyberCoachServer/resources/partnerships/arueedlinger;asarteam5/'
545479
def partnership_by_uri(uri, options={})
      raise 'Error: Param uri is nil!' if uri.nil?

      url = url_for_uri(uri)
      url = append_query_params(url, options)
      client.get(url, options) do |response|
        a_hash = parse(response)
        Resource::Partnership.from_coach a_hash
      end
    end
446796
def uri_from_other_sources
      uri = nil
      source.remotes.each do |remote|
        break if uri

        uri = case remote.host
              when 'rubygems.org' then next # already checked
              when 'rails-assets.org'
                uri_from_railsassets
              else
                Bundler.ui.error "Source #{remote} is not supported, ' \
                  'feel free to open a PR or an issue on https://github.com/MaximeD/gem_updater"
              end
      end

      uri
    end
286867
def get(url, options={}, &block)
      http_options = options.merge(@basic_options)
      if block_given?
        RestClient.get(url, http_options, &block)
      else
        RestClient.get(url, http_options)
      end
    end
1215389
def join_uri(scheme, userinfo, host, port, registry, path, opaque, query, fragment)
      URI::Generic.new(scheme, userinfo, host, port, registry, path, opaque, query, fragment).to_s
    end
314863
def opts_from_url(url)
      url = URI.parse(url) unless url.is_a?(URI)
      opts_from_non_params(url).merge opts_from_params(url.query)
    rescue URI::InvalidURIError
      {}
    end
543566
def get_compatible_systems(self, id_or_uri):
        
        uri = self._client.build_uri(id_or_uri) + "/compatible-systems"
        return self._client.get(uri)
656757
public Optional<PartnerSubscription> show(long partnerId, long accountId, long subscriptionId)
    {
        return HTTP.GET(String.format("/v2/partners/%d/accounts/%d/subscriptions/%d", partnerId, accountId, subscriptionId), PARTNER_SUBSCRIPTION);
    }
620847
def gets
      begin
        data = make_http_request
        @hash = send(@@formats[@format][:oembed_parser], data) # Call the method specified in default_formats hash above
      rescue RuntimeError => e
        if e.message == "401"
          # Embedding disabled
          return nil        
        elsif e.message == "501"
          # Format not supported
          raise UnsupportedError, "#{@format} not supported by #{@domain}"
        elsif e.message == "404"
          # Not found
          raise Error, "#{@url} not found"
        else
          raise e
        end
      end
    end
1186049
def make_request_uri(uri, opts)
      uri = uri.to_s

      if default_options.persistent? && uri !~ HTTP_OR_HTTPS_RE
        uri = "#{default_options.persistent}#{uri}"
      end

      uri = HTTP::URI.parse uri

      if opts.params && !opts.params.empty?
        uri.query_values = uri.query_values(Array).to_a.concat(opts.params.to_a)
      end

      # Some proxies (seen on WEBRick) fail if URL has
      # empty path (e.g. `http://example.com`) while it's RFC-complaint:
      # http://tools.ietf.org/html/rfc1738#section-3.1
      uri.path = "/" if uri.path.empty?

      uri
    end
585216
def get(self, id_or_uri):
        
        uri = self.build_uri(id_or_uri)
        logger.debug('Get resource (uri = %s, ID = %s)' %
                     (uri, str(id_or_uri)))
        return self._connection.get(uri)
1225824
def connection_repo
      @options[:path] = API_REST + @options[:path]

      @options[:headers] = HEADERS.merge(AUTH_PREFIX => @final_hash[:creds]).merge(@options[:headers])

      text.msg('HTTP Request Data:')
      text.msg("> HTTP #{@options[:scheme]}://#{@options[:host]}")
      @options.each do |key, value|
        text.msg("> #{key}: #{value}")
      end
      text.msg('End HTTP Request Data.')
      if @options[:scheme] == 'https'
        @connection = Excon.new("#{@options[:scheme]}://#{@options[:host]}", @options)
      else
        Excon.defaults[:ssl_verify_peer] = false
        @connection = Excon.new("#{@options[:scheme]}://#{@options[:host]}:6001", @options)
      end
      @connection
      end
410977
def get(url, options = {})
      connection(url, options) do |uri, conn|
        conn.get(uri.request_uri, options)
      end
    end
1242424
def retrieve_asset(uri)
      uri = URI.join(full_source_uri, uri)
      cache(uri) do
        case
        when %w[http https].include?(uri.scheme)
          Net::HTTP.get(uri)
        when uri.scheme.eql?('file')
          File.read(uri.path)
        end
      end
    end
276649
def to_addressable_uri(uri)
      uri.nil? || uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri)
    end
109933
def get(resource_uri)
      result = connection.get("resource") do |request|
        request.query[:uri] = resource_uri.to_s
        request.query.delete(:graph)
      end
      MaybeGraphResult.new(result).value
    end
605982
def request(uri:, request_options: {}, parameters: {})
      opts = {
        uri: uri,
        request_options: request_options,
        parameters: @default_parameters.merge(parameters)
      }
      parse_response(http_service.perform_request(opts))
    end
529976
def get(self, uri):
        
        return self.send_request(
            "{0}://{1}:{2}{3}{4}".format(
                self.get_protocol(),
                self.host,
                self.port,
                uri,
                self.client_id
            )
        )