Read the secret at the given path. If the secret does not exist, +nil+
 will be returned.

 @example
   Vault.logical.read("secret/password") #=> #<Vault::Secret lease_id="">

 @param [String] path
   the path to read

 @return [Secret, nil]
182026
def read(path, options = {})
      headers = extract_headers!(options)
      json = client.get("/v1/#{encode_path(path)}", {}, headers)
      return Secret.decode(json)
    rescue HTTPError => e
      return nil if e.code == 404
      raise
    end
398698
def load!(path)
      settings = YAML.load(ERB.new(File.new(path).read).result)
      if settings.present?
        from_hash(settings)
      end
    end
310493
def path_to_routing_key(path)
      new_path = ""
      path.split('').each_with_index do |c,i|
        if c == '/' and i != 0 and i != path.length-1
          new_path += '.'
        elsif c != '/'
          new_path += c
        end
      end
      new_path
    end
98674
def read_data_file(path)
      case File.extname(path).downcase
      when ".csv"
        CSV.read(path,
                 :headers  => true,
                 :encoding => site.config["encoding"]).map(&:to_hash)
      when ".tsv"
        CSV.read(path,
                 :col_sep  => "\t",
                 :headers  => true,
                 :encoding => site.config["encoding"]).map(&:to_hash)
      else
        SafeYAML.load_file(path)
      end
    end
211371
def get_key(keyfile=None):
    
    keyfile = keyfile or application_path(settings.SECRETKEY.SECRET_FILE)
    with file(keyfile, 'rb') as f:
        return f.read()
1298878
function get(path) {
  return splitPath(path).concat('@').reduce(function (t, segment) {
    return t ? t[segment]
             : undefined
  }, this)
}
389862
def read_data_file(path)
      case File.extname(path).downcase
      when ".csv"
        CSV.read(path, {
          :headers  => true,
          :encoding => site.config["encoding"],
        }).map(&:to_hash)
      else
        SafeYAML.load_file(path)
      end
    end
648180
def get(path, params = nil, headers = {})
      response = http_client.get(
        path: path,
        query: encode_params(params),
        headers: request_headers(headers)
      )
      if response.status == 200
        parse_response(response)
      else
        handle_error_response(response)
      end
    end
449146
def _fetch_secrets(vault_url, path, token):
        """"""
        url = _url_joiner(vault_url, 'v1', path)
        resp = requests.get(url, headers=VaultLoader._get_headers(token))
        resp.raise_for_status()
        data = resp.json()
        if data.get('errors'):
            raise VaultException(u'Error fetching Vault secrets from path {}: {}'
                                 .format(path, data['errors']))
        return data['data']
767395
def get(path, params = nil, headers = {}, auth = true)
      request(path: path, query: params, headers: headers, auth: auth)
    end
1931
def read(in_path):
    
    assert os.path.exists(in_path), "The following GRP file can't be found. in_path: {}".format(in_path)

    with open(in_path, "r") as f:
        lines = f.readlines()
        # need the second conditional to ignore comment lines
        grp = [line.strip() for line in lines if line and not re.match("^#", line)]

    return grp
1029185
def parse_file_content(file_path)
      text = ::File.read(file_path)
      tokens = text.split(%r{^\[(.*?)\]\r?\n})
      tokens.shift # first item should be blank
      tokens.in_groups_of(2).each_with_object({}) do |pair, h|
        h[pair[0]] = pair[1]
      end
    end
1154891
def get(path, params={})
      dont_parse_response = params.delete(:dont_parse_response)

      options = {
        :content_type => :json, 
        :accept => :json, 
        :params => params.merge(:apikey => @api_key, :source => @source)
      }

      RestClient.get("#{@litmosURL}/#{path}", options) do |response, request, result|
        case response.code
        when 200, 201 
          # 200 Success. User/Course etc updated, deleted or retrieved
          # 201 Success. User/Course etc created
          if response.blank?
            true
          else
            if dont_parse_response
              response
            else
              parse_response(response)
            end
          end
        when 404 # 404 Not Found. The User/Course etc that you requested does not exist
          raise NotFound.new(response)

        else
          # 400 Bad Request. Check that your Uri and request body is well formed
          # 403 Forbidden. Check your API key, HTTPS setting, Source parameter etc
          # 409 Conflict. Often occurs when trying to create an item that already exists
          raise ApiError.new(response)

        end        
      end
    end
1047854
def get(path)
      tmp = Rudy::Backup.new path
      backups = Rudy::Backups.list :path => path
      return nil unless backups.is_a?(Array) && !backups.empty?
      backups.first
    end
699159
func (v *Vault) Read(path string) ([]byte, error) {
	secret, err := v.client.Logical().Read(path)
	if err != nil {
		return nil, err
	}
	if secret == nil {
		return []byte{}, nil
	}

	var buf bytes.Buffer
	enc := json.NewEncoder(&buf)
	if err := enc.Encode(secret.Data); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}
8203
def query_key(path)
      i = 0
      path.map do |v|
        i += 1
        if i != 1
          "[#{v}]"
        else
          v
        end
      end.join('')
    end
837638
def get(path, params = {}, header = {})
      _send(Net::HTTP::Get.new(expand_path(path, params), expand_header(header)))
    end