text:
/**
 * Copyright (c) 2018 Dell Inc., or its subsidiaries. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 */

package util

import (
	"fmt"
	"reflect"
	"regexp"
	"strconv"
	"strings"

	v "github.com/hashicorp/go-version"
	corev1 "k8s.io/api/core/v1"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

var (
	versionRegexp *regexp.Regexp
)

const (
	healthcheckVersion      string = "0.10.0"
	MajorMinorVersionRegexp string = `^v?(?P<Version>[0-9]+\.[0-9]+\.[0-9]+)`
)

func init() {
	versionRegexp = regexp.MustCompile(MajorMinorVersionRegexp)
}

// function to check if v1 is below v2 or not
func IsVersionBelow(v1 string, v2 string) bool {
	if v1 == "" {
		return true
	}
	if v2 == "" {
		return false
	}
	result, _ := CompareVersions(v1, v2, "<")
	if result {
		return true
	}
	return false
}

func CompareConfigMap(cm1 *corev1.ConfigMap, cm2 *corev1.ConfigMap) bool {
	eq := reflect.DeepEqual(cm1.Data, cm2.Data)
	if eq {
		return true
	}
	return false
}

func IsOrphan(k8sObjectName string, replicas int32) bool {
	index := strings.LastIndexAny(k8sObjectName, "-")
	if index == -1 {
		return false
	}

	ordinal, err := strconv.Atoi(k8sObjectName[index+1:])
	if err != nil {
		return false
	}

	return int32(ordinal) >= replicas
}

func HealthcheckCommand(version string, port int32, restport int32) []string {
	command := ""
	if IsVersionBelow(version, healthcheckVersion) {
		command = fmt.Sprintf("netstat -ltn 2> /dev/null | grep %d || ss -ltn 2> /dev/null | grep %d", port, port)
	} else {
		command = fmt.Sprintf("curl -s -X GET 'http://localhost:%d/v1/health/liveness' || curl -s -k -X GET 'https://localhost:%d/v1/health/liveness'", restport, restport)
	}
	return []string{"/bin/sh", "-c", command}
}

func ControllerReadinessCheck(version string, port int32, authflag bool) []string {
	command := ""
	if IsVersionBelow(version, healthcheckVersion) {
		//This function check for the readiness of the controller in the following cases
		//1) Auth and TLS Enabled- in this case, we check if the controller is properly enabled with authentication or not and we do a get on controller and with dummy credentials(testtls:testtls) and the controller returns 401 error in this case if it's correctly configured
		//2) Auth Enabled and TLS Disabled- in this case, we check if the controller is properly enabled with authentication or not and we do a get on controller and with dummy credentials(testtls:testtls) and the controller returns 401 error in this case if it's correctly configured
		//3) Auth Disabled and TLS Enabled- in this case, we check if the controller can create scopes or not by checking if _system scope is present or not
		//4) Auth and TLS Disabled- in this case, we check if the controller can create scopes or not by checking if _system scope is present or not
		if authflag == true {
			// This is to check the readiness of controller in case auth is Enabled
			// here we are using login credential as testtls:testtls which should
			// not be used as auth credential and we depend on controller giving us
			// 401 error which means controller is properly configured with auth
			// it checks both cases when tls is enabled as well as tls disabled
			// with auth enabled
			command = fmt.Sprintf("echo $JAVA_OPTS | grep 'controller.auth.tlsEnabled=true' &&  curl -v -k -u testtls:testtls -s -X GET 'https://localhost:%d/v1/scopes/' 2>&1 -H 'accept: application/json' | grep 401 || (echo $JAVA_OPTS | grep 'controller.auth.tlsEnabled=false' && curl -v -k -u testtls:testtls -s -X GET 'http://localhost:%d/v1/scopes/' 2>&1 -H 'accept: application/json' | grep 401 ) ||  (echo $JAVA_OPTS | grep 'controller.security.tls.enable=true' && echo $JAVA_OPTS | grep -v 'controller.auth.tlsEnabled' && curl -v -k -u testtls:testtls -s -X GET 'https://localhost:%d/v1/scopes/' 2>&1 -H 'accept: application/json' | grep 401 ) || (curl -v -k -u testtls:testtls -s -X GET 'http://localhost:%d/v1/scopes/' 2>&1 -H 'accept: application/json' | grep 401 )", port, port, port, port)
		} else {
			// This is to check the readiness in case auth is not enabled
			// and it covers both the cases with tls enabled and tls disabled
			// along with auth disabled
			command = fmt.Sprintf("echo $JAVA_OPTS | grep 'controller.auth.tlsEnabled=true' &&  curl -s -X GET 'https://localhost:%d/v1/scopes/' -H 'accept: application/json' | grep '_system'|| (echo $JAVA_OPTS | grep 'controller.auth.tlsEnabled=false' && curl -s -X GET 'http://localhost:%d/v1/scopes/' -H 'accept: application/json' | grep '_system' ) || (echo $JAVA_OPTS | grep 'controller.security.tls.enable=true' && echo $JAVA_OPTS | grep -v 'controller.auth.tlsEnabled' && curl -s -X GET 'https://localhost:%d/v1/scopes/' -H 'accept: application/json' | grep '_system' ) || (curl -s -X GET 'http://localhost:%d/v1/scopes/' -H 'accept: application/json' | grep '_system') ", port, port, port, port)
		}
	} else {
		command = fmt.Sprintf("curl -s -X GET 'http://localhost:%d/v1/health/readiness' || curl -s -k -X GET 'https://localhost:%d/v1/health/readiness'", port, port)
	}
	return []string{"/bin/sh", "-c", command}
}

func SegmentStoreReadinessCheck(version string, port int32, restport int32) []string {
	command := ""
	if IsVersionBelow(version, healthcheckVersion) {
		command = fmt.Sprintf("netstat -ltn 2> /dev/null | grep %d || ss -ltn 2> /dev/null | grep %d", port, port)
	} else {
		command = fmt.Sprintf("curl -s -X GET 'http://localhost:%d/v1/health/readiness' || curl -s -k -X GET 'https://localhost:%d/v1/health/readiness'", restport, restport)
	}
	return []string{"/bin/sh", "-c", command}
}

// Min returns the smaller of x or y.
func Min(x, y int32) int32 {
	if x > y {
		return y
	}
	return x
}

func ContainsString(slice []string, str string) bool {
	for _, item := range slice {
		if item == str {
			return true
		}
	}
	return false
}

func RemoveString(slice []string, str string) (result []string) {
	for _, item := range slice {
		if item == str {
			continue
		}
		result = append(result, item)
	}
	return result
}

func GetPodVersion(pod *v1.Pod) string {
	return pod.GetAnnotations()["pravega.version"]
}

func CompareVersions(v1, v2, operator string) (bool, error) {
	normv1, err := NormalizeVersion(v1)
	if err != nil {
		return false, err
	}
	normv2, err := NormalizeVersion(v2)
	if err != nil {
		return false, err
	}
	clusterVersion, err := v.NewSemver(normv1)
	if err != nil {
		return false, err
	}
	constraints, err := v.NewConstraint(fmt.Sprintf("%s %s", operator, normv2))
	if err != nil {
		return false, err
	}
	return constraints.Check(clusterVersion), nil
}

func ContainsVersion(list []string, version string) bool {
	result := false
	for _, v := range list {
		if result, _ = CompareVersions(version, v, "="); result {
			break
		}
	}
	return result
}

func NormalizeVersion(version string) (string, error) {
	matches := versionRegexp.FindStringSubmatch(version)
	if matches == nil || len(matches) <= 1 {
		return "", fmt.Errorf("failed to parse version %s", version)
	}
	return matches[1], nil
}

// OrderedMap is a map that has insertion order when iterating. The iteration of
// map in GO is in random order by default.
type OrderedMap struct {
	m    map[string]string
	keys []string
}

// This method will parse the JVM options into a key value pair and store it
// in the OrderedMap
func UpdateOneJVMOption(arg string, om *OrderedMap) {
	// Parse "-Xms"
	if strings.HasPrefix(arg, "-Xms") {
		if _, ok := om.m["-Xms"]; !ok {
			om.keys = append(om.keys, "-Xms")
		}
		om.m["-Xms"] = arg[4:]
		return
	}

	// Parse option starting with "-XX"
	if strings.HasPrefix(arg, "-XX:") {
		if arg[4] == '+' || arg[4] == '-' {
			if _, ok := om.m[arg[5:]]; !ok {
				om.keys = append(om.keys, arg[5:])
			}
			om.m[arg[5:]] = string(arg[4])
			return
		}
		s := strings.Split(arg[4:], "=")
		if _, ok := om.m[s[0]]; !ok {
			om.keys = append(om.keys, s[0])
		}
		om.m[s[0]] = s[1]
		return
	}

	// Not in those formats, just keep the option as a key
	if _, ok := om.m[arg]; !ok {
		om.keys = append(om.keys, arg)
	}
	om.m[arg] = ""
	return
}

// Concatenate the key value pair to be a JVM option string.
func GenerateJVMOption(k, v string) string {
	if v == "" {
		return k
	}

	if k == "-Xms" {
		return fmt.Sprintf("%v%v", k, v)
	}

	if v == "+" || v == "-" {
		return fmt.Sprintf("-XX:%v%v", v, k)
	}

	return fmt.Sprintf("-XX:%v=%v", k, v)
}

// This method will override the default JVM options with user provided custom options
func OverrideDefaultJVMOptions(defaultOpts []string, customOpts []string) []string {

	// Nothing to be overriden, just return the default options
	if customOpts == nil {
		return defaultOpts
	}

	om := &OrderedMap{m: map[string]string{}, keys: []string{}}

	// Firstly, store the default options in an ordered map. The ordered map is a
	// map that has insertion order guarantee when iterating.
	for _, option := range defaultOpts {
		UpdateOneJVMOption(option, om)
	}

	// Secondly, update the ordered map with custom options. If the option has been
	// found in the map, its value will be updated by the custom options. If not, the
	// the map will just add a new key value pair.
	for _, option := range customOpts {
		UpdateOneJVMOption(option, om)
	}

	jvmOpts := []string{}
	// Iterate the ordered map in its insertion order.
	for _, key := range om.keys {
		jvmOpts = append(jvmOpts, GenerateJVMOption(key, om.m[key]))
	}

	return jvmOpts
}

func IsPodReady(pod *corev1.Pod) bool {
	for _, condition := range pod.Status.Conditions {
		if condition.Type == corev1.PodReady && condition.Status == corev1.ConditionTrue {
			return true
		}
	}
	return false
}

func IsPravegaContainer(container corev1.ContainerStatus) bool {
	return container.Name == "pravega-controller" || container.Name == "pravega-segmentstore"
}

func IsPodFaulty(pod *corev1.Pod) (bool, error) {
	for _, container := range pod.Status.ContainerStatuses {
		if IsPravegaContainer(container) && container.State.Waiting != nil && (container.State.Waiting.Reason == "ImagePullBackOff" ||
			container.State.Waiting.Reason == "CrashLoopBackOff") {
			return true, fmt.Errorf("pod %s update failed because of %s", pod.Name, container.State.Waiting.Reason)
		}
	}
	return false, nil
}

func DownwardAPIEnv() []corev1.EnvVar {
	return []corev1.EnvVar{
		{
			Name: "POD_NAME",
			ValueFrom: &corev1.EnvVarSource{
				FieldRef: &corev1.ObjectFieldSelector{
					APIVersion: "v1",
					FieldPath:  "metadata.name",
				},
			},
		},
		{
			Name: "POD_NAMESPACE",
			ValueFrom: &corev1.EnvVarSource{
				FieldRef: &corev1.ObjectFieldSelector{
					APIVersion: "v1",
					FieldPath:  "metadata.namespace",
				},
			},
		},
	}
}

func PodAntiAffinity(component string, clusterName string) *corev1.Affinity {
	return &corev1.Affinity{
		PodAntiAffinity: &corev1.PodAntiAffinity{
			PreferredDuringSchedulingIgnoredDuringExecution: []corev1.WeightedPodAffinityTerm{
				{
					Weight: 100,
					PodAffinityTerm: corev1.PodAffinityTerm{
						LabelSelector: &metav1.LabelSelector{
							MatchExpressions: []metav1.LabelSelectorRequirement{
								{
									Key:      "component",
									Operator: metav1.LabelSelectorOpIn,
									Values:   []string{component},
								},
								{
									Key:      "pravega_cluster",
									Operator: metav1.LabelSelectorOpIn,
									Values:   []string{clusterName},
								},
							},
						},
						TopologyKey: "kubernetes.io/hostname",
					},
				},
			},
		},
	}
}

repository: pravega/pravega-operator

repo_name: pravega/pravega-operator


text:
@book{menichinelli_openp2pdesign.org_1.1._2008,
 author = {Menichinelli, Massimo},
 copyright = {All rights reserved},
 title = {openp2pdesign.org_1.1. Design for Complexity},
 url = {http://issuu.com/openp2pdesign/docs/openp2pdesign.org_1.1_english},
 year = {2008}
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

gha_license_id: MIT

extension: bib


text:
package listener_test

import (
	"fmt"

	"github.com/int128/listener"
)

// ExampleNew allocates a net.Listener at port 18000 or 28000.
func ExampleNew() {
	l, err := listener.New([]string{"127.0.0.1:18000", "127.0.0.1:28000"})
	if err != nil {
		panic(err)
	}
	defer l.Close()

	fmt.Printf("Open %s", l.URL)

	// Output:
	// Open http://localhost:18000
}

gha_language: Go

extension: go


text:
package process

import (
	"io"
	"os"
	"path/filepath"
	"time"

	"github.com/1dustindavis/gorilla/pkg/catalog"
	"github.com/1dustindavis/gorilla/pkg/config"
	"github.com/1dustindavis/gorilla/pkg/gorillalog"
	"github.com/1dustindavis/gorilla/pkg/installer"
	"github.com/1dustindavis/gorilla/pkg/manifest"
)

//Manifests iterates though the first manifest and any included manifests
func Manifests(manifests []manifest.Item, catalog map[string]catalog.Item) (installs, uninstalls, updates []string) {
	// Compile all of the installs, uninstalls, and updates into arrays
	for _, manifestItem := range manifests {
		// Installs
		for _, item := range manifestItem.Installs {
			if item != "" && catalog[item].InstallerItemLocation != "" {
				installs = append(installs, item)
			}
		}
		// Uninstalls
		for _, item := range manifestItem.Uninstalls {
			if item != "" {
				uninstalls = append(uninstalls, item)
			}
		}
		// Updates
		for _, item := range manifestItem.Updates {
			if item != "" {
				updates = append(updates, item)
			}
		}
	}
	return
}

// Installs prepares and then installs and array of items
func Installs(installs []string, catalog map[string]catalog.Item) {
	// Iterate through the installs array, install dependencies, and then the item itself
	for _, item := range installs {
		// Check for dependencies and install if found
		if len(catalog[item].Dependencies) > 0 {
			for _, dependency := range catalog[item].Dependencies {
				installer.Install(catalog[dependency])
			}
		}
		// Install the item
		installer.Install(catalog[item])
	}
}

// Uninstalls prepares and then installs and array of items
func Uninstalls(uninstalls []string, catalog map[string]catalog.Item) {
	// Iterate through the uninstalls array and uninstall the item
	for _, item := range uninstalls {
		// Uninstall the item
		installer.Uninstall(catalog[item])
	}
}

// Updates prepares and then installs and array of items
func Updates(updates []string, catalog map[string]catalog.Item) {
	// Iterate through the updates array and update the item **if it is already installed**
	for _, item := range updates {
		// Update the item
		installer.Update(catalog[item])
	}
}

func dirEmpty(path string) bool {
	f, err := os.Open(path)
	if err != nil {
		return false
	}
	defer f.Close()

	// read in ONLY one file
	_, err = f.Readdir(1)

	// and if the file is EOF... well, the dir is empty.
	if err == io.EOF {
		return true
	}
	return false
}

func fileOld(info os.FileInfo) bool {
	// Age of the file
	fileAge := time.Since(info.ModTime())

	// Our limit
	days := 5

	// Convert from days
	hours := days * 24
	ageLimit := time.Duration(hours) * time.Hour

	// If the file is older than our limit, delete it
	if fileAge > ageLimit {
		return true
	}

	return false
}

// CleanUp checks the age of items in the cache and removes if older than 10 days
func CleanUp() {

	// Clean up old files
	err := filepath.Walk(config.CachePath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			gorillalog.Warn("Failed to access path:", path, err)
			return err
		}
		// If not a directory and older that our limit, delete
		if !info.IsDir() && fileOld(info) {
			gorillalog.Info("Cleaning old cached file:", info.Name())
			os.Remove(path)
			return nil
		}
		return nil
	})
	if err != nil {
		gorillalog.Warn("error walking path:", config.CachePath, err)
		return
	}

	// Clean up empty directories
	err = filepath.Walk(config.CachePath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			gorillalog.Warn("Failed to access path:", path, err)
			return err
		}

		// If a dir and empty, delete
		if info.IsDir() && dirEmpty(path) {
			gorillalog.Info("Cleaning empty directory:", info.Name())
			os.Remove(path)
			return nil

		}
		return nil
	})
	if err != nil {
		gorillalog.Warn("error walking path:", config.CachePath, err)
		return
	}
}

repository: jaredsiegel/gorilla

repo_name: jaredsiegel/gorilla


text:
// Code generated by vfsgen; DO NOT EDIT.

// +build !dev

package cli

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	pathpkg "path"
	"time"
)

// Config statically implements the virtual filesystem provided to vfsgen.
var Config = func() http.FileSystem {
	fs := vfsgen۰FS{
		"/": &vfsgen۰DirInfo{
			name:    "/",
			modTime: time.Date(2020, 8, 10, 16, 51, 22, 798413337, time.UTC),
		},
		"/martian.yml": &vfsgen۰CompressedFileInfo{
			name:             "martian.yml",
			modTime:          time.Date(2020, 8, 10, 16, 51, 22, 786413090, time.UTC),
			uncompressedSize: 1601,

			compressedContent: []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x54\xcb\x72\xe2\x3a\x10\xdd\xeb\x2b\xba\x60\x1b\xc3\xbd\x5b\xaa\xee\xe2\x86\xc7\x84\x21\x95\xa1\xc0\xa9\xac\x1b\xbb\x6d\x2b\xc8\x92\x4b\x6a\x93\x84\x4f\x9a\xdf\x98\x1f\x9b\x92\x01\xc9\x29\x66\xc8\xce\xea\x3e\x7d\xfa\xa8\x7d\xd4\x43\x98\x1a\x5d\xc8\xb2\xb5\xc8\xd2\x68\x28\x8c\x85\x1a\x2d\x4b\xd4\x77\xc0\xc6\xa8\x2e\xb2\xe5\x2e\x4b\x64\x1d\x28\x93\xa1\x92\xc7\x2e\x30\x12\x43\xd8\x12\x41\xc5\xdc\xb8\xc9\x78\x5c\x4a\xae\xda\xdd\x28\x33\xf5\xd8\x71\xa2\xfe\xfd\x47\x8f\xcf\x64\x1d\x8d\xa5\x82\x2c\xe9\x8c\x46\x42\x0c\xe1\x51\x3a\x06\x53\x00\x1e\x50\x2a\xdc\x29\x02\x85\xba\x6c\xb1\x24\x37\x12\xe1\x73\x22\x12\xc8\x4c\x4e\x13\xd8\x3c\x0b\x00\x8d\xb5\xff\x6c\x9d\x93\xa8\x05\x40\x61\x34\x4f\xc0\x9e\xcf\x01\x3b\x7f\x0a\xd8\xb9\x2e\x95\x74\x55\xc0\xd2\xf9\x1c\xb0\x8b\x4d\xc0\x2e\xbc\xba\x1e\xf4\x9d\x49\xe7\x94\x47\xec\x6c\x1e\xb0\xdf\xc8\xd6\x3d\x09\xd7\xd8\x65\x1a\xb0\x4b\x46\x25\x6f\x82\x57\x51\xf0\x77\x6c\x50\x93\xa3\x80\xce\x5e\xf7\x02\x4e\x73\xa7\x09\xbc\x62\xaf\xea\x47\xa8\x5a\x19\x4b\xbd\x0e\x95\x9f\x9f\x8a\xc8\xf5\x63\x40\xae\xcd\xa7\x79\x5c\xcd\x6e\x9d\xf6\xa0\x96\xdb\xb2\xfd\xf5\xd3\x09\x80\xc6\x52\x21\xdf\x27\xd0\x9c\x82\x27\x85\x17\x55\x0d\x27\xeb\xb4\xc7\x71\x1f\x38\xee\x2d\x1e\xa5\xbf\xfd\x85\xed\x54\x78\xcd\x96\xec\x2e\xc8\xcf\xbc\xf7\x9b\xc8\x3b\x8d\x63\xda\xca\xba\x51\xb2\x90\x94\xc3\xb4\x92\x37\x06\x76\xac\x92\xe9\x53\xa4\x48\x5f\x02\x45\x6a\x31\x97\xde\xc7\xa8\x7a\x1c\x17\x65\x1c\xb3\x49\xf6\x55\x87\xf4\xc5\x5b\x7a\x21\xb5\xf6\xb3\x0d\xd6\x5a\x46\xb9\xad\xa9\x65\x54\xb1\x5d\xc5\x8c\x32\x07\xdc\xff\xfd\x7f\x4c\xb7\x01\x3a\x3d\x52\x76\xe3\xcf\xcd\x23\x72\xdb\xa0\xfe\xe4\xfa\x2b\xc7\xa5\xd1\xf6\x69\x6b\xf7\x37\x2d\x31\xfb\x3f\x60\x67\x5f\xf1\x3e\x45\xa7\xcd\x5a\xbe\xf9\x9a\x1e\xe2\x8b\x7e\x68\x75\x89\xf6\xe6\x9b\xde\x44\xb3\x6f\x4c\x8d\xfa\xcf\x0f\x6a\xd8\x37\x06\x5b\xd4\x4e\x9d\x36\x5b\x83\x96\x9d\x5f\x58\xcb\x02\x5c\x80\xdc\x01\x57\x04\x83\xda\x95\x32\x1f\xc0\x01\x55\x4b\x7e\x27\xf5\x0b\xa5\x03\x47\x0c\x6c\x7a\x65\x62\x08\x96\x7c\xfe\x40\xd0\x20\x57\xfd\x1a\xca\x81\x14\xd5\xa4\xf9\x0e\xb4\xe1\xae\x81\xb1\xb2\x94\xde\x66\x4c\xef\x3c\x12\xc3\x6e\xfd\xed\xa9\xdb\x8a\x1b\xc2\x92\x34\xbb\xf1\x86\x32\x63\xf3\xf3\x11\xde\x24\x57\xb0\xa2\x8f\xff\x16\xca\xb4\xf6\xa4\x53\xe6\x5d\xc5\xb3\x96\x3e\xaf\x14\xec\x08\x06\x5d\x7e\xe4\x63\x03\x31\x04\xa9\x1d\x13\xe6\x5e\xd0\xa0\x1c\x9c\x5a\xa5\xfe\x8a\xa9\x6c\xdc\xa0\x9b\x82\xbf\x11\xaa\x37\xfc\x70\x80\xce\xb5\x35\xe5\x80\x0e\xb4\xd1\x49\xbc\xe0\x48\xc4\xef\x89\x00\x48\x82\xcc\xae\x53\x17\x59\xd1\x87\x13\xbf\x03\x00\x00\xff\xff\x8b\x7b\x91\x61\x41\x06\x00\x00"),
		},
	}
	fs["/"].(*vfsgen۰DirInfo).entries = []os.FileInfo{
		fs["/martian.yml"].(os.FileInfo),
	}

	return fs
}()

type vfsgen۰FS map[string]interface{}

func (fs vfsgen۰FS) Open(path string) (http.File, error) {
	path = pathpkg.Clean("/" + path)
	f, ok := fs[path]
	if !ok {
		return nil, &os.PathError{Op: "open", Path: path, Err: os.ErrNotExist}
	}

	switch f := f.(type) {
	case *vfsgen۰CompressedFileInfo:
		gr, err := gzip.NewReader(bytes.NewReader(f.compressedContent))
		if err != nil {
			// This should never happen because we generate the gzip bytes such that they are always valid.
			panic("unexpected error reading own gzip compressed bytes: " + err.Error())
		}
		return &vfsgen۰CompressedFile{
			vfsgen۰CompressedFileInfo: f,
			gr:                        gr,
		}, nil
	case *vfsgen۰DirInfo:
		return &vfsgen۰Dir{
			vfsgen۰DirInfo: f,
		}, nil
	default:
		// This should never happen because we generate only the above types.
		panic(fmt.Sprintf("unexpected type %T", f))
	}
}

// vfsgen۰CompressedFileInfo is a static definition of a gzip compressed file.
type vfsgen۰CompressedFileInfo struct {
	name              string
	modTime           time.Time
	compressedContent []byte
	uncompressedSize  int64
}

func (f *vfsgen۰CompressedFileInfo) Readdir(count int) ([]os.FileInfo, error) {
	return nil, fmt.Errorf("cannot Readdir from file %s", f.name)
}
func (f *vfsgen۰CompressedFileInfo) Stat() (os.FileInfo, error) { return f, nil }

func (f *vfsgen۰CompressedFileInfo) GzipBytes() []byte {
	return f.compressedContent
}

func (f *vfsgen۰CompressedFileInfo) Name() string       { return f.name }
func (f *vfsgen۰CompressedFileInfo) Size() int64        { return f.uncompressedSize }
func (f *vfsgen۰CompressedFileInfo) Mode() os.FileMode  { return 0444 }
func (f *vfsgen۰CompressedFileInfo) ModTime() time.Time { return f.modTime }
func (f *vfsgen۰CompressedFileInfo) IsDir() bool        { return false }
func (f *vfsgen۰CompressedFileInfo) Sys() interface{}   { return nil }

// vfsgen۰CompressedFile is an opened compressedFile instance.
type vfsgen۰CompressedFile struct {
	*vfsgen۰CompressedFileInfo
	gr      *gzip.Reader
	grPos   int64 // Actual gr uncompressed position.
	seekPos int64 // Seek uncompressed position.
}

func (f *vfsgen۰CompressedFile) Read(p []byte) (n int, err error) {
	if f.grPos > f.seekPos {
		// Rewind to beginning.
		err = f.gr.Reset(bytes.NewReader(f.compressedContent))
		if err != nil {
			return 0, err
		}
		f.grPos = 0
	}
	if f.grPos < f.seekPos {
		// Fast-forward.
		_, err = io.CopyN(ioutil.Discard, f.gr, f.seekPos-f.grPos)
		if err != nil {
			return 0, err
		}
		f.grPos = f.seekPos
	}
	n, err = f.gr.Read(p)
	f.grPos += int64(n)
	f.seekPos = f.grPos
	return n, err
}
func (f *vfsgen۰CompressedFile) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case io.SeekStart:
		f.seekPos = 0 + offset
	case io.SeekCurrent:
		f.seekPos += offset
	case io.SeekEnd:
		f.seekPos = f.uncompressedSize + offset
	default:
		panic(fmt.Errorf("invalid whence value: %v", whence))
	}
	return f.seekPos, nil
}
func (f *vfsgen۰CompressedFile) Close() error {
	return f.gr.Close()
}

// vfsgen۰DirInfo is a static definition of a directory.
type vfsgen۰DirInfo struct {
	name    string
	modTime time.Time
	entries []os.FileInfo
}

func (d *vfsgen۰DirInfo) Read([]byte) (int, error) {
	return 0, fmt.Errorf("cannot Read from directory %s", d.name)
}
func (d *vfsgen۰DirInfo) Close() error               { return nil }
func (d *vfsgen۰DirInfo) Stat() (os.FileInfo, error) { return d, nil }

func (d *vfsgen۰DirInfo) Name() string       { return d.name }
func (d *vfsgen۰DirInfo) Size() int64        { return 0 }
func (d *vfsgen۰DirInfo) Mode() os.FileMode  { return 0755 | os.ModeDir }
func (d *vfsgen۰DirInfo) ModTime() time.Time { return d.modTime }
func (d *vfsgen۰DirInfo) IsDir() bool        { return true }
func (d *vfsgen۰DirInfo) Sys() interface{}   { return nil }

// vfsgen۰Dir is an opened dir instance.
type vfsgen۰Dir struct {
	*vfsgen۰DirInfo
	pos int // Position within entries for Seek and Readdir.
}

func (d *vfsgen۰Dir) Seek(offset int64, whence int) (int64, error) {
	if offset == 0 && whence == io.SeekStart {
		d.pos = 0
		return 0, nil
	}
	return 0, fmt.Errorf("unsupported Seek in directory %s", d.name)
}

func (d *vfsgen۰Dir) Readdir(count int) ([]os.FileInfo, error) {
	if d.pos >= len(d.entries) && count > 0 {
		return nil, io.EOF
	}
	if count <= 0 || count > len(d.entries)-d.pos {
		count = len(d.entries) - d.pos
	}
	e := d.entries[d.pos : d.pos+count]
	d.pos += count
	return e, nil
}


text:
@article{Arike2012,
abstract = {Three different label-free proteome quantification methods - APEX, emPAI and iBAQ - were evaluated to measure proteome-wide protein concentrations in the cell. All the methods were applied to a sample from Escherichia coli chemostat culture. A Pearson squared correlation of approximately 0.6 among the three quantification methods was demonstrated. Importantly, the sum of quantified proteins by iBAQ and emPAI corresponded with the Lowry total protein quantification, demonstrating applicability of label-free methods for an accurate calculation of protein concentrations at the proteome level. The iBAQ method showed the best correlation between biological replicates, a normal distribution among all protein abundances, and the lowest variation among ribosomal protein abundances, which are expected to have equal amounts. Absolute quantitative proteome data enabled us to evaluate metabolic cost for protein synthesis and apparent catalytic activities of enzymes by integration with flux analysis. All the methods demonstrated similar ATP costs for protein synthesis for different cellular processes and that costs for expressing biomass synthesis related proteins were higher than those for energy generation. Importantly, catalytic activities of energy metabolism enzymes were an order or two higher than those of monomer synthesis. Interestingly, a staircase-like protein expression was demonstrated for most of the transcription units. {\textcopyright} 2012 Elsevier B.V.},
author = {Arike, L. and Valgepea, K. and Peil, L. and Nahku, R. and Adamberg, K. and Vilu, R.},
doi = {10.1016/j.jprot.2012.06.020},
isbn = {1876-7737 (Electronic)},
issn = {18743919},
journal = {Journal of Proteomics},
keywords = {APEX,EmPAI,IBAQ,Label-free absolute quantitative proteomics,Precursor ion intensity,Spectral counting},
number = {17},
pages = {5437--5448},
pmid = {22771841},
title = {{Comparison and applications of label-free absolute proteome quantification methods on Escherichia coli}},
volume = {75},
year = {2012}
}
@misc{Calderon-Celis2017,
abstract = {Mass spectrometry-based approaches have enabled important breakthroughs in quantitative proteomics in the last decades. This development is reflected in the better quantitative assessment of protein levels as well as to understand post-translational modifications and protein complexes and networks. Nowadays, the focus of quantitative proteomics shifted from the relative determination of proteins (ie, differential expression between two or more cellular states) to absolute quantity determination, required for a more-thorough characterization of biological models and comprehension of the proteome dynamism, as well as for the search and validation of novel protein biomarkers. However, the physico-chemical environment of the analyte species affects strongly the ionization efficiency in most mass spectrometry (MS) types, which thereby require the use of specially designed standardization approaches to provide absolute quantifications. Most common of such approaches nowadays include (i) the use of stable isotope-labeled peptide standards, isotopologues to the target proteotypic peptides expected after tryptic digestion of the target protein; (ii) use of stable isotope-labeled protein standards to compensate for sample preparation, sample loss, and proteolysis steps; (iii) isobaric reagents, which after fragmentation in the MS/MS analysis provide a final detectable mass shift, can be used to tag both analyte and standard samples; (iv) label-free approaches in which the absolute quantitative data are not obtained through the use of any kind of labeling, but from computational normalization of the raw data and adequate standards; (v) elemental mass spectrometry-based workflows able to provide directly absolute quantification of peptides/proteins that contain an ICP-detectable element. A critical insight from the Analytical Chemistry perspective of the different standardization approaches and their combinations used so far for absolute quantitative MS-based (molecular and elemental) proteomics is provided in this review.},
author = {Calder{\'{o}}n-Celis, Francisco and Encinar, Jorge Ruiz and Sanz-Medel, Alfredo},
booktitle = {Mass Spectrometry Reviews},
doi = {10.1002/mas.21542},
file = {::},
issn = {10982787},
keywords = {Absolute quantification,Isotope labeling,Mass spectrometry,Quantitative proteomics},
month = {nov},
number = {6},
pages = {715--737},
pmid = {28758227},
publisher = {Wiley-Blackwell},
title = {{Standardization approaches in absolute quantitative proteomics with mass spectrometry}},
url = {http://doi.wiley.com/10.1002/mas.21542},
volume = {37},
year = {2017}
}
@article{Cox2014,
abstract = {Protein quantification without isotopic labels has been a long-standing interest in the proteomics field. However, accurate and robust proteome-wide quantification with label-free approaches remains a challenge. We developed a new intensity determination and normalization procedure called MaxLFQ that is fully compatible with any peptide or protein separation prior to LC-MS analysis. Protein abundance profiles are assembled using the maximum possible information from MS-signals given that the presence of quantifiable peptides varies from sample to sample. On a benchmark dataset with two proteomes mixed at known ratios, we accurately detect the mixing ratio over the entire protein expression range, with higher precision for abundant proteins. The significance of individual label-free quantifications is obtained by a t-test approach. On a second benchmark dataset, we accurately quantify fold changes over several orders of magnitudes, a task that is challenging with label-based methods. MaxLFQ is a generic label-free quantification technology that is readily applicable to tackle many biological questions and it is compatible with standard statistical analysis workflows, and it has been validated in many and diverse biological projects. Our algorithms can handle very large experiments of 500+ samples in manageable computing time. It is implemented in the freely-available MaxQuant computational proteomics platform and works completely seamlessly at the click of a button (www.maxquant.org).},
author = {Cox, J{\"{u}}rgen and Hein, Marco Y. and Luber, Christian A. and Paron, Igor and Nagaraj, Nagarjuna and Mann, Matthias},
doi = {10.1074/mcp.M113.031591},
file = {:C$\backslash$:/Users/bensan/Box/References/Exp data/Proteomics/Cox 2014 - MaxLFQ.pdf:pdf},
isbn = {1535-9484},
issn = {1535-9476},
journal = {Molecular {\&} Cellular Proteomics},
number = {9},
pages = {2513--2526},
pmid = {24942700},
title = {{Accurate Proteome-wide Label-free Quantification by Delayed Normalization and Maximal Peptide Ratio Extraction, Termed MaxLFQ}},
url = {http://www.mcponline.org/lookup/doi/10.1074/mcp.M113.031591},
volume = {13},
year = {2014}
}
@article{Cox2008,
abstract = {Efficient analysis of very large amounts of raw data for peptide identification and protein quantification is a principal challenge in mass spectrometry (MS)-based proteomics. Here we describe MaxQuant, an integrated suite of algorithms specifically developed for high-resolution, quantitative MS data. Using correlation analysis and graph theory, MaxQuant detects peaks, isotope clusters and stable amino acid isotope-labeled (SILAC) peptide pairs as three-dimensional objects in m/z, elution time and signal intensity space. By integrating multiple mass measurements and correcting for linear and nonlinear mass offsets, we achieve mass accuracy in the p.p.b. range, a sixfold increase over standard techniques. We increase the proportion of identified fragmentation spectra to 73{\%} for SILAC peptide pairs via unambiguous assignment of isotope and missed-cleavage state and individual mass precision. MaxQuant automatically quantifies several hundred thousand peptides per SILAC-proteome experiment and allows statistically robust identification and quantification of {\textgreater}4,000 proteins in mammalian cell lysates.},
archivePrefix = {arXiv},
arxivId = {10.1038/nbt.1511},
author = {Cox, J{\"{u}}rgen and Mann, Matthias},
doi = {10.1038/nbt.1511},
eprint = {nbt.1511},
isbn = {1546-1696 (Electronic)$\backslash$r1087-0156 (Linking)},
issn = {10870156},
journal = {Nature Biotechnology},
month = {dec},
number = {12},
pages = {1367--1372},
pmid = {19029910},
primaryClass = {10.1038},
publisher = {Nature Publishing Group},
title = {{MaxQuant enables high peptide identification rates, individualized p.p.b.-range mass accuracies and proteome-wide protein quantification}},
url = {http://www.nature.com/articles/nbt.1511},
volume = {26},
year = {2008}
}
@article{Fabre2014,
abstract = {Protein complexes are the main molecular machines that support all major cellular pathways and their in-depth characterization are essential to understand their functions. Determining the stoichiometry of the different subunits of a protein complex still remains challenging. Recently, many label-free quantitative proteomic approaches have been developed to study the composition of protein complexes. It is therefore of great interest to evaluate these different methods in a stoichiometry oriented objective. Here we compare the ability of four absolute quantitative label-free methods currently used in proteomic studies to determine the stoichiometry of a well-characterized protein complex, the 26S proteasome.},
author = {Fabre, Bertrand and Lambour, Thomas and Bouyssi{\'{e}}, David and Menneteau, Thomas and Monsarrat, Bernard and Burlet-Schiltz, Odile and Bousquet-Dubouch, Marie Pierre},
doi = {10.1016/j.euprot.2014.06.001},
file = {::},
isbn = {2212-9685},
issn = {22129685},
journal = {EuPA Open Proteomics},
keywords = {26S proteasome,Affinity purification mass spectrometry (AP-MS),IBAQ,Spectral counting,Top3},
month = {sep},
pages = {82--86},
publisher = {Elsevier},
title = {{Comparison of label-free quantification methods for the determination of protein complexes subunits stoichiometry}},
url = {https://www.sciencedirect.com/science/article/pii/S2212968514000403?via{\%}3Dihub},
volume = {4},
year = {2014}
}
@article{Geiger2010,
abstract = {We describe a method to accurately quantify human tumor proteomes by combining a mixture of five stable-isotope labeling by amino acids in cell culture (SILAC)-labeled cell lines with human carcinoma tissue. This generated hundreds of thousands of isotopically labeled peptides in appropriate amounts to serve as internal standards for mass spectrometry-based analysis. By decoupling the labeling from the measurement, this super-SILAC method broadens the scope of SILAC-based proteomics.},
author = {Geiger, Tamar and Cox, Juergen and Ostasiewicz, Pawel and Wisniewski, Jacek R and Mann, Matthias},
doi = {10.1038/nmeth.1446},
file = {::},
isbn = {1548-7105 (Electronic) 1548-7091 (Linking)},
issn = {15487091},
journal = {Nature Methods},
keywords = {Cancer,Mass spectrometry,Proteomic analysis},
month = {may},
number = {5},
pages = {383--385},
pmid = {20364148},
publisher = {Nature Publishing Group},
title = {{Super-SILAC mix for quantitative proteomics of human tumor tissue}},
url = {http://www.nature.com/articles/nmeth.1446},
volume = {7},
year = {2010}
}
@article{Ghaemmaghami2003,
abstract = {The availability of complete genomic sequences and technologies that allow comprehensive analysis of global expression profiles of messenger RNA have greatly expanded our ability to monitor the internal state of a cell. Yet biological systems ultimately need to be explained in terms of the activity, regulation and modification of proteins--and the ubiquitous occurrence of post-transcriptional regulation makes mRNA an imperfect proxy for such information. To facilitate global protein analyses, we have created a Saccharomyces cerevisiae fusion library where each open reading frame is tagged with a high-affinity epitope and expressed from its natural chromosomal location. Through immunodetection of the common tag, we obtain a census of proteins expressed during log-phase growth and measurements of their absolute levels. We find that about 80{\%} of the proteome is expressed during normal growth conditions, and, using additional sequence information, we systematically identify misannotated genes. The abundance of proteins ranges from fewer than 50 to more than 10(6) molecules per cell. Many of these molecules, including essential proteins and most transcription factors, are present at levels that are not readily detectable by other proteomic techniques nor predictable by mRNA levels or codon bias measurements.},
author = {Ghaemmaghami, S and Huh, W.-K. and Bower, K and Howson, R W and Belle, a and Dephoure, N and O'Shea, E K and Weissman, J S},
doi = {10.1038/nature02046\nnature02046 [pii]},
isbn = {1476-4687 (Electronic)$\backslash$n0028-0836 (Linking)},
issn = {1476-4687},
journal = {Nature},
keywords = {*Gene Expression Profiling,Blotting, Western,Computational Biology,Epitopes/analysis/genetics,Genome, Fungal,Open Reading Frames/genetics,Proteome/genetics/*metabolism,Proteomics,RNA, Fungal/genetics/metabolism,Recombinant Fusion Proteins/chemistry/genetics/met,Saccharomyces cerevisiae Proteins/genetics/*metabo,Saccharomyces cerevisiae/genetics/growth {\&} develop},
number = {6959},
pages = {737--741},
pmid = {14562106},
title = {{Global analysis of protein expression in yeast}},
url = {http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?cmd=Retrieve{\&}db=PubMed{\&}dopt=Citation{\&}list{\_}uids=14562106},
volume = {425},
year = {2003}
}
@article{Ho2018,
abstract = {Protein activity is the ultimate arbiter of function in most cellular pathways, and protein concentration is fundamentally connected to protein action. While the proteome of yeast has been subjected to the most comprehensive analysis of any eukaryote, existing datasets are difficult to compare, and there is no consensus abundance value for each protein. We evaluated 21 quantitative analyses of the S. cerevisiae proteome, normalizing and converting all measurements of protein abundance into the intuitive measurement of absolute molecules per cell. We estimate the cellular abundance of 92{\%} of the proteins in the yeast proteome and assess the variation in each abundance measurement. Using our protein abundance dataset, we find that a global response to diverse environmental stresses is not detected at the level of protein abundance, we find that protein tags have only a modest effect on protein abundance, and we identify proteins that are differentially regulated at the mRNA abundance, mRNA translation, and protein abundance levels. By normalizing and converting 21 protein abundance datasets to the intuitive unit of molecules per cell, we provide precise and accurate abundance estimates for 92{\%} of the yeast proteome. Our protein abundance dataset proves useful for exploring the cellular response to environmental stress, the balance between transcription and translation in regulating protein abundance, and the systematic evaluation of the effect of protein tags on protein abundance.},
author = {Ho, Brandon and Baryshnikova, Anastasia and Brown, Grant W},
doi = {10.1016/j.cels.2017.12.004},
issn = {24054720},
journal = {Cell Systems},
keywords = {GFP,flow cytometry,fluorescence microscopy,high-throughput,mass spectrometry,protein abundance,proteome,tandem affinity tag,yeast},
month = {feb},
number = {2},
pages = {192--205.e3},
pmid = {29361465},
publisher = {Elsevier},
title = {{Unification of Protein Abundance Datasets Yields a Quantitative Saccharomyces cerevisiae Proteome}},
url = {http://www.ncbi.nlm.nih.gov/pubmed/29361465},
volume = {6},
year = {2018}
}
@article{Hukelmann2016,
abstract = {We used high-resolution mass spectrometry to map the cytotoxic T lymphocyte (CTL) proteome and the effect of the metabolic checkpoint kinase mTORC1 on CTLs. The CTL proteome was dominated by metabolic regulators and granzymes, and mTORC1 selectively repressed and promoted expression of a subset of CTL proteins ({\~{}}10{\%}). These included key CTL effector molecules, signaling proteins and a subset of metabolic enzymes. Proteomic data highlighted the potential for negative control of the production of phosphatidylinositol (3,4,5)-trisphosphate (PtdIns(3,4,5)P3) by mTORC1 in CTLs. mTORC1 repressed PtdIns(3,4,5)P3 production and determined the requirement for mTORC2 in activation of the kinase Akt. Our unbiased proteomic analysis thus provides comprehensive understanding of CTL identity and the control of CTL function by mTORC1.},
author = {Hukelmann, Jens L and Anderson, Karen E and Sinclair, Linda V and Grzes, Katarzyna M and Murillo, Alejandro Brenes and Hawkins, Phillip T and Stephens, Len R and Lamond, Angus I and Cantrell, Doreen A},
doi = {10.1038/ni.3314},
isbn = {1529-2908},
issn = {15292916},
journal = {Nature Immunology},
keywords = {Cytotoxic T cells,Signal transduction},
month = {jan},
number = {1},
pages = {104--112},
pmid = {26551880},
publisher = {Nature Publishing Group},
title = {{The cytotoxic T cell proteome and its shaping by the kinase mTOR}},
volume = {17},
year = {2016}
}
@misc{Jenner2012,
abstract = {The first X-ray structure of the eukaryotic ribosome at 3.0. {\AA} resolution was determined using ribosomes isolated and crystallized from the yeast Saccharomyces cerevisiae (Ben-Shem A, Garreau de Loubresse N, Melnikov S, Jenner L, Yusupova G, Yusupov M: The structure of the eukaryotic ribosome at 3.0 A resolution. Science 2011, 334:1524-1529). This accomplishment was possible due to progress in yeast ribosome biochemistry as well as recent advances in crystallographic methods developed for structure determination of prokaryotic ribosomes isolated from Thermus thermophilus and Escherichia coli. In this review we will focus on the development of isolation procedures that allowed structure determination (both cryo-EM and X-ray crystallography) to be successful for the yeast S. cerevisiae. Additionally we will introduce a new nomenclature that facilitates comparison of ribosomes from different species and kingdoms of life. Finally we will discuss the impact of the yeast 80S ribosome crystal structure on perspectives for future investigations. {\textcopyright} 2012 Elsevier Ltd.},
author = {Jenner, Lasse and Melnikov, Sergey and de Loubresse, Nicolas Garreau and Ben-Shem, Adam and Iskakova, Madina and Urzhumtsev, Alexandre and Meskauskas, Arturas and Dinman, Jonathan and Yusupova, Gulnara and Yusupov, Marat},
booktitle = {Current Opinion in Structural Biology},
doi = {10.1016/j.sbi.2012.07.013},
isbn = {1879-033X (Electronic)$\backslash$r0959-440X (Linking)},
issn = {0959440X},
month = {dec},
number = {6},
pages = {759--767},
pmid = {22884264},
publisher = {Elsevier Current Trends},
title = {{Crystal structure of the 80S yeast ribosome}},
volume = {22},
year = {2012}
}
@article{Krey2014,
abstract = {Label-free quantitation of proteins analyzed by tandem mass spectrometry uses either integrated peak intensity from the parent-ion mass analysis (MS1) or features from fragment-ion analysis (MS2), such as spectral counts or summed fragment-ion intensity. We directly compared MS1 and MS2 quantitation by analyzing human protein standards diluted into Escherichia coli extracts on an Orbitrap mass spectrometer. We found that summed MS2 intensities were nearly as accurate as integrated MS1 intensities, and both outperformed MS2 spectral counting in accuracy and linearity. We compared these results to those obtained from two low-resolution ion-trap mass spectrometers; summed MS2 intensities from LTQ and LTQ Velos instruments were similar in accuracy to those from the Orbitrap. Data from all three instruments are available via ProteomeXchange with identifier PXD000602. Abundance measurements using MS1 or MS2 intensities had limitations, however. While measured protein concentration was on average well-correlated with the known concentration, there was considerable protein-to-protein variation. Moreover, not all human proteins diluted to a mole fraction of 10(-3) or lower were detected, with a strong falloff below 10(-4) mole fraction. These results show that MS1 and MS2 intensities are simple measures of protein abundance that are on average accurate but should be limited to quantitation of proteins of intermediate to higher fractional abundance.},
archivePrefix = {arXiv},
arxivId = {NIHMS150003},
author = {Krey, Jocelyn F. and Wilmarth, Phillip A. and Shin, Jung Bum and Klimek, John and Sherman, Nicholas E. and Jeffery, Erin D. and Choi, Dongseok and David, Larry L. and Barr-Gillespie, Peter G.},
doi = {10.1021/pr401017h},
eprint = {NIHMS150003},
isbn = {1535-3893},
issn = {15353893},
journal = {Journal of Proteome Research},
keywords = {Orbitrap,intensity,ion trap,spectral counts},
number = {2},
pages = {1034--1044},
pmid = {24295401},
title = {{Accurate label-free protein quantitation with high- and low-resolution mass spectrometers}},
volume = {13},
year = {2014}
}
@article{Kulak2014,
abstract = {Mass spectrometry (MS)-based proteomics typically employs multistep sample-preparation workflows that are subject to sample contamination and loss. We report an in-StageTip method for performing sample processing, from cell lysis through elution of purified peptides, in a single, enclosed volume. This robust and scalable method largely eliminates contamination or loss. Peptides can be eluted in several fractions or in one step for single-run proteome analysis. In one day, we obtained the largest proteome coverage to date for budding and fission yeast, and found that protein copy numbers in these cells were highly correlated (R(2) = 0.78). Applying the in-StageTip method to quadruplicate measurements of a human cell line, we obtained copy-number estimates for 9,667 human proteins and observed excellent quantitative reproducibility between replicates (R(2) = 0.97). The in-StageTip method is straightforward and generally applicable in biological or clinical applications.},
archivePrefix = {arXiv},
arxivId = {arXiv:1612.02179v1},
author = {Kulak, Nils A and Pichler, Garwin and Paron, Igor and Nagaraj, Nagarjuna and Mann, Matthias},
doi = {10.1038/nmeth.2834},
eprint = {arXiv:1612.02179v1},
isbn = {1548-7105 (Electronic)$\backslash$r1548-7091 (Linking)},
issn = {15487105},
journal = {Nature Methods},
keywords = {Proteomic analysis,Proteomics},
month = {mar},
number = {3},
pages = {319--324},
pmid = {24487582},
publisher = {Nature Publishing Group},
title = {{Minimal, encapsulated proteomic-sample processing applied to copy-number estimation in eukaryotic cells}},
url = {http://www.nature.com/articles/nmeth.2834},
volume = {11},
year = {2014}
}
@article{Lahtvee2017,
abstract = {Protein synthesis is the most energy-consuming process in a proliferating cell, and understanding what controls protein abundances represents a key question in biology and biotechnology. We quantified absolute abundances of 5,354 mRNAs and 2,198 proteins in Saccharomyces cerevisiae under ten environmental conditions and protein turnover for 1,384 proteins under a reference condition. The overall correlation between mRNA and protein abundances across all conditions was low (0.46), but for differentially expressed proteins (n = 202), the median mRNA-protein correlation was 0.88. We used these data to model translation efficiencies and found that they vary more than 400-fold between genes. Non-linear regression analysis detected that mRNA abundance and translation elongation were the dominant factors controlling protein synthesis, explaining 61{\%} and 15{\%} of its variance. Metabolic flux balance analysis further showed that only mitochondrial fluxes were positively associated with changes at the transcript level. The present dataset represents a crucial expansion to the current resources for future studies on yeast physiology.},
author = {Lahtvee, Petri Jaan and S{\'{a}}nchez, Benjam{\'{i}}n J. and Smialowska, Agata and Kasvandik, Sergo and Elsemman, Ibrahim E. and Gatto, Francesco and Nielsen, Jens},
doi = {10.1016/j.cels.2017.03.003},
file = {:C$\backslash$:/Users/bensan/Documents/Dropbox/CV/Mis Papers/5. 2017 Lahtvee et al - Cell Systems.pdf:pdf},
isbn = {2405-4712 (Print)
2405-4712 (Linking)},
issn = {24054720},
journal = {Cell Systems},
keywords = {absolute proteome,absolute transcriptome,genome-scale metabolic modeling,integrative data analysis,protein degradation rates,protein turnover,translation efficiency,translational control},
number = {5},
pages = {495--504.e5},
pmid = {28365149},
title = {{Absolute Quantification of Protein and mRNA Abundances Demonstrate Variability in Gene-Specific Translation Efficiency in Yeast}},
volume = {4},
year = {2017}
}
@article{Lawless2016,
abstract = {Defining intracellular protein concentration is critical in molecular systems biology. Although strategies for determining relative protein changes are available, defining robust absolute values in copies per cell has proven significantly more challenging. Here we present a reference dataset quantifying over 1800 S. cerevisiae proteins by direct means using protein-specific stable-isotope labelled internal standards and selected reaction monitoring (SRM) mass spectrometry, far exceeding any previous study. This was achieved by careful design of over 100 QconCAT recombinant proteins as standards, defining 1167 proteins in terms of copies per cell and upper limits on a further 668, with robust CVs routinely less than 20{\%}. The SRM-derived proteome is compared with existing quantitative data sets, highlighting the disparities between methodologies. Coupled with a quantification of the transcriptome by RNA-seq taken from the same cells, these data support revised estimates of several fundamental molecular parameters: a total protein count of {\~{}}100 million molecules-per-cell, a median of {\~{}}1000 proteins-per-transcript, and a linear model of protein translation explaining 70{\%} of the variance in translation rate. This work contributes a 'gold-standard' reference yeast proteome (including 532 values based on high quality, dual peptide quantification) that can be widely used in systems models and for other comparative studies.},
author = {Lawless, Craig and Holman, Stephen W. and Brownridge, Philip and Lanthaler, Karin and Harman, Victoria M. and Watkins, Rachel and Hammond, Dean E. and Miller, Rebecca L. and Sims, Paul F. G. and Grant, Christopher M. and Eyers, Claire E. and Beynon, Robert J. and Hubbard, Simon J.},
doi = {10.1074/mcp.M115.054288},
isbn = {1535-9484 (Electronic)$\backslash$r1535-9476 (Linking)},
issn = {1535-9476},
journal = {Molecular {\&} Cellular Proteomics},
number = {4},
pages = {1309--1322},
pmid = {26750110},
title = {{Direct and Absolute Quantification of over 1800 Yeast Proteins via Selected Reaction Monitoring}},
url = {http://www.mcponline.org/lookup/doi/10.1074/mcp.M115.054288},
volume = {15},
year = {2016}
}
@misc{Mann2013,
abstract = {High-resolution mass spectrometry (MS)-based proteomics has progressed tremendously over the years. For model organisms like yeast, we can now quantify complete proteomes in just a few hours. Developments discussed in this Perspective will soon enable complete proteome analysis of mammalian cells, as well, with profound impact on biology and biomedicine. {\textcopyright} 2013 Elsevier Inc.},
author = {Mann, Matthias and Kulak, Nils A and Nagaraj, Nagarjuna and Cox, J{\"{u}}rgen},
booktitle = {Molecular Cell},
doi = {10.1016/j.molcel.2013.01.029},
file = {::},
isbn = {1097-4164 (Electronic)$\backslash$n1097-2765 (Linking)},
issn = {10972765},
month = {feb},
number = {4},
pages = {583--590},
pmid = {23438854},
publisher = {Elsevier},
title = {{The Coming Age of Complete, Accurate, and Ubiquitous Proteomes}},
url = {http://www.ncbi.nlm.nih.gov/pubmed/23438854},
volume = {49},
year = {2013}
}
@article{Marguerat2012,
abstract = {Data on absolute molecule numbers will empower the modeling, understanding, and comparison of cellular functions and biological systems. We quantified transcriptomes and proteomes in fission yeast during cellular proliferation and quiescence. This rich resource provides the first comprehensive reference for all RNA and most protein concentrations in a eukaryote under two key physiological conditions. The integrated data set supports quantitative biology and affords unique insights into cell regulation. Although mRNAs are typically expressed in a narrow range above 1 copy/cell, most long, noncoding RNAs, except for a distinct subset, are tightly repressed below 1 copy/cell. Cell-cycle-regulated transcription tunes mRNA numbers to phase-specific requirements but can also bring about more switch-like expression. Proteins greatly exceed mRNAs in abundance and dynamic range, and concentrations are regulated to functional demands. Upon transition to quiescence, the proteome changes substantially, but, in stark contrast to mRNAs, proteins do not uniformly decrease but scale with cell volume. {\textcopyright} 2012 Elsevier Inc.},
author = {Marguerat, Samuel and Schmidt, Alexander and Codlin, Sandra and Chen, Wei and Aebersold, Ruedi and B{\"{a}}hler, J{\"{u}}rg},
doi = {10.1016/j.cell.2012.09.019},
file = {::},
isbn = {1097-4172 (Electronic)$\backslash$r0092-8674 (Linking)},
issn = {00928674},
journal = {Cell},
month = {oct},
number = {3},
pages = {671--683},
pmid = {23101633},
publisher = {Elsevier},
title = {{Quantitative analysis of fission yeast transcriptomes and proteomes in proliferating and quiescent cells}},
url = {http://www.ncbi.nlm.nih.gov/pubmed/23101633 http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=PMC3482660},
volume = {151},
year = {2012}
}
@article{Ning2012,
abstract = {An increasing number of studies involve integrative analysis of gene and protein expression data taking advantage of new technologies such as next-generation transcriptome sequencing (RNA-Seq) and highly sensitive mass spectrometry (MS) instrumentation. Thus, it becomes interesting to revisit the correlative analysis of gene and protein expression data using more recently generated data sets. Furthermore, within the proteomics community there is a substantial interest in comparing the performance of different label-free quantitative proteomic strategies. Gene expression data can be used as an indirect benchmark for such protein-level comparisons. In this work we use publicly available mouse data to perform a joint analysis of genomic and proteomic data obtained on the same organism. First, we perform a comparative analysis of different label-free protein quantification methods (intensity based and spectral count based and using various associated data normalization steps) using several software tools on the proteomic side. Similarly, we perform correlative analysis of gene expression data derived using microarray and RNA-Seq methods on the genomic side. We also investigate the correlation between gene and protein expression data, and various factors affecting the accuracy of quantitation at both levels. It is observed that spectral count based protein abundance metrics, which are easy to extract from any published data, are comparable to intensity based measures with respect to correlation with gene expression data. The results of this work should be useful for designing robust computational pipelines for extraction and joint analysis of gene and protein expression data in the context of integrative studies.},
archivePrefix = {arXiv},
arxivId = {NIHMS150003},
author = {Ning, Kang and Fermin, Damian and Nesvizhskii, Alexey I.},
doi = {10.1021/pr201052x},
eprint = {NIHMS150003},
isbn = {1535-3893},
issn = {15353893},
journal = {Journal of Proteome Research},
month = {apr},
number = {4},
pages = {2261--2271},
pmid = {22329341},
title = {{Comparative analysis of different label-free mass spectrometry based protein abundance estimates and their correlation with RNA-Seq gene expression data}},
url = {http://www.ncbi.nlm.nih.gov/pubmed/22329341 http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=PMC3744887 http://pubs.acs.org/doi/10.1021/pr201052x},
volume = {11},
year = {2012}
}
@article{Peng2012,
abstract = {Nature Methods 9, 524 (2012). doi:10.1038/nmeth.2031},
author = {Peng, Mao and Taouatas, Nadia and Cappadona, Salvatore and {Van Breukelen}, Bas and Mohammed, Shabaz and Scholten, Arjen and Heck, Albert J R},
doi = {10.1038/nmeth.2031},
isbn = {1548-7105 (Electronic)$\backslash$r1548-7091 (Linking)},
issn = {15487091},
journal = {Nature Methods},
number = {6},
pages = {524--525},
pmid = {22669647},
publisher = {Nature Publishing Group},
title = {{Protease bias in absolute protein quantitation}},
url = {http://dx.doi.org/10.1038/nmeth.2031},
volume = {9},
year = {2012}
}
@article{Sanchez2017,
abstract = {Genome-scale metabolic models (GEMs) are widely used to calculate metabolic phenotypes. They rely on defining a set of constraints, the most common of which is that the production of metabolites and/or growth are limited by the carbon source uptake rate. However, enzyme abundances and kinetics, which act as limitations on metabolic fluxes, are not taken into account. Here, we present GECKO, a method that enhances a GEM to account for enzymes as part of reactions, thereby ensuring that each metabolic flux does not exceed its maximum capacity, equal to the product of the enzyme's abundance and turnover number. We applied GECKO to a Saccharomyces cerevisiae GEM and demonstrated that the new model could correctly describe phenotypes that the previous model could not, particularly under high enzymatic pressure conditions, such as yeast growing on different carbon sources in excess, coping with stress, or overexpressing a specific pathway. GECKO also allows to directly integrate quantitative proteomics data; by doing so, we significantly reduced flux variability of the model, in over 60{\%} of metabolic reactions. Additionally, the model gives insight into the distribution of enzyme usage between and within metabolic pathways. The developed method and model are expected to increase the use of model-based design in metabolic engineering.},
author = {S{\'{a}}nchez, Benjam{\'{i}}n J and Zhang, Cheng and Nilsson, Avlant and Lahtvee, Petri‐Jaan and Kerkhoven, Eduard J and Nielsen, Jens},
doi = {10.15252/msb.20167411},
issn = {1744-4292},
journal = {Molecular Systems Biology},
keywords = {Saccharomyces cerevisiae,enzyme kinetics,flux balance analysis,molecular crowding,proteomics},
number = {8},
pages = {935},
pmid = {28779005},
title = {{Improving the phenotype predictions of a yeast genome‐scale metabolic model by incorporating enzymatic constraints}},
volume = {13},
year = {2017}
}
@article{Schwanhausser2011,
abstract = {Gene expression is a multistep process that involves the transcription, translation and turnover of messenger RNAs and proteins. Although it is one of the most fundamental processes of life, the entire cascade has never been quantified on a genome-wide scale. Here we simultaneously measured absolute mRNA and protein abundance and turnover by parallel metabolic pulse labelling for more than 5,000 genes in mammalian cells. Whereas mRNA and protein levels correlated better than previously thought, corresponding half-lives showed no correlation. Using a quantitative model we have obtained the first genome-scale prediction of synthesis rates of mRNAs and proteins. We find that the cellular abundance of proteins is predominantly controlled at the level of translation. Genes with similar combinations of mRNA and protein stability shared functional properties, indicating that half-lives evolved under energetic and dynamic constraints. Quantitative information about all stages of gene expression provides a rich resource and helps to provide a greater understanding of the underlying design principles.},
author = {Schwanh{\"{a}}usser, Bj{\"{o}}rn and Busse, Dorothea and Li, Na and Dittmar, Gunnar and Schuchhardt, Johannes and Wolf, Jana and Chen, Wei and Selbach, Matthias},
doi = {10.1038/nature10098},
isbn = {1476-4687 (Electronic)0028-0836 (Linking)},
issn = {0028-0836},
journal = {Nature},
month = {may},
number = {7347},
pages = {337--342},
pmid = {21593866},
publisher = {Nature Research},
title = {{Global quantification of mammalian gene expression control}},
volume = {473},
year = {2011}
}
@article{Shalit2015,
abstract = {Presented is a data set for benchmarking MS1-based label-free quantitative proteomics using a quadrupole orbitrap mass spectrometer. Escherichia coli digest was spiked into a HeLa digest in four different concentrations, simulating protein expression differences in a background of an unchanged complex proteome. The data set provides a unique opportunity to evaluate the proteomic platform (instrumentation and software) in its ability to perform MS1-intensity-based label-free quantification. We show that the presented combination of informatics and instrumentation produces high precision and quantification accuracy. The data were also used to compare different quantitative protein inference methods such as iBAQ and Hi-N. The data can also be used as a resource for development and optimization of proteomics informatics tools, thus the raw data have been deposited to ProteomeXchange with identifier PXD001385.},
author = {Shalit, Tali and Elinger, Dalia and Savidor, Alon and Gabashvili, Alexandra and Levin, Yishai},
doi = {10.1021/pr501045t},
isbn = {1535-3907 (Electronic)$\backslash$r1535-3893 (Linking)},
issn = {15353907},
journal = {Journal of Proteome Research},
keywords = {informatics tools,label-free proteomics,quantification},
month = {apr},
number = {4},
pages = {1979--1986},
pmid = {25780947},
title = {{MS1-based label-free proteomics using a quadrupole orbitrap mass spectrometer}},
url = {http://pubs.acs.org/doi/10.1021/pr501045t},
volume = {14},
year = {2015}
}
@article{Sinitcyn2018,
abstract = {Computational proteomics is the data science concerned with the identification and quantification of proteins from high-throughput data and the biological interpretation of their concentration changes, posttranslational modifications, interactions, and subcellular localizations. Today, these data most often originate from mass spectrometry–based shotgun proteomics experiments. In this review, we survey computational methods for the analysis of such proteomics data, focusing on the explanation of the key concepts. Starting with mass spectrometric feature detection, we then cover methods for the identification of peptides. Subsequently, protein inference and the control of false discovery rates are highly important topics covered. We then discuss methods for the quantification of peptides and proteins. A section on downstream data analysis covers exploratory statistics, network analysis, machine learning, and multiomics data integration. Finally, we discuss current developments and provide an outlook on wha...},
author = {Sinitcyn, Pavel and {Daniel Rudolph}, Jan and Cox, J{\"{u}}rgen},
doi = {10.1146/annurev-biodatasci-080917-013516},
file = {:C$\backslash$:/Users/bensan/Box/References/Exp data/Proteomics/Sinitcyn 2018 - computational  methods.pdf:pdf},
issn = {2574-3414},
journal = {Annual Review of Biomedical Data Science},
keywords = {computational proteomics,mass spectrometry,modifications,multiomics data analysis,multivariate analysis,network,posttranslational},
number = {1},
pages = {annurev--biodatasci--080917--013516},
title = {{Computational Methods for Understanding Mass Spectrometry–Based Shotgun Proteomics Data}},
url = {http://www.annualreviews.org/doi/10.1146/annurev-biodatasci-080917-013516},
volume = {1},
year = {2018}
}
@article{Tyanova2016,
  title={The MaxQuant computational platform for mass spectrometry-based shotgun proteomics},
  author={Tyanova, Stefka and Temu, Tikira and Cox, Juergen},
  journal={Nature protocols},
  volume={11},
  number={12},
  pages={2301},
  year={2016},
  publisher={Nature Publishing Group}
}
@article{Weisser2013,
abstract = {We present a computational pipeline for the quantification of peptides and proteins in label-free LC-MS/MS data sets. The pipeline is composed of tools from the OpenMS software framework and is applicable to the processing of large experiments (50+ samples). We describe several enhancements that we have introduced to OpenMS to realize the implementation of this pipeline. They include new algorithms for centroiding of raw data, for feature detection, for the alignment of multiple related measurements, and a new tool for the calculation of peptide and protein abundances. Where possible, we compare the performance of the new algorithms to that of their established counterparts in OpenMS. We validate the pipeline on the basis of two small data sets that provide ground truths for the quantification. There, we also compare our results to those of MaxQuant and Progenesis LC-MS, two popular alternatives for the analysis of label-free data. We then show how our software can be applied to a large heterogeneous data set of 58 LC-MS/MS runs.},
author = {Weisser, Hendrik and Nahnsen, Sven and Grossmann, Jonas and Nilse, Lars and Quandt, Andreas and Brauer, Hendrik and Sturm, Marc and Kenar, Erhan and Kohlbacher, Oliver and Aebersold, Ruedi and Malmstr{\"{o}}m, Lars},
doi = {10.1021/pr300992u},
file = {::},
isbn = {1535-3893},
issn = {15353893},
journal = {Journal of Proteome Research},
keywords = {algorithms,automation,bioinformatics software,label-free,mass spectrometry,quantification},
month = {apr},
number = {4},
pages = {1628--1644},
pmid = {23391308},
publisher = {American Chemical Society},
title = {{An automated pipeline for high-throughput label-free quantitative proteomics}},
url = {http://pubs.acs.org/doi/10.1021/pr300992u},
volume = {12},
year = {2013}
}
@article{Welle2016,
abstract = {Recent advances in mass spectrometry have enabled system-wide analyses of protein turnover. By globally quantifying the kinetics of protein clearance and synthesis, these methodologies can provide important insights into the regulation of the proteome under varying cellular and environmental conditions. To facilitate such analyses, we have employed a methodology that combines metabolic isotopic labeling (Stable Isotope Labeling in Cell Culture - SILAC) with isobaric tagging (Tandem Mass Tags - TMT) for analysis of multiplexed samples. The fractional labeling of multiple time-points can be measured in a single mass spectrometry run, providing temporally resolved measurements of protein turnover kinetics. To demonstrate the feasibility of the approach, we simultaneously measured the kinetics of protein clearance and accumulation for more than 3000 proteins in dividing and quiescent human fibroblasts and verified the accuracy of the measurements by comparison to established non-multiplexed approaches. The results indicate that upon reaching quiescence, fibroblasts compensate for lack of cellular growth by globally downregulating protein synthesis and upregulating protein degradation. The described methodology significantly reduces the cost and complexity of temporally-resolved dynamic proteomic experiments and improves the precision of proteome-wide turnover data.},
author = {Welle, Kevin A and Zhang, Tian and Hyrohorenko, Jennifer R and Shen, Shichen and Qu, Jun and Ghaemmaghami, Sina},
doi = {10.1074/mcp.M116.063230},
issn = {1535-9484},
journal = {Molecular {\&} cellular proteomics : MCP},
keywords = {Cell division*,Degradomics*,Proliferation*,Protein Degradation*,Protein Synthesis*,Protein Turnover*,Proteostasis,Quiescence,SILAC,TMT},
number = {12},
pages = {3551--3563},
pmid = {27765818},
title = {{Time-resolved analysis of proteome dynamics by TMT-SILAC hyperplexing.}},
url = {http://www.ncbi.nlm.nih.gov/pubmed/27765818},
volume = {15},
year = {2016}
}
@article{Wilhelm2014,
abstract = {Proteomes are characterized by large protein-abundance differences, cell-type- and time-dependent expression patterns and post-translational modifications, all of which carry biological information that is not accessible by genomics or transcriptomics. Here we present a mass-spectrometry-based draft of the human proteome and a public, high-performance, in-memory database for real-time analysis of terabytes of big data, called ProteomicsDB. The information assembled from human tissues, cell lines and body fluids enabled estimation of the size of the protein-coding genome, and identified organ-specific proteins and a large number of translated lincRNAs (long intergenic non-coding RNAs). Analysis of messenger RNA and protein-expression profiles of human tissues revealed conserved control of protein abundance, and integration of drug-sensitivity data enabled the identification of proteins predicting resistance or sensitivity. The proteome profiles also hold considerable promise for analysing the composition and stoichiometry of protein complexes. ProteomicsDB thus enables navigation of proteomes, provides biological insight and fosters the development of proteomic technology.},
archivePrefix = {arXiv},
arxivId = {209},
author = {Wilhelm, Mathias and Schlegl, Judith and Hahne, Hannes and Gholami, Amin Moghaddas and Lieberenz, Marcus and Savitski, Mikhail M. and Ziegler, Emanuel and Butzmann, Lars and Gessulat, Siegfried and Marx, Harald and Mathieson, Toby and Lemeer, Simone and Schnatbaum, Karsten and Reimer, Ulf and Wenschuh, Holger and Mollenhauer, Martin and Slotta-Huspenina, Julia and Boese, Joos Hendrik and Bantscheff, Marcus and Gerstmair, Anja and Faerber, Franz and Kuster, Bernhard},
doi = {10.1038/nature13319},
eprint = {209},
isbn = {1476-4687 (Electronic)$\backslash$n0028-0836 (Linking)},
issn = {14764687},
journal = {Nature},
number = {7502},
pages = {582--587},
pmid = {24870543},
publisher = {Nature Publishing Group},
title = {{Mass-spectrometry-based draft of the human proteome}},
url = {http://dx.doi.org/10.1038/nature13319},
volume = {509},
year = {2014}
}
@article{Wisniewski2014,
abstract = {Absolute protein quantification using mass spectrometry (MS)-based proteomics delivers protein concentrations or copy numbers per cell. Existing methodologies typically require a combination of isotope-labeled spike-in references, cell counting, and protein concentration measurements. Here we present a novel method that delivers similar quantitative results directly from deep eukaryotic proteome datasets without any additional experimental steps. We show that the MS signal of histones can be used as a "proteomic ruler" because it is proportional to the amount of DNA in the sample, which in turn depends on the number of cells. As a result, our proteomic ruler approach adds an absolute scale to the MS readout and allows estimation of the copy numbers of individual proteins per cell. We compare our protein quantifications with values derived via the use of stable isotope labeling by amino acids in cell culture and protein epitope signature tags in a method that combines spike-in protein fragment standards with precise isotope label quantification. The proteomic ruler approach yields quantitative readouts that are in remarkably good agreement with results from the precision method. We attribute this surprising result to the fact that the proteomic ruler approach omits error-prone steps such as cell counting or protein concentration measurements. The proteomic ruler approach is readily applicable to any deep eukaryotic proteome dataset-even in retrospective analysis-and we demonstrate its usefulness with a series of mouse organ proteomes.},
author = {Wi{\'{s}}niewski, Jacek R. and Hein, Marco Y. and Cox, J{\"{u}}rgen and Mann, Matthias},
doi = {10.1074/mcp.M113.037309},
isbn = {1535-9484 (Electronic)$\backslash$r1535-9476 (Linking)},
issn = {1535-9476},
journal = {Molecular {\&} Cellular Proteomics},
number = {12},
pages = {3497--3506},
pmid = {25225357},
title = {{A “Proteomic Ruler” for Protein Copy Number and Concentration Estimation without Spike-in Standards}},
url = {http://www.mcponline.org/lookup/doi/10.1074/mcp.M113.037309},
volume = {13},
year = {2014}
}
@article{Wisniewski2012,
abstract = {We report a proteomic analysis of microdissected material from formalin-fixed and paraffin-embedded colorectal cancer, quantifying {\textgreater} 7500 proteins between patient matched normal mucosa, primary carcinoma, and nodal metastases. Expression levels of 1808 proteins changed significantly between normal and cancer tissues, a much larger fraction than that reported in transcript-based studies. Tumor cells exhibit extensive alterations in the cell-surface and nuclear proteomes. Functionally similar changes in the proteome were observed comparing rapidly growing and differentiated CaCo-2 cells. In contrast, there was minimal proteomic remodeling between primary cancer and metastases, suggesting that no drastic proteome changes are necessary for the tumor to propagate in a different tissue context. Additionally, we introduce a new way to determine protein copy numbers per cell without protein standards. Copy numbers estimated in enterocytes and cancer cells are in good agreement with CaCo-2 and HeLa cells and with the literature data. Our proteomic data set furthermore allows mapping quantitative changes of functional protein classes, enabling novel insights into the biology of colon cancer.},
author = {Wi{\'{s}}niewski, Jacek R. and Ostasiewicz, Pawe{\l} and Du{\'{s}}, Kamila and Zieli{\'{n}}ska, Dorota F. and Gnad, Florian and Mann, Matthias},
doi = {10.1038/msb.2012.44},
isbn = {1744-4292 (Electronic)$\backslash$r1744-4292 (Linking)},
issn = {17444292},
journal = {Molecular Systems Biology},
keywords = {FASP,FFPE tissue,colon cancer,microdissection,quantitative proteomics},
number = {611},
pmid = {22968445},
title = {{Extensive quantitative remodeling of the proteome between normal colon tissue and adenocarcinoma}},
volume = {8},
year = {2012}
}
@article{Wisniewski2014a,
abstract = {We describe a proteomic approach combining the multi-enzyme digestion FASP-sample processing strategy and the 'Total Protein Approach' applied to absolute quantification of proteins in Escherichia coli. Consecutive digestion of whole cell lysates with LysC and trypsin allowed the generation of two populations of peptides at a yield of 76{\%}. Subsequent two 4-hour LC-MS/MS analyses allowed the identification of 19,000 unique peptides per sample. Notably, only 1.2 and 2.4{\%} of the identified peptides were found to be incompletely cleaved by the LysC and trypsin, respectively. The analysis resulted in the identification of 2200 proteins per sample. We show high reproducibility of the approach, allowing the accurate estimation of cellular protein concentrations. Quantitative analysis of the DNA content per sample enabled the calculation of the protein content per bacterial cell and, as a result, estimation of protein copy numbers. The accuracy of these estimations was confirmed by analyzing protein complexes with known subunit stoichiometry and cellular abundances. In stationary culture, a single bacterium contains about 6500 copies of ribosomes, 300 molecules of RNA polymerase and 10 DNA polymerase assembles. The here presented experimental and computational workflow offers an easy way to analyze proteomes quantitatively. Biological Significance: We demonstrate a proteomic workflow for in-depth analysis of small proteomes with minimal fractionation extent and mass spectrometry measuring time. For the first time we provide the quantitative picture of the Escherichia coli proteome at protein copy number. {\textcopyright} 2014.},
author = {Wi{\'{s}}niewski, Jacek R. and Rakus, Dariusz},
doi = {10.1016/j.jprot.2014.07.012},
isbn = {1876-7737 (Electronic)},
issn = {18767737},
journal = {Journal of Proteomics},
keywords = {'Total Protein Approach',Absolute protein quantification,Escherichia coli proteome,FASP,Filter-aided sample preparation,Protein copy number},
pages = {322--331},
pmid = {25063446},
title = {{Multi-enzyme digestion FASP and the 'Total Protein Approach'-based absolute quantification of the Escherichia coli proteome}},
volume = {109},
year = {2014}
}
@article{Vizcaino2016,
abstract = {The PRoteomics IDEntifications (PRIDE) database is one of the world-leading data repositories of mass spectrometry (MS)-based proteomics data. Since the beginning of 2014, PRIDE Archive (http://www.ebi.ac.uk/pride/archive/) is the new PRIDE archival system, replacing the original PRIDE database. Here we summarize the developments in PRIDE resources and related tools since the previous update manuscript in the Database Issue in 2013. PRIDE Archive constitutes a complete redevelopment of the original PRIDE, comprising a new storage backend, data submission system and web interface, among other components. PRIDE Archive supports the most-widely used PSI (Proteomics Standards Initiative) data standard formats (mzML and mzIdentML) and implements the data requirements and guidelines of the ProteomeXchange Consortium. The wide adoption of ProteomeXchange within the community has triggered an unprecedented increase in the number of submitted data sets (around 150 data sets per month). We outline some statistics on the current PRIDE Archive data contents. We also report on the status of the PRIDE related stand-alone tools: PRIDE Inspector, PRIDE Converter 2 and the ProteomeXchange submission tool. Finally, we will give a brief update on the resources under development 'PRIDE Cluster' and 'PRIDE Proteomes', which provide a complementary view and quality-scored information of the peptide and protein identification data available in PRIDE Archive.},
author = {Vizca{\'{i}}no, Juan Antonio and Csordas, Attila and Del-Toro, Noemi and Dianes, Jos{\'{e}} A. and Griss, Johannes and Lavidas, Ilias and Mayer, Gerhard and Perez-Riverol, Yasset and Reisinger, Florian and Ternent, Tobias and Xu, Qing Wei and Wang, Rui and Hermjakob, Henning},
doi = {10.1093/nar/gkv1145},
isbn = {1362-4962 (Electronic) 0305-1048 (Linking)},
issn = {13624962},
journal = {Nucleic Acids Research},
keywords = {community,datasets,guidelines,peptides},
month = {jan},
number = {D1},
pages = {D447--D456},
pmid = {26527722},
publisher = {Oxford University Press},
title = {{2016 update of the PRIDE database and its related tools}},
url = {https://academic.oup.com/nar/article-lookup/doi/10.1093/nar/gkv1145},
volume = {44},
year = {2016}
}
@article{Vowinckel2018,
abstract = {While quantitative proteomics is a key technology in biological research, the routine industry and diagnostics application is so far still limited by a moderate throughput, data consistency and robustness. In part, the restrictions emerge in the proteomics dependency on nanolitre/minute flow rate chromatography that enables a high sensitivity, but is difficult to handle on large sample series, and on the stochastic nature in data-dependent acquisition strategies. We here establish and benchmark a label-free, quantitative proteomics platform that uses microlitre/minute flow rate chromatography in combination with data-independent SWATH acquisition. Being able to largely compensate for the loss of sensitivity by exploiting the analytical capacities of microflow chromatography, we show that microLC-SWATH-MS is able to precisely quantify up to 4000 proteins in an hour or less, enables the consistent processing of sample series in high-throughput, and gains quantification precisions comparable to targeted proteomic assays. MicroLC-SWATH-MS can hence routinely process hundreds to thousands of samples to systematically create precise, label free quantitative proteomes.},
author = {Vowinckel, Jakob and Zelezniak, Aleksej and Bruderer, Roland and M{\"{u}}lleder, Michael and Reiter, Lukas and Ralser, Markus},
doi = {10.1038/s41598-018-22610-4},
issn = {20452322},
journal = {Scientific Reports},
number = {1},
pages = {1--10},
pmid = {29531254},
title = {{Cost-effective generation of precise label-free quantitative proteomes in high-throughput by microLC and data-independent acquisition}},
volume = {8},
year = {2018}
}
@article{Valikangas2018,
abstract = {To date, mass spectrometry (MS) data remain inherently biased as a result of reasons ranging from sample handling to differences caused by the instrumentation. Normalization is the process that aims to account for the bias and make samples more comparable. The selection of a proper normalization method is a pivotal task for the reliability of the downstream analysis and results. Many normalization methods commonly used in proteomics have been adapted from the DNA microarray techniques. Previous studies comparing normalization methods in proteomics have focused mainly on intragroup variation. In this study, several popular and widely used normalization methods representing different strategies in normalization are evaluated using three spike-in and one experimental mouse label-free proteomic data sets. The normalization methods are evaluated in terms of their ability to reduce variation between technical replicates, their effect on differential expression analysis and their effect on the estimation of logarithmic fold changes. Additionally, we examined whether normalizing the whole data globally or in segments for the differential expression analysis has an effect on the performance of the normalization methods. We found that variance stabilization normalization (Vsn) reduced variation the most between technical replicates in all examined data sets. Vsn also performed consistently well in the differential expression analysis. Linear regression normalization and local regression normalization performed also systematically well. Finally, we discuss the choice of a normalization method and some qualities of a suitable normalization method in the light of the results of our evaluation.},
author = {V{\"{a}}likangas, Tommi and Suomi, Tomi and Elo, Laura L.},
doi = {10.1093/bib/bbw095},
file = {::},
issn = {14774054},
journal = {Briefings in Bioinformatics},
keywords = {Bias,Differential expression,Intragroup variation,Label free,Logarithmic fold change,Mass spectrometry,Normalization,Proteomics,Quantitation,Reproducibility},
month = {oct},
number = {1},
pages = {1--11},
pmid = {27694351},
publisher = {Oxford University Press},
title = {{A systematic evaluation of normalization methods in quantitative label-free proteomics}},
url = {https://academic.oup.com/bib/article-lookup/doi/10.1093/bib/bbw095},
volume = {19},
year = {2018}
}

repository: SysBioChalmers/reproduce

repo_name: SysBioChalmers/reproduce

gha_language: R


text:
package repositories

import (
	"context"

	"code.cloudfoundry.org/cf-k8s-api/repositories/authorization"
)

//counterfeiter:generate -o fake -fake-name CFOrgRepository . CFOrgRepository
//counterfeiter:generate -o fake -fake-name AuthorizedNamespacesProvider . AuthorizedNamespacesProvider

type CFOrgRepository interface {
	CreateOrg(context context.Context, org OrgRecord) (OrgRecord, error)
	FetchOrgs(context context.Context, orgNames []string) ([]OrgRecord, error)
}

type AuthorizedNamespacesProvider interface {
	GetAuthorizedNamespaces(context.Context, authorization.Identity) ([]string, error)
}

type OrgRepoAuthDecorator struct {
	CFOrgRepository
	identity   authorization.Identity
	nsProvider AuthorizedNamespacesProvider
}

func NewOrgRepoAuthDecorator(
	repo CFOrgRepository,
	identity authorization.Identity,
	nsProvider AuthorizedNamespacesProvider,
) *OrgRepoAuthDecorator {
	return &OrgRepoAuthDecorator{
		CFOrgRepository: repo,
		identity:        identity,
		nsProvider:      nsProvider,
	}
}

func (r *OrgRepoAuthDecorator) FetchOrgs(ctx context.Context, names []string) ([]OrgRecord, error) {
	orgs, err := r.CFOrgRepository.FetchOrgs(ctx, names)
	if err != nil {
		return nil, err
	}

	authorizedNamespaces, err := r.nsProvider.GetAuthorizedNamespaces(ctx, r.identity)
	if err != nil {
		return nil, err
	}

	orgsFilter := toMap(authorizedNamespaces)

	result := []OrgRecord{}
	for _, org := range orgs {
		if _, ok := orgsFilter[org.GUID]; !ok {
			continue
		}

		result = append(result, org)
	}

	return result, nil
}

branch_name: refs/heads/main


text:
@article{roehner_proposed_2015,
 author = {Roehner, Nicholas and Oberortner, Ernst and Pocock, Matthew and Beal, Jacob and Clancy, Kevin and Madsen, Curtis and Misirli, Goksel and Wipat, Anil and Sauro, Herbert and Myers, Chris J.},
 date = {2015-01-16},
 doi = {10.1021/sb500176h},
 issn = {2161-5063, 2161-5063},
 journaltitle = {ACS Synthetic Biology},
 langid = {english},
 note = {00000},
 number = {1},
 pages = {57--71},
 shortjournal = {ACS Synth. Biol.},
 title = {Proposed Data Model for the Next Version of the Synthetic Biology Open Language},
 url = {https://pubs.acs.org/doi/10.1021/sb500176h},
 urldate = {2020-09-17},
 volume = {4}
}

gha_language: TeX


text:
package gdc

import (
	"sort"
)

func GDC(numbers []int) int {
	sort.Ints(numbers)
	divisors := [][]int{}
	for _, n := range numbers {
		d2 := []int{}
		for d := 1; d <= n; d++ {
			if n%d == 0 {
				d2 = append(d2, d)
			}
		}
		divisors = append(divisors, d2)
	}
	dvs := []int{}
	for i := 0; i <= numbers[len(numbers)-1]; i++ {
		present := true
		for _, dr := range divisors {
			if !isPresent(i, dr) {
				present = false
			}
		}
		if present {
			dvs = append(dvs, i)
		}
	}
	if len(dvs) == 0 {
		return 1
	}
	sort.Ints(dvs)
	return dvs[len(dvs)-1]
}

func isPresent(i int, dr1 []int) bool {
	for _, v := range dr1 {
		if i == v {
			return true
		}
	}
	return false
}

func EuclideanGDC(a int, b int) int {
	if b == 0 {
		return a
	}
	a, b = b, a%b
	return EuclideanGDC(a, b)
}

license: Unlicense

repository: eloylp/go-training

repo_name: eloylp/go-training


text:
# Copyright (C) 2020, STMicroelectronics - All Rights Reserved

SUMMARY = "Installing the installer script"

LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6"

SRC_URI = " \
    file://install_pkg.sh \
    "

do_install () {
    install -d ${D}${prefix}/local/weston-start-at-startup/
    install -m 0755 ${WORKDIR}/install_pkg.sh ${D}${prefix}/local/weston-start-at-startup/
}

FILES_${PN} += " ${prefix}/local/weston-start-at-startup/"

extension: bb


text:
@article{pmid34530733,
 author = {Tahkola, A.  and Korhonen, P.  and Kautiainen, H.  and Niiranen, T.  and Mäntyselkä, P. },
 journal = {BMC Cardiovasc Disord},
 month = {Sep},
 number = {1},
 pages = {444},
 title = {The impact of antihypertensive treatment initiation on health-related quality of life and cardiovascular risk factor levels: a prospective, interventional study},
 volume = {21},
 year = {2021}
}

repository: hypertensioncenter/academic-kickstart

repo_name: hypertensioncenter/academic-kickstart


text:
@article{ramelyte3650575oncolytic,
  title={Oncolytic Virotherapy Mediated Anti-Tumor Response: A Single-Cell Perspective},
  author={Ramelyte, Egle and Tastanova, Aizhan and Bal{\'a}zs, Zsolt and Turko, Patrick and Menzel, Ulrike and Guenova, Emmanuella and Beisel, Christian and Krauthammer, Michael and Levesque, Mitchell Paul and Rreinhard, Dummer},
  journal={Available at SSRN 3650575}
}

repository: spiros/lab-website

repo_name: spiros/lab-website


text:
add_library(iface INTERFACE)
install(TARGETS iface EXPORT ifaceExport)

export(EXPORT ifaceExport FILE "${CMAKE_CURRENT_BINARY_DIR}/theTargets.cmake")
include("${CMAKE_CURRENT_BINARY_DIR}/theTargets.cmake")

extension: cmake


text:
file(REMOVE_RECURSE
  "CMakeFiles/PetShop.dir/simpe_tasks/PetShop.cpp.obj"
  "PetShop.pdb"
  "PetShop.exe"
  "PetShop.exe.manifest"
  "libPetShop.dll.a"
)

# Per-language clean rules from dependency scanning.
foreach(lang CXX)
  include(CMakeFiles/PetShop.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

url: https://raw.githubusercontent.com/galin-kostadinov/Software-Engineering/55189648d787b35f1e9cd24cc4449c6beda51c90/C++/Programming Basics with C++/02. Simple Operations and Calculation/cmake-build-debug/CMakeFiles/PetShop.dir/cmake_clean.cmake

repository: galin-kostadinov/Software-Engineering

repo_name: galin-kostadinov/Software-Engineering


text:
include(${CMAKE_CURRENT_LIST_DIR}/../pmm/util.cmake)
_pmm_parse_script_args(
    . /Verbose
    - /Docker /Test
    )

find_program(ARG_/Docker docker)

get_filename_component(test_dir "${CMAKE_CURRENT_LIST_DIR}/${ARG_/Test}.docker" ABSOLUTE)
set(test_pr_dir "${test_dir}/project")
if(NOT EXISTS "${test_pr_dir}")
    set(test_pr_dir "${CMAKE_CURRENT_LIST_DIR}/default-project")
endif()

if(NOT ARG_/Verbose)
    set(OUTPUT_EAT_ARGS ERROR_VARIABLE out OUTPUT_VARIABLE out)
endif()

function(run_checked)
    execute_process(
        ${OUTPUT_EAT_ARGS}
        RESULT_VARIABLE retc
        COMMAND ${ARGN}
        )
    if(retc)
        string(REPLACE ";" " " cmd "${ARGN}")
        message(FATAL_ERROR "Running command (${cmd}) failed [${retc}]: ${out}")
    endif()
endfunction()

set(image_name pmm.test_container.${ARG_/Test})

message(STATUS "Building Docker container")
run_checked(${ARG_/Docker} build -t "${image_name}" "${test_dir}")

message(STATUS "Configuring project")
get_filename_component(pmm_dir "${CMAKE_CURRENT_LIST_DIR}/../pmm" ABSOLUTE)
set(mount_args
    -v "${test_pr_dir}:/host/source"
    -v "${CMAKE_CURRENT_LIST_DIR}/../pmm:/host/pmm"
    -v "${CMAKE_CURRENT_LIST_DIR}/../pmm.cmake:/host/pmm.cmake"
    )
run_checked(${ARG_/Docker} run --rm -t ${mount_args} ${image_name}
    cmake
        -H/host/source
        -B/tmp/build
        -DPMM_URL=file:///host/pmm
        -DPMM_INCLUDE=/host/pmm.cmake
    )

repository: zesem/pmm

repo_name: zesem/pmm

branch_name: refs/heads/develop

gha_language: CMake


text:
package wiki

import (
	"net/http"
	"text/template"

	"github.com/peterhellberg/wiki/db"
	"github.com/zenazn/goji/web"
)

func (w *Wiki) Edit(c web.C, rw http.ResponseWriter, r *http.Request) {
	name := w.getPageName(c.URLParams["name"])

	w.DB().View(func(tx *db.Tx) error {
		p, _ := tx.Page(name)

		t, err := template.New("edit").Parse(editTpl)

		template.Must(t, err).Execute(rw, map[string]string{
			"Path": "/" + string(p.Name),
			"Text": string(p.Text),
		})

		return nil
	})
}

repository: ciarand/wiki

repo_name: ciarand/wiki


text:
// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
// ------------------------------------------------------------

package blobstorage

import (
	"bytes"
	"context"
	b64 "encoding/base64"
	"encoding/json"
	"fmt"
	"net/url"
	"strconv"

	"github.com/Azure/azure-storage-blob-go/azblob"
	"github.com/dapr/components-contrib/bindings"
	"github.com/dapr/dapr/pkg/logger"
	"github.com/google/uuid"
)

const (
	blobName                 = "blobName"
	contentType              = "ContentType"
	contentMD5               = "ContentMD5"
	contentEncoding          = "ContentEncoding"
	contentLanguage          = "ContentLanguage"
	contentDisposition       = "ContentDisposition"
	cacheControl             = "CacheControl"
	defaultGetBlobRetryCount = 10
)

// AzureBlobStorage allows saving blobs to an Azure Blob Storage account
type AzureBlobStorage struct {
	metadata     *blobStorageMetadata
	containerURL azblob.ContainerURL

	logger logger.Logger
}

type blobStorageMetadata struct {
	StorageAccount    string `json:"storageAccount"`
	StorageAccessKey  string `json:"storageAccessKey"`
	Container         string `json:"container"`
	DecodeBase64      string `json:"decodeBase64"`
	GetBlobRetryCount int    `json:"getBlobRetryCount"`
	PublicAccessLevel string `json:"publicAccessLevel"`
}

type createResponse struct {
	BlobURL string `json:"blobURL"`
}

// NewAzureBlobStorage returns a new Azure Blob Storage instance
func NewAzureBlobStorage(logger logger.Logger) *AzureBlobStorage {
	return &AzureBlobStorage{logger: logger}
}

// Init performs metadata parsing
func (a *AzureBlobStorage) Init(metadata bindings.Metadata) error {
	m, err := a.parseMetadata(metadata)
	if err != nil {
		return err
	}
	a.metadata = m
	credential, err := azblob.NewSharedKeyCredential(m.StorageAccount, m.StorageAccessKey)
	if err != nil {
		return fmt.Errorf("invalid credentials with error: %s", err.Error())
	}
	p := azblob.NewPipeline(credential, azblob.PipelineOptions{})

	containerName := a.metadata.Container
	URL, _ := url.Parse(
		fmt.Sprintf("https://%s.blob.core.windows.net/%s", m.StorageAccount, containerName))
	containerURL := azblob.NewContainerURL(*URL, p)

	ctx := context.Background()
	_, err = containerURL.Create(ctx, azblob.Metadata{}, azblob.PublicAccessType(m.PublicAccessLevel))
	// Don't return error, container might already exist
	a.logger.Debugf("error creating container: %s", err)
	a.containerURL = containerURL

	return nil
}

func (a *AzureBlobStorage) parseMetadata(metadata bindings.Metadata) (*blobStorageMetadata, error) {
	connInfo := metadata.Properties
	b, err := json.Marshal(connInfo)
	if err != nil {
		return nil, err
	}

	var m blobStorageMetadata
	err = json.Unmarshal(b, &m)
	if err != nil {
		return nil, err
	}

	if m.GetBlobRetryCount == 0 {
		m.GetBlobRetryCount = defaultGetBlobRetryCount
	}

	return &m, nil
}

func (a *AzureBlobStorage) Operations() []bindings.OperationKind {
	return []bindings.OperationKind{bindings.CreateOperation, bindings.GetOperation}
}

func (a *AzureBlobStorage) create(blobURL azblob.BlockBlobURL, req *bindings.InvokeRequest) (*bindings.InvokeResponse, error) {
	var blobHTTPHeaders azblob.BlobHTTPHeaders
	if val, ok := req.Metadata[contentType]; ok && val != "" {
		blobHTTPHeaders.ContentType = val
		delete(req.Metadata, contentType)
	}
	if val, ok := req.Metadata[contentMD5]; ok && val != "" {
		sDec, err := b64.StdEncoding.DecodeString(val)
		if err != nil || len(sDec) != 16 {
			return nil, fmt.Errorf("the MD5 value specified in Content MD5 is invalid, MD5 value must be 128 bits and base64 encoded")
		}
		blobHTTPHeaders.ContentMD5 = sDec
		delete(req.Metadata, contentMD5)
	}
	if val, ok := req.Metadata[contentEncoding]; ok && val != "" {
		blobHTTPHeaders.ContentEncoding = val
		delete(req.Metadata, contentEncoding)
	}
	if val, ok := req.Metadata[contentLanguage]; ok && val != "" {
		blobHTTPHeaders.ContentLanguage = val
		delete(req.Metadata, contentLanguage)
	}
	if val, ok := req.Metadata[contentDisposition]; ok && val != "" {
		blobHTTPHeaders.ContentDisposition = val
		delete(req.Metadata, contentDisposition)
	}
	if val, ok := req.Metadata[cacheControl]; ok && val != "" {
		blobHTTPHeaders.CacheControl = val
		delete(req.Metadata, cacheControl)
	}

	d, err := strconv.Unquote(string(req.Data))
	if err == nil {
		req.Data = []byte(d)
	}

	// The "true" is the only allowed positive value. Other positive variations like "True" not acceptable.
	if a.metadata.DecodeBase64 == "true" {
		decoded, decodeError := b64.StdEncoding.DecodeString(string(req.Data))
		if decodeError != nil {
			return nil, decodeError
		}
		req.Data = decoded
	}

	_, err = azblob.UploadBufferToBlockBlob(context.Background(), req.Data, blobURL, azblob.UploadToBlockBlobOptions{
		Parallelism:     16,
		Metadata:        req.Metadata,
		BlobHTTPHeaders: blobHTTPHeaders,
	})
	if err != nil {
		return nil, fmt.Errorf("error uploading az blob: %s", err)
	}

	resp := createResponse{
		BlobURL: blobURL.String(),
	}
	b, err := json.Marshal(resp)
	if err != nil {
		return nil, fmt.Errorf("error marshalling create response for azure blob: %s", err)
	}

	return &bindings.InvokeResponse{
		Data: b,
	}, nil
}

func (a *AzureBlobStorage) get(blobURL azblob.BlockBlobURL, req *bindings.InvokeRequest) (*bindings.InvokeResponse, error) {
	resp, err := blobURL.Download(context.TODO(), 0, azblob.CountToEnd, azblob.BlobAccessConditions{}, false)
	if err != nil {
		return nil, fmt.Errorf("error downloading az blob: %s", err)
	}

	bodyStream := resp.Body(azblob.RetryReaderOptions{MaxRetryRequests: a.metadata.GetBlobRetryCount})

	b := bytes.Buffer{}
	_, err = b.ReadFrom(bodyStream)
	if err != nil {
		return nil, fmt.Errorf("error reading az blob body: %s", err)
	}

	return &bindings.InvokeResponse{
		Data: b.Bytes(),
	}, nil
}

func (a *AzureBlobStorage) Invoke(req *bindings.InvokeRequest) (*bindings.InvokeResponse, error) {
	name := ""
	if val, ok := req.Metadata[blobName]; ok && val != "" {
		name = val
		delete(req.Metadata, blobName)
	} else {
		name = uuid.New().String()
	}

	blobURL := a.containerURL.NewBlockBlobURL(name)
	switch req.Operation {
	case bindings.CreateOperation:
		return a.create(blobURL, req)
	case bindings.GetOperation:
		return a.get(blobURL, req)
	case bindings.DeleteOperation, bindings.ListOperation:
		fallthrough
	default:
		return nil, fmt.Errorf("unsupported operation %s", req.Operation)
	}
}

repository: dipkakwani/dapr-demo

repo_name: dipkakwani/dapr-demo


text:
@inProceedings{gasse16,
  title = {Identifying the irreducible disjoint factors of a multivariate probability distribution},
  author = {Gasse, Maxime and Aussem, Alex},
  pages = {183-194},
  abstract = {We study the problem of decomposing a multivariate probability distribution $p(\mathbf{v})$ defined over a set of random variables $\mathbf{V}=\{V_1,\dots,V_n\}$ into a product of factors defined over disjoint subsets $\{\mathbf{V}_{F_1},\dots,\mathbf{V}_{F_m}\}$. We show that the decomposition of $\mathbf{V}$ into irreducible disjoint factors forms a unique partition, which corresponds to the connected components of a Bayesian or Markov network, given that it is faithful to $p$. Finally, we provide three generic procedures to identify these factors with $O(n^2)$ pairwise conditional independence tests ($V_i\perp V_j {\mathbin{\mid}}\mathbf{Z}$) under much less restrictive assumptions: 1) $p$ supports the Intersection property ii) $p$ supports the Composition property iii) no assumption at all.},
}

repository: mreid/papersite

repo_name: mreid/papersite