text:
require dnsmasq.inc

PR = "r3"

SRC_URI[dnsmasq-2.72.md5sum] = "cf82f81cf09ad3d47612985012240483"
SRC_URI[dnsmasq-2.72.sha256sum] = "635f1b47417d17cf32e45cfcfd0213ac39fd09918479a25373ba9b2ce4adc05d"

repository: webbbn/OpenSolo

repo_name: webbbn/OpenSolo


text:
// Copyright 2017 Google Inc.
//
// 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
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

package main

import (
	"flag"
	"net/http"

	"juju.nz/x/pipoint"

	"gobot.io/x/gobot"
	"gobot.io/x/gobot/api"
	"gobot.io/x/gobot/platforms/mavlink"
	"gobot.io/x/gobot/platforms/mqtt"
)

func main() {
	mqttUrl := flag.String("mqtt.url", "", "URI of the MQTT server, such as tls://iot.juju.net.nz:8883")
	mavAddr := flag.String("mavlink.address", ":14550", "Address to listen on for Mavlink messages")

	flag.Parse()

	var cons []gobot.Connection
	var drivers []gobot.Device

	pi := pipoint.NewPiPoint()

	if mavAddr != nil && *mavAddr != "" {
		mav := mavlink.NewUDPAdaptor(*mavAddr)
		cons = append(cons, mav)
		driver := mavlink.NewDriver(mav)
		drivers = append(drivers, driver)
		driver.On(driver.Event(mavlink.MessageEvent), pi.Message)
	}

	if mqttUrl != nil && *mqttUrl != "" {
		mq := mqtt.NewAdaptor(*mqttUrl, "pipoint")
		cons = append(cons, mq)
		mq.SetAutoReconnect(true)
		pi.AddMQTT(mq)
	}

	http.HandleFunc("/metrics", pi.Params.Metrics)

	master := gobot.NewMaster()
	a := api.NewAPI(master)
	a.Start()

	robot := gobot.NewRobot("pipoint",
		cons, drivers,
		func() {
			go pi.Run()
		})

	master.AddRobot(robot)
	master.Start()
}

repository: nzmichaelh/pipoint

license_type: permissive

repo_name: nzmichaelh/pipoint

branch_name: refs/heads/master

extension: go


text:
// Copyright 2018 gopcua authors. All rights reserved.
// Use of this source code is governed by a MIT-style license that can be
// found in the LICENSE file.

package services

import (
	"testing"
	"time"

	"github.com/wmnsk/gopcua/datatypes"
	"github.com/wmnsk/gopcua/utils/codectest"
)

func TestResponseHeader(t *testing.T) {
	cases := []codectest.Case{
		{
			Struct: NewResponseHeader(
				time.Date(2018, time.August, 10, 23, 0, 0, 0, time.UTC),
				1,
				0x00000000,
				NewDiagnosticInfo(
					false, false, false, false, false, false, false,
					0, 0, 0, 0, nil, 0, nil,
				),
				[]string{"foo", "bar"},
				NewAdditionalHeader(
					datatypes.NewExpandedNodeID(
						false, false,
						datatypes.NewTwoByteNodeID(255),
						"", 0,
					),
					0x00,
				),
				[]byte{0xde, 0xad, 0xbe, 0xef},
			),
			Bytes: []byte{
				// Timestamp
				0x00, 0x98, 0x67, 0xdd, 0xfd, 0x30, 0xd4, 0x01,
				// RequestHandle
				0x01, 0x00, 0x00, 0x00,
				// ServiceResult
				0x00, 0x00, 0x00, 0x00,
				// ServiceDiagnostics
				0x00,
				// StringTable: "foo", "bar"
				0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
				0x66, 0x6f, 0x6f, 0x03, 0x00, 0x00, 0x00, 0x62,
				0x61, 0x72,
				// AdditionalHeader
				0x00, 0xff, 0x00,
				// dummy Payload
				0xde, 0xad, 0xbe, 0xef,
			},
		},
	}
	codectest.Run(t, cases, func(b []byte) (codectest.S, error) {
		return DecodeResponseHeader(b)
	})
}

license: MIT

repository: eugeis/gopcua

repo_name: eugeis/gopcua

gha_license_id: MIT


text:
package models

import (
	"fmt"
	"time"

	"github.com/go-playground/validator/v10"
	schema "github.com/gojek/turing/api/turing/internal/alertschema"
)

// Alert contains policy that determines the "type of notification" and
// the "metric condition" that will trigger notifications for a
// particular service.
//
// There are 5 provided metrics that can be used as conditions for triggering the alert:
//
// - throughput: when current request per second is lower than the threshold
// - latency95p: when the 95-th percentile millisecond latency is higher than the threshold
// - error_rate: when the error percentage of all requests is higher than the threshold
// - cpu_util: when the percentage of cpu utilization is higher than the threshold
// - memory_util: when the percentage of memory utilization is higher than the threshold
//
// There are "warning" and "critical" thresholds that can be specified. A value of 0 or less
// will deactivate that particular type of alert. "warning" and "critical" will usually
// send alerts to different notifications channels.
//
// Environment, Team, Service, Metric and Duration are required in order to generate the correct
// query for the metric values and to direct the alert to the correct recipients.
//
type Alert struct {
	Model

	Environment       string  `json:"environment" validate:"required"`
	Team              string  `json:"team" validate:"required"`
	Service           string  `json:"service"`
	Metric            Metric  `json:"metric" validate:"oneof=throughput latency95p error_rate cpu_util memory_util"`
	WarningThreshold  float64 `json:"warning_threshold"`
	CriticalThreshold float64 `json:"critical_threshold"`
	// Duration to wait after the threshold is violated before firing the alert.
	// The duration format is a sequence of decimal numbers followed by a time unit suffix.
	// For instance: 5m
	Duration string `json:"duration" validate:"required"`
}

type Metric string

const (
	MetricThroughput Metric = "throughput"
	MetricLatency95p Metric = "latency95p"
	MetricErrorRate  Metric = "error_rate"
	MetricCPUUtil    Metric = "cpu_util"
	MetricMemoryUtil Metric = "memory_util"
)

func (alert Alert) Validate() error {
	validate := validator.New()
	if err := validate.Struct(alert); err != nil {
		return err
	}
	if _, err := time.ParseDuration(alert.Duration); err != nil {
		return err
	}
	return nil
}

// Group creates an AlertGroup from the Alert specification. An alert group follows the alerting rule format
// in prometheus: https://prometheus.io/docs/prometheus/latest/configuration/alerting_rules/
func (alert Alert) Group(playbookURL string, dashboardURL string) schema.AlertGroup {
	groupName := fmt.Sprintf("%s_%s_%s_%s", alert.Environment, alert.Team, alert.Service, alert.Metric)
	alerts := make([]schema.Alert, 0)

	if alert.WarningThreshold > 0 {
		alerts = append(alerts, schema.Alert{
			AlertName:  fmt.Sprintf("%s_%s_violation_%s", alert.Service, alert.Metric, alert.Environment),
			Expression: getAlertExpr(alert.Metric, alert.Environment, alert.Service, alert.WarningThreshold),
			For:        alert.Duration,
			Labels: map[string]string{
				"owner":        alert.Team,
				"service_name": alert.Service,
				"severity":     "warning",
			},
			Annotations: map[string]string{
				"summary": fmt.Sprintf("%s is %s than the threshold: %.0f%s",
					alert.Metric,
					getAlertOperatorText(alert.Metric),
					alert.WarningThreshold,
					getAlertUnit(alert.Metric),
				),
				"description": fmt.Sprintf("%s for the past %s: {{ $value }}%s",
					alert.Metric,
					alert.Duration,
					getAlertUnit(alert.Metric),
				),
				"dashboard": dashboardURL,
				"playbook":  playbookURL,
			},
		})
	}

	if alert.CriticalThreshold > 0 {
		alerts = append(alerts, schema.Alert{
			AlertName:  fmt.Sprintf("%s_%s_violation_%s", alert.Service, alert.Metric, alert.Environment),
			Expression: getAlertExpr(alert.Metric, alert.Environment, alert.Service, alert.CriticalThreshold),
			For:        alert.Duration,
			Labels: map[string]string{
				"owner":        alert.Team,
				"service_name": alert.Service,
				"severity":     "critical",
			},
			Annotations: map[string]string{
				"summary": fmt.Sprintf("%s is %s than the threshold: %.0f%s",
					alert.Metric,
					getAlertOperatorText(alert.Metric),
					alert.CriticalThreshold,
					getAlertUnit(alert.Metric),
				),
				"description": fmt.Sprintf("%s for the past %s: {{ $value }}%s",
					alert.Metric,
					alert.Duration,
					getAlertUnit(alert.Metric),
				),
				"dashboard": dashboardURL,
				"playbook":  playbookURL,
			},
		})
	}

	return schema.AlertGroup{
		Name:   groupName,
		Alerts: alerts,
	}
}

func getAlertExpr(metric Metric, env string, rev string, threshold float64) string {
	switch metric {
	case MetricThroughput:
		return fmt.Sprintf(`sum(rate(revision_request_count{
  environment="%s",
  service_name=~"%s-[0-9]*"
}[1m])) %s %f
`, env, rev, getAlertOperator(metric), threshold)

	case MetricLatency95p:
		return fmt.Sprintf(`histogram_quantile(0.95, sum(rate(revision_request_latencies_bucket{
  environment="%s",
  service_name=~"%s-[0-9]*"
}[1m])) by (le)) %s %f
`, env, rev, getAlertOperator(metric), threshold)

	case MetricErrorRate:
		return fmt.Sprintf(`sum(rate(revision_request_count{
  environment="%s",
  service_name=~"%s-[0-9]*",
  response_code_class!="2xx"
}[1m]))
/
sum(rate(revision_request_count{
  environment="%s",
  service_name=~"%s-[0-9]*"
}[1m])) * 100.0 %s %f
`, env, rev, env, rev, getAlertOperator(metric), threshold)

	case MetricCPUUtil:
		return fmt.Sprintf(`sum(rate(container_cpu_usage_seconds_total{
  environment="%s",
  pod=~"%s-[0-9]*.*"
}[1m]))
/
sum(kube_pod_container_resource_requests_cpu_cores{
  environment="%s",
  pod=~"%s-[0-9]*.*"
}) * 100.0 %s %f
`, env, rev, env, rev, getAlertOperator(metric), threshold)

	case MetricMemoryUtil:
		return fmt.Sprintf(`sum(container_memory_usage_bytes{
  environment="%s",
  pod=~"%s-[0-9]*.*",
  image!=""
})
/
sum(kube_pod_container_resource_requests_memory_bytes{
  environment="%s",
  pod=~"%s-[0-9]*.*"
}) * 100.0 %s %f
`, env, rev, env, rev, getAlertOperator(metric), threshold)

	default:
		return ""
	}
}

func getAlertOperator(metric Metric) string {
	if metric == MetricThroughput {
		return "<"
	}
	return ">"
}

func getAlertOperatorText(metric Metric) string {
	if metric == MetricThroughput {
		return "lower"
	}
	return "higher"
}

func getAlertUnit(metric Metric) string {
	switch metric {
	case MetricThroughput:
		return "rps"
	case MetricLatency95p:
		return "ms"
	case MetricErrorRate:
		fallthrough
	case MetricCPUUtil:
		fallthrough
	case MetricMemoryUtil:
		return "%"
	}
	return ""
}

repository: davidheryanto/turing

repo_name: davidheryanto/turing

branch_name: refs/heads/main


text:
@InProceedings{foulds11a,
  title = {Revisiting MAP Estimation, Message Passing and Perfect Graphs},
  author = {James Foulds and Nicholas Navaroli and Padhraic Smyth and Alexander Ihler},
  pages = {278--286},
  abstract = {Given a graphical model, one of them ost useful queries is to find the most likely configuration of its variables. This task, known as the maximum a posteriori (MAP) problem, can be solved efficiently via message passing techniques when the graph is a tree, but is NP-hard for general graphs. Jebara (2009) shows that the MAP problem can be converted into the stable set problem, which can be solved in polynomial time for a broad class of graphs known as perfect graphs via a linear programming relaxation technique. This is a result of great theoretical interest. However, the article additionally claims that max-product linear programming (MPLP) message passing techniques of Globerson and Jaakkola (2007) are also guaranteed to solve these problems exactly and efficiently. We investigate this claim, show that it does not hold, and repair it with alternative message passing algorithms.

[pdf]},
  pdf = {http://jmlr.org/proceedings/papers/v15/foulds11a/foulds11a.pdf},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX

extension: bib


text:
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
package translation

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"go.opentelemetry.io/otel/schema/v1.0/ast"
	"go.opentelemetry.io/otel/schema/v1.0/types"

	"github.com/open-telemetry/opentelemetry-collector-contrib/processor/schemaprocessor/internal/migrate"
)

func TestNewRevision(t *testing.T) {
	t.Parallel()

	for _, tc := range []struct {
		name         string
		inVersion    *Version
		inDefinition ast.VersionDef
		expect       *RevisionV1
	}{
		{
			name:         "no definition defined",
			inVersion:    &Version{1, 1, 1},
			inDefinition: ast.VersionDef{},
			expect: &RevisionV1{
				ver:              &Version{1, 1, 1},
				all:              migrate.NewAttributeChangeSetSlice(),
				resource:         migrate.NewAttributeChangeSetSlice(),
				spans:            migrate.NewConditionalAttributeSetSlice(),
				eventNames:       migrate.NewSignalNameChangeSlice(),
				eventAttrsOnSpan: migrate.NewConditionalAttributeSetSlice(),
				eventAttrsOnName: migrate.NewConditionalAttributeSetSlice(),
				metricsAttrs:     migrate.NewConditionalAttributeSetSlice(),
				metricNames:      migrate.NewSignalNameChangeSlice(),
			},
		},
		{
			name:      "complete version definition used",
			inVersion: &Version{1, 0, 0},
			inDefinition: ast.VersionDef{
				All: ast.Attributes{
					Changes: []ast.AttributeChange{
						{
							RenameAttributes: &ast.RenameAttributes{
								AttributeMap: ast.AttributeMap{
									"state": "status",
								},
							},
						},
						{
							RenameAttributes: &ast.RenameAttributes{
								AttributeMap: ast.AttributeMap{
									"status": "state",
								},
							},
						},
					},
				},
				Resources: ast.Attributes{
					Changes: []ast.AttributeChange{
						{
							RenameAttributes: &ast.RenameAttributes{
								AttributeMap: ast.AttributeMap{
									"service_name": "service.name",
								},
							},
						},
					},
				},
				Spans: ast.Spans{
					Changes: []ast.SpansChange{
						{
							RenameAttributes: &ast.AttributeMapForSpans{
								ApplyToSpans: []types.SpanName{
									"application start",
								},
								AttributeMap: ast.AttributeMap{
									"service_version": "service.version",
								},
							},
						},
						{
							RenameAttributes: &ast.AttributeMapForSpans{
								AttributeMap: ast.AttributeMap{
									"deployment.environment": "service.deployment.environment",
								},
							},
						},
					},
				},
				SpanEvents: ast.SpanEvents{
					Changes: []ast.SpanEventsChange{
						{
							RenameEvents: &ast.RenameSpanEvents{
								EventNameMap: map[string]string{
									"started": "application started",
								},
							},
							RenameAttributes: &ast.RenameSpanEventAttributes{
								ApplyToSpans: []types.SpanName{
									"service running",
								},
								ApplyToEvents: []types.EventName{
									"service errored",
								},
								AttributeMap: ast.AttributeMap{
									"service.app.name": "service.name",
								},
							},
						},
					},
				},
				Logs: ast.Logs{
					Changes: []ast.LogsChange{
						{
							RenameAttributes: &ast.RenameAttributes{
								AttributeMap: ast.AttributeMap{
									"ERROR": "error",
								},
							},
						},
					},
				},
				Metrics: ast.Metrics{
					Changes: []ast.MetricsChange{
						{
							RenameMetrics: map[types.MetricName]types.MetricName{
								"service.computed.uptime": "service.uptime",
							},
							RenameAttributes: &ast.AttributeMapForMetrics{
								ApplyToMetrics: []types.MetricName{
									"service.runtime",
								},
								AttributeMap: ast.AttributeMap{
									"runtime": "service.language",
								},
							},
						},
					},
				},
			},
			expect: &RevisionV1{
				ver: &Version{1, 0, 0},
				all: migrate.NewAttributeChangeSetSlice(
					migrate.NewAttributeChangeSet(map[string]string{
						"state": "status",
					}),
					migrate.NewAttributeChangeSet(map[string]string{
						"status": "state",
					}),
				),
				resource: migrate.NewAttributeChangeSetSlice(
					migrate.NewAttributeChangeSet(map[string]string{
						"service_name": "service.name",
					}),
				),
				spans: migrate.NewConditionalAttributeSetSlice(
					migrate.NewConditionalAttributeSet(
						map[string]string{"service_version": "service.version"},
						"application start",
					),
					migrate.NewConditionalAttributeSet[string](
						map[string]string{"deployment.environment": "service.deployment.environment"},
					),
				),
				eventNames: migrate.NewSignalNameChangeSlice(
					migrate.NewSignalNameChange(map[string]string{
						"started": "application started",
					}),
				),
				eventAttrsOnSpan: migrate.NewConditionalAttributeSetSlice(
					migrate.NewConditionalAttributeSet(
						map[string]string{
							"service.app.name": "service.name",
						},
						"service running",
					),
				),
				eventAttrsOnName: migrate.NewConditionalAttributeSetSlice(
					migrate.NewConditionalAttributeSet(
						map[string]string{
							"service.app.name": "service.name",
						},
						"service errored",
					),
				),
				metricsAttrs: migrate.NewConditionalAttributeSetSlice(
					migrate.NewConditionalAttributeSet(
						map[string]string{
							"runtime": "service.language",
						},
						"service.runtime",
					),
				),
				metricNames: migrate.NewSignalNameChangeSlice(
					migrate.NewSignalNameChange(map[string]string{
						"service.computed.uptime": "service.uptime",
					}),
				),
			},
		},
	} {
		tc := tc

		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			rev := NewRevision(tc.inVersion, tc.inDefinition)
			assert.EqualValues(t, tc.expect, rev, "Must match the expected values")
		})
	}
}

gha_language: Go


text:
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: commercionetwork/government/query.proto

package types

import (
	context "context"
	fmt "fmt"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type QueryGovernmentAddrRequest struct {
}

func (m *QueryGovernmentAddrRequest) Reset()         { *m = QueryGovernmentAddrRequest{} }
func (m *QueryGovernmentAddrRequest) String() string { return proto.CompactTextString(m) }
func (*QueryGovernmentAddrRequest) ProtoMessage()    {}
func (*QueryGovernmentAddrRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_88c43dcc4e5acf65, []int{0}
}
func (m *QueryGovernmentAddrRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryGovernmentAddrRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryGovernmentAddrRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryGovernmentAddrRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryGovernmentAddrRequest.Merge(m, src)
}
func (m *QueryGovernmentAddrRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryGovernmentAddrRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryGovernmentAddrRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryGovernmentAddrRequest proto.InternalMessageInfo

type QueryGovernmentAddrResponse struct {
	GovernmentAddress string `protobuf:"bytes,1,opt,name=governmentAddress,proto3" json:"governmentAddress,omitempty"`
}

func (m *QueryGovernmentAddrResponse) Reset()         { *m = QueryGovernmentAddrResponse{} }
func (m *QueryGovernmentAddrResponse) String() string { return proto.CompactTextString(m) }
func (*QueryGovernmentAddrResponse) ProtoMessage()    {}
func (*QueryGovernmentAddrResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_88c43dcc4e5acf65, []int{1}
}
func (m *QueryGovernmentAddrResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryGovernmentAddrResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryGovernmentAddrResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryGovernmentAddrResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryGovernmentAddrResponse.Merge(m, src)
}
func (m *QueryGovernmentAddrResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryGovernmentAddrResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryGovernmentAddrResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryGovernmentAddrResponse proto.InternalMessageInfo

func (m *QueryGovernmentAddrResponse) GetGovernmentAddress() string {
	if m != nil {
		return m.GovernmentAddress
	}
	return ""
}

func init() {
	proto.RegisterType((*QueryGovernmentAddrRequest)(nil), "commercionetwork.commercionetwork.government.QueryGovernmentAddrRequest")
	proto.RegisterType((*QueryGovernmentAddrResponse)(nil), "commercionetwork.commercionetwork.government.QueryGovernmentAddrResponse")
}

func init() {
	proto.RegisterFile("commercionetwork/government/query.proto", fileDescriptor_88c43dcc4e5acf65)
}

var fileDescriptor_88c43dcc4e5acf65 = []byte{
	// 255 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4f, 0xce, 0xcf, 0xcd,
	0x4d, 0x2d, 0x4a, 0xce, 0xcc, 0xcf, 0x4b, 0x2d, 0x29, 0xcf, 0x2f, 0xca, 0xd6, 0x4f, 0xcf, 0x2f,
	0x4b, 0x2d, 0xca, 0xcb, 0x4d, 0xcd, 0x2b, 0xd1, 0x2f, 0x2c, 0x4d, 0x2d, 0xaa, 0xd4, 0x2b, 0x28,
	0xca, 0x2f, 0xc9, 0x17, 0xd2, 0x41, 0x57, 0xa8, 0x87, 0x21, 0x80, 0xd0, 0x29, 0x25, 0x93, 0x9e,
	0x9f, 0x9f, 0x9e, 0x93, 0xaa, 0x9f, 0x58, 0x90, 0xa9, 0x9f, 0x98, 0x97, 0x97, 0x5f, 0x92, 0x58,
	0x92, 0x99, 0x9f, 0x57, 0x0c, 0x31, 0x4b, 0x49, 0x86, 0x4b, 0x2a, 0x10, 0x64, 0xb4, 0x3b, 0x5c,
	0x83, 0x63, 0x4a, 0x4a, 0x51, 0x50, 0x6a, 0x61, 0x69, 0x6a, 0x71, 0x89, 0x92, 0x37, 0x97, 0x34,
	0x56, 0xd9, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0x21, 0x1d, 0x2e, 0xc1, 0x74, 0x14, 0x99, 0xd4,
	0xe2, 0x62, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xce, 0x20, 0x4c, 0x09, 0xa3, 0xe7, 0x8c, 0x5c, 0xac,
	0x60, 0xd3, 0x84, 0xee, 0x32, 0x72, 0xf1, 0xa1, 0x1a, 0x29, 0xe4, 0xa1, 0x47, 0x8a, 0xa7, 0xf4,
	0x70, 0xbb, 0x59, 0xca, 0x93, 0x0a, 0x26, 0x41, 0xfc, 0xa7, 0x64, 0xd6, 0x74, 0xf9, 0xc9, 0x64,
	0x26, 0x03, 0x21, 0x3d, 0x7d, 0x7c, 0x51, 0x83, 0xe1, 0x53, 0xa7, 0xc8, 0x13, 0x8f, 0xe4, 0x18,
	0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5,
	0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0xb2, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0x02, 0xb9, 0x08,
	0xd3, 0x4c, 0x0c, 0x81, 0x0a, 0x64, 0x6b, 0x4a, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0xd1,
	0x66, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x05, 0xbc, 0xa2, 0x8d, 0x2d, 0x02, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// Queries the government address.
	GovernmentAddr(ctx context.Context, in *QueryGovernmentAddrRequest, opts ...grpc.CallOption) (*QueryGovernmentAddrResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) GovernmentAddr(ctx context.Context, in *QueryGovernmentAddrRequest, opts ...grpc.CallOption) (*QueryGovernmentAddrResponse, error) {
	out := new(QueryGovernmentAddrResponse)
	err := c.cc.Invoke(ctx, "/commercionetwork.commercionetwork.government.Query/GovernmentAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Queries the government address.
	GovernmentAddr(context.Context, *QueryGovernmentAddrRequest) (*QueryGovernmentAddrResponse, error)
}

// UnimplementedQueryServer can be embedded to have forward compatible implementations.
type UnimplementedQueryServer struct {
}

func (*UnimplementedQueryServer) GovernmentAddr(ctx context.Context, req *QueryGovernmentAddrRequest) (*QueryGovernmentAddrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GovernmentAddr not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_GovernmentAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGovernmentAddrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).GovernmentAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/commercionetwork.commercionetwork.government.Query/GovernmentAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).GovernmentAddr(ctx, req.(*QueryGovernmentAddrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "commercionetwork.commercionetwork.government.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GovernmentAddr",
			Handler:    _Query_GovernmentAddr_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "commercionetwork/government/query.proto",
}

func (m *QueryGovernmentAddrRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryGovernmentAddrRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryGovernmentAddrRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *QueryGovernmentAddrResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryGovernmentAddrResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryGovernmentAddrResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.GovernmentAddress) > 0 {
		i -= len(m.GovernmentAddress)
		copy(dAtA[i:], m.GovernmentAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.GovernmentAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryGovernmentAddrRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryGovernmentAddrResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GovernmentAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryGovernmentAddrRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryGovernmentAddrRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGovernmentAddrRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryGovernmentAddrResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryGovernmentAddrResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGovernmentAddrResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GovernmentAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GovernmentAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipQuery(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthQuery
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupQuery
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthQuery
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)

repository: commercionetwork/commercionetwork

repo_name: commercionetwork/commercionetwork


text:
package http

import (
	"encoding/json"
	"net/http"
)

// setHeader is a helper function for writing response header' content type and code.
func setHeader(w http.ResponseWriter, code int) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(code)
}

// respondJSON sends the given data as JSON. The response status code is set to the given code.
func respondJSON(w http.ResponseWriter, code int, data interface{}) {
	setHeader(w, code)

	resp, err := json.Marshal(data)
	if err != nil {
		respondHTTPError(w, errInternal)
		return
	}
	w.Write(resp)
}

// respondHTTPError formats the given error and sends it as JSON.
// Parameter `httpErr` sets the status code.
func respondHTTPError(w http.ResponseWriter, httpErr httpError) {
	resp := map[string]httpError{
		"error": httpErr,
	}
	respondJSON(w, httpErr.Code, resp)
}

repository: GregoryAlbouy/golastic

repo_name: GregoryAlbouy/golastic


text:
# Copyright (c) 2018-2020 LG Electronics, Inc.

require webos-open-test-apps.inc

LIC_FILES_CHKSUM += " \
file://oss-pkg-info.yaml;md5=2bdfe040dcf81b4038370ae96036c519 \
"

PR = "${INC_PR}.2"

SRCREV = "9ebc4e9f1f3fa337f90047e5d94ffe29aa347298"

SUMMARY = "Enact test application"
AUTHOR = "Anish TD <anish.td@lge.com>"

repository: webOS-ports/meta-webos-ports

repo_name: webOS-ports/meta-webos-ports

branch_name: refs/heads/kirkstone

gha_language: BitBake

extension: bb


text:
@article{Kehoe-2019-Successful,
    title = "Successful forecasting of harmful cyanobacteria blooms with high frequency lake data",
    author = "Kehoe, M.J.  and
      Ingalls, B.P.  and
      Venkiteswaran, J.J.  and
      Baulch, H.M.",
    journal = "",
    year = "2019",
    publisher = "Copernicus GmbH",
    url = "https://aclanthology.org/G19-9003",
    doi = "10.1101/674325",
    abstract = "Abstract Cyanobacterial blooms are causing increasing issues across the globe. Bloom forecasting can facilitate adaptation to blooms. Most bloom forecasting models depend on weekly or fortnightly sampling, but these sparse measurements can miss important dynamics. Here we develop forecasting models from five years of high frequency summer monitoring in a shallow lake (which serves as an important regional water supply). A suite of models were calibrated to predict cyanobacterial fluorescence (a biomass proxy) using measurements of: cyanobacterial fluorescence, water temperature, light, and wind speed. High temporal autocorrelation contributed to relatively strong predictive power over 1, 4 and 7 day intervals. Higher order derivatives of water temperature helped improve forecasting accuracy. While traditional monitoring and modelling have supported forecasting on longer timescales, we show high frequency monitoring combined with telemetry allows forecasting over timescales of 1 day to 1 week, supporting early warning, enhanced monitoring, and adaptation of water treatment processes.",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

gha_language: Python


text:
set(Monocle_Math_SOURCES
	./Angles/Angles.cpp
./Angles/Angles.h
./GLM/Angles_glm.h
./GLM/Matrix_glm.h
./GLM/Vector_glm.h
./Math.h
./Matrix.h
./Vec2.h
./Vec3.h
./Vec4.h
	)

if(WIN32)
	set(Monocle_Math_SOURCES

	${Monocle_Math_SOURCES}

	)

elseif(APPLE)
	set(Monocle_Math_SOURCES

	${Monocle_Math_SOURCES}

	)

elseif(UNIX)
	set(Monocle_Math_SOURCES

	${Monocle_Math_SOURCES}

	)

endif()

extension: cmake


text:
package config

import (
	"log"
	"os"
	"os/user"
	"path/filepath"

	"github.com/op/go-logging"
	"github.com/spf13/viper"
)

type Config struct {
	DBPath            string
	ReloadOntologies  bool
	DisableQueryCache bool

	// datasets to load
	Buildings map[string]string

	// ontologies to load
	Ontologies []string

	EnableHTTP     bool
	EnableBOSSWAVE bool

	ShowNamespaces         bool
	ShowDependencyGraph    bool
	ShowQueryPlan          bool
	ShowQueryPlanLatencies bool
	ShowOperationLatencies bool
	ShowQueryLatencies     bool
	LogLevel               logging.Level

	ServerPort    string
	UseIPv6       bool
	ListenAddress string
	StaticPath    string
	TLSHost       string

	BW2_AGENT          string
	BW2_DEFAULT_ENTITY string
	HodURI             string

	EnableCPUProfile   bool
	EnableMEMProfile   bool
	EnableBlockProfile bool
}

func (cfg *Config) Copy() *Config {
	return &Config{
		DBPath:                 cfg.DBPath,
		ReloadOntologies:       cfg.ReloadOntologies,
		DisableQueryCache:      cfg.DisableQueryCache,
		Buildings:              cfg.Buildings,
		Ontologies:             cfg.Ontologies,
		ShowNamespaces:         cfg.ShowNamespaces,
		ShowDependencyGraph:    cfg.ShowDependencyGraph,
		ShowQueryPlan:          cfg.ShowQueryPlan,
		ShowQueryPlanLatencies: cfg.ShowQueryPlanLatencies,
		ShowOperationLatencies: cfg.ShowOperationLatencies,
		ShowQueryLatencies:     cfg.ShowQueryLatencies,
		LogLevel:               cfg.LogLevel,
	}
}

func init() {
	prefix := os.Getenv("GOPATH")
	// switch prefix to default GOPATH /home/{user}/go
	if prefix == "" {
		u, err := user.Current()
		if err != nil {
			log.Fatal(err)
		}
		prefix = filepath.Join(u.HomeDir, "go")
	}
	// set defaults for config
	viper.SetDefault("DBPath", "_hoddb")
	viper.SetDefault("ReloadOntologies", true)
	viper.SetDefault("DisableQueryCache", true)
	viper.SetDefault("Buildings", make(map[string]string))
	viper.SetDefault("Ontologies", []string{
		prefix + "/src/github.com/gtfierro/hod/BrickFrame.ttl",
		prefix + "/src/github.com/gtfierro/hod/Brick.ttl",
		prefix + "/src/github.com/gtfierro/hod/BrickUse.ttl",
		prefix + "/src/github.com/gtfierro/hod/BrickTag.ttl",
	})

	viper.SetDefault("EnableHTTP", true)
	viper.SetDefault("EnableBOSSWAVE", false)

	viper.SetDefault("ShowNamespaces", true)
	viper.SetDefault("ShowDependencyGraph", false)
	viper.SetDefault("ShowQueryPlan", false)
	viper.SetDefault("ShowQueryPlanLatencies", false)
	viper.SetDefault("ShowOperationLatencies", false)
	viper.SetDefault("ShowQueryLatencies", true)
	viper.SetDefault("LogLevel", "notice")

	viper.SetDefault("ServerPort", "47808")
	viper.SetDefault("UseIPv6", false)
	viper.SetDefault("ListenAddress", "127.0.0.1")
	viper.SetDefault("StaticPath", prefix+"/src/github.com/gtfierro/hod/server")
	viper.SetDefault("TLSHost", "") // disabled

	viper.SetDefault("HodURI", "scratch.ns/hod")

	viper.SetDefault("EnableCPUProfile", false)
	viper.SetDefault("EnableMEMProfile", false)
	viper.SetDefault("EnableBlockProfile", false)

	viper.SetConfigName("hodconfig")
	// set search paths for config
	viper.AddConfigPath(".")
	viper.AddConfigPath("/etc/hod/")
	viper.AddConfigPath(prefix + "/src/github.com/gtfierro/hod")
}

func ReadConfig(file string) (*Config, error) {
	if len(file) > 0 {
		viper.SetConfigFile(file)
	}
	if err := viper.ReadInConfig(); err != nil {
		return nil, err
	}
	viper.AutomaticEnv()

	level, err := logging.LogLevel(viper.GetString("LogLevel"))
	if err != nil {
		level = logging.DEBUG
	}

	c := &Config{
		DBPath:                 viper.GetString("DBPath"),
		ReloadOntologies:       viper.GetBool("ReloadOntologies"),
		EnableHTTP:             viper.GetBool("EnableHTTP"),
		EnableBOSSWAVE:         viper.GetBool("EnableBOSSWAVE"),
		DisableQueryCache:      viper.GetBool("DisableQueryCache"),
		Buildings:              viper.GetStringMapString("Buildings"),
		Ontologies:             viper.GetStringSlice("Ontologies"),
		ShowNamespaces:         viper.GetBool("ShowNamespaces"),
		ShowDependencyGraph:    viper.GetBool("ShowDependencyGraph"),
		ShowQueryPlan:          viper.GetBool("ShowQueryPlan"),
		ShowQueryPlanLatencies: viper.GetBool("ShowQueryPlanLatencies"),
		ShowOperationLatencies: viper.GetBool("ShowOperationLatencies"),
		ShowQueryLatencies:     viper.GetBool("ShowQueryLatencies"),
		LogLevel:               level,
		ServerPort:             viper.GetString("ServerPort"),
		UseIPv6:                viper.GetBool("UseIPv6"),
		ListenAddress:          viper.GetString("ListenAddress"),
		StaticPath:             viper.GetString("StaticPath"),
		TLSHost:                viper.GetString("TLSHost"),
		BW2_AGENT:              viper.GetString("BW2_AGENT"),
		BW2_DEFAULT_ENTITY:     viper.GetString("BW2_DEFAULT_ENTITY"),
		HodURI:                 viper.GetString("HodURI"),
		EnableCPUProfile:       viper.GetBool("EnableCPUProfile"),
		EnableMEMProfile:       viper.GetBool("EnableMEMProfile"),
		EnableBlockProfile:     viper.GetBool("EnableBlockProfile"),
	}
	return c, nil
}


text:
@Article{haynes2020has,
  title = {How Has the COVID-19 Pandemic Changed How You Will Approach Research and Lab Work in the Future?},
  author = {Karmella Haynes and Christopher Yau and Andrea Bild and Ashley Laughney and Leonardo Morsut and Xia Yang and Judith Zaugg and Patrick Hsu and Vera Pancaldi and Srividya Iyer-Biswas},
  journal = {Cell Systems},
  volume = {11},
  number = {6},
  pages = {550--554},
  year = {2020},
  publisher = {Elsevier},
  date = {2020-01-01},
}


text:
DESCRIPTION = "mostfun pro 3D printer test models"
SECTION = "userland"

FILESEXTRAPATHS_prepend := "${THISDIR}/files/:"

SRC_URI = "file://birdcage.stl \
           file://birdcage.gcode"

LICENSE = "CLOSED"

PV = "0.0"
PR = "r0"

S = "${WORKDIR}"

FILESDIR = "${FILE_DIRNAME}/files/"

FILES_${PN}  += "/home/birdcage.stl \
           /home/birdcage.gcode"

inherit allarch update-alternatives

do_install() {
        install -v -d  ${D}/home/gcode
        install -v -d  ${D}/home/model
        install -m 0755 birdcage.gcode ${D}/home/gcode
        install -m 0755 birdcage.stl ${D}/home/model
}


text:
# Copyright (C) 2009 Khem Raj <raj.khem@gmail.org>
# Released under the MIT license (see COPYING.MIT for the terms)

DESCRIPTION = "mini_httpd is a small HTTP server. \
	       It implements all the basic features of an HTTP server \
	       It can also be configured to do SSL/HTTPS and IPv6. \
	       "
HOMEPAGE = "http://www.acme.com/software/mini_httpd/"
LICENSE = "BSD"
SECTION = "net"
DEPENDS = "openssl"
PR = "r0"

SRC_URI="http://www.acme.com/software/mini_httpd/mini_httpd-${PV}.tar.gz \
	 file://new-bindir-mandir.patch \
	 file://remove-CC.patch \
	 file://mini-httpd.conf \
	 file://init \
	"

INITSCRIPT_NAME = "mini_httpd"
INITSCRIPT_PARAMS = "defaults"

S = "${WORKDIR}/mini_httpd-${PV}"

inherit autotools update-rc.d

do_install () {
	install -d ${D}${sysconfdir}
	install -d ${D}${sysconfdir}/init.d
	install -d ${D}${sysconfdir}/mini-httpd
	install -m 0755 ${WORKDIR}/init ${D}${sysconfdir}/init.d/mini_httpd
	install -m 0755 ${WORKDIR}/mini-httpd.conf ${D}${sysconfdir}/mini-httpd.conf
	oe_runmake 'BINDIR=${D}${sbindir}' 'MANDIR=${D}${mandir}' install
}

SRC_URI[md5sum] = "7c68293ad265ecfe2edea917912f6f1f"
SRC_URI[sha256sum] = "f7f36533b1338ea16d916ea525ea7006ab38fdd3544ac7df93a4688a8e270241"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@article{jnca-Barcellos2012,
 abstract = {Simulation has been of paramount importance to the development of novel Internet protocols. Such an approach typically focuses on one of three domains: wireless and other link-layer technologies, routing protocols, and transport-layer mechanisms and},
 author = {Barcellos, Marinho Pilla and Antunes, Rodolfo Stoffel and Muhammad, Hisham H and Munaretti, Ruthiano S},
 file = {:Users/mbarcell/Google Drive (mbarcell@waikato.ac.nz)/Work/Research/MendeleyPaperBase/Barcellos et al/JNCA_2012_Barcellos et al.pdf:pdf},
 journal = {JNCA},
 month = {jan},
 number = {1},
 publisher = {Academic Press Ltd},
 title = {Beyond network simulators: Fostering novel distributed applications and protocols through extendible design},
 url = {http://dl.acm.org/citation.cfm?id=2076808.2077055&coll=DL&dl=GUIDE&CFID=675591961&CFTOKEN=99072741 papers3://publication/uuid/7294F319-4F38-4D24-9F11-5E4D1F0D3694},
 volume = {35},
 year = {2012}
}

repository: marinho-barcellos/academic-kickstart

repo_name: marinho-barcellos/academic-kickstart


text:
DESCRIPTION = "Python Gstreamer bindings"
SECTION = "devel/python"
LICENSE = "LGPL"
DEPENDS = "gstreamer gst-plugins-base python-pygobject"
PR = "ml4"

SRC_URI = "\
  http://gstreamer.freedesktop.org/src/gst-python/gst-python-${PV}.tar.bz2 \
  file://python-path.patch \
  file://import-gobject-instead-of-pygtk.patch \
"
S = "${WORKDIR}/gst-python-${PV}"

inherit autotools pkgconfig  distutils-base

require fix-path.inc

EXTRA_OECONF += "--with-python-includes=${STAGING_INCDIR}/../"

do_configure_prepend() {
    install -d ${S}/m4
    install -m 0644 ${S}/common/m4/*.m4 ${S}/m4/
}

PACKAGES =+ "${PN}-examples"

FILES_${PN} += "${datadir}/gst-python"
FILES_${PN}-dev += "\
  ${datadir}/gst-python/0.10/defs \
  ${libdir}/${PYTHON_DIR}/site-packages/gst-0.10/gst/*.la \
"
FILES_${PN}-dbg += "${libdir}/${PYTHON_DIR}/site-packages/gst-0.10/gst/.debug/"
FILES_${PN}-examples = "${datadir}/gst-python/0.10/examples"

SRC_URI[md5sum] = "6183d61e434b5d34f232248a35571627"
SRC_URI[sha256sum] = "c875753a6cccd40a79f5824ea5ec51ee4615a4f22103e4adfc6a0221bf615d8e"


text:
require bug-app.inc

DESCRIPTION = "This application is the combination of various geriatric assistance ideas(two to be exact). The first function of the application is a more modern 'I've fallen and I can't get up' device which actually attempts to detect when a fall has occurred using the Motion/Accelerometer module. If a fall is detected, a log is posted to a tumblr account (http://www.tumblr.com) complete with an image (generated using the Yahoo! Maps API) which pin-points the location of the fall based on the GPS coordinates retrieved from the GPS module.  The second function of the application is used to help people with memory issues (Alzheimers patients, etc.) by recording images throughout the day and allowing them to review those images in rapid succession before they go to bed, which has been proven to help increase their recollection of events.   \
The GeriatricAssistant employs the following BUG modules:\
Camera (used to take images every 30 seconds to be played back in the evening before the user goes to bed)\
Motion/Accelerometer (used to determine when a free fall has occurred)\
GPS (used to pin-point the exact location of a fall)\
LCD (used to allow interaction with the user, including the playback of recorded images)\
"
HOMEPAGE = "http://buglabs.net/applications/GeriatricAssistant"

DEPENDS += "service-tracker com.buglabs.bug.module.motion com.buglabs.bug.module.lcd com.buglabs.bug.module.camera com.buglabs.common com.buglabs.bug.module.gps com.buglabs.bug.base com.buglabs.osgi "

PV = "2"

SRC_LINK = "http://buglabs.net/program_version/download/152"

APIVERSION = ""

BROKEN = "1"


text:
DESCRIPTION = "Java SDK for connecting to AWS IoT from a device."
HOMEPAGE = "https://github.com/aws/aws-iot-device-sdk-java"
AUTHOR = "Amazon Web Services"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=08528ae069cf72dbf7ee85efa7405c37"

FILESEXTRAPATHS_prepend := "${THISDIR}/files:"

DEPENDS = "maven-native icedtea7-native"

SRC_URI = "git://github.com/aws/${PN}.git \
	   file://0001-build-with-deps.patch \
"
SRCREV = "5d9830bb21d167eea995dcad38e77ad6835adc7e"

PR = "r0"

S = "${WORKDIR}/git"
B = "${S}/${PN}/target"

JAVA_DATADIR ?= "${datadir}/java"

SAMPLES_BUILD_DIR = "${S}/${PN}-samples/target"

do_compile() {
	cd ${S}
	export JAVA_HOME="${STAGING_LIBDIR_NATIVE}/jvm/icedtea7-native"
	export M3_HOME="${STAGING_DIR_NATIVE}/usr/bin/maven-native"

	mvn install -Dgpg.skip=true
}

do_install() {
	install -d ${D}${JAVA_DATADIR}
	install -m 0644 ${B}/${PN}-${PV}-with-deps.jar ${D}${JAVA_DATADIR}/${PN}-${PV}.jar
	ln -s ${PN}-${PV}.jar ${D}${JAVA_DATADIR}/${PN}.jar

	# Samples
	install -d ${D}${datadir}/awsiotsdk/samples/java
    	install -m 0755 ${SAMPLES_BUILD_DIR}/${PN}-samples-${PV}-with-deps.jar ${D}${datadir}/awsiotsdk/samples/java/${PN}-samples-${PV}.jar
}

PACKAGES = "${PN} ${PN}-samples"

FILES_${PN} += "${JAVA_DATADIR}"
FILES_${PN}-samples += "${datadir}/awsiotsdk/samples/java"

repository: MentorEmbedded/meta-iot-cloud

repo_name: MentorEmbedded/meta-iot-cloud


text:
%% This BibTeX bibliography file was created using BibDesk.
%% http://bibdesk.sourceforge.net/

%% Created for Sherine Awad at 2015-02-10 16:48:40 -0500

%% Saved with string encoding Unicode (UTF-8)

@article{streaming,
	Author = {Zhang Qingpeng and Awad Sherine and  Brown Titus},
	Journal = { PeerJ PrePrints 3:e1100 https://dx.doi.org/10.7287/peerj.preprints.890v1},
	Title = {Crossing the streams: a framework for streaming analysis of short DNA sequencing reads.},
	Year = {2015}}
,
@article{velvet,
	Author = {Daniel R. Zerbino and Ewan Birney},
	Journal = {Genome Research},
	Pages = {821-829},
	Title = {Velvet: algorithms for de novo short read assembly using de Bruijn graphs},
	Volume = {18},
	Year = {2008}}
,
@article{idba,
	Author = {Yu Peng and Henry C.M. Leung and S.M. Yiu and Francis Y.L. Chin},
	Journal = {Bioinformatics},
	Pages = {1420-1428},
	Title = {IDBA-UD: a de novo assembler for single-cell and metagenomic sequencing data with highly uneven depth},
	Volume = {28},
	Year = {2012}}
,
@article{spades,
	Author = {Anton Bankevich and Sergey Nurk and Dmitry Antipov and Alexey A. Gurevich and Mikhail Dvorkin and Alexander S. Kulikov and Valery M. Lesin and Sergey I. Nikolenko and Son Pham and Andrey D. Prjibelski and Alexey V. Pyshkin and Alexander V. Sirotkin and Nikolay Vyahhi and Glenn Tesler and Max A. Alekseyev and Pavel A. Pevzner},
	Journal = {Journal of Computational Biology},
	Number = {5},
	Pages = {455-477},
	Title = {SPAdes: A New Genome Assembly Algorithm and Its Applications to Single-Cell Sequencing},
	Volume = {19},
	Year = {2012}}

@article{trimmomatic,
	Author = {Anthony M. Bolger and Marc Lohse and Bjoern Usadel},
	Journal = {Bioinformatics},
	Number = {15},
	Pages = {2114-2120},
	Title = {Trimmomatic: A flexible trimmer for Illumina Sequence Data},
	Volume = {30},
	Year = {2014}}
,
@article{samtools,
	Author ={Li Heng and Bob Handsaker and Alec Wysoker and Tim Fennell and Jue Ruan and Nils Homer and Gabor Marth and Goncalo Abecasis and Richard Durbin},
	Journal = {Bioinformatics},
	Pages={2078-2079},
	Number = {16},
	Title = {The Sequence Alignment/Map format and SAMtools},
	Volume = {25},
	Year = {2009}}
,
@article{megahit,
  title={MEGAHIT v1. 0: A fast and scalable metagenome assembler driven by advanced methodologies and community practices},
  author={Li, Dinghua and Luo, Ruibang and Liu, Chi-Man and Leung, Chi-Ming and Ting, Hing-Fung and Sadakane, Kunihiko and Yamashita, Hiroshi and Lam, Tak-Wah},
  journal={Methods},
  volume={102},
  pages={3--11},
  year={2016},
  publisher={Elsevier}
}
,

@article{podar,
        Author = {Shakya Migun and Christopher Quince and James Campbell and Zamin Yang and Christopher Schadt and Mircea Podar},
        Journal = {Enivromental Microbiology},
        Number = {6},
        Title = {Comparative metagenomic and rRNA microbial diversity characterization using archaeal and bacterial synthetic communities},
        Volume = {15},
         Pages={1882-1899},
        Year = {2013}}
,

@article{bwa-mem,
  title={Aligning sequence reads, clone sequences and assembly contigs with BWA-MEM},
  author={Li, Heng},
  journal={arXiv preprint arXiv:1303.3997},
  year={2013}
},

@article{bwa,
  title={Fast and accurate short read alignment with Burrows--Wheeler transform},
  author={Li, Heng and Durbin, Richard},
  journal={Bioinformatics},
  volume={25},
  number={14},
  pages={1754--1760},
  year={2009},
  publisher={Oxford Univ Press}
},

@article{bowtie2,
  title={Fast gapped-read alignment with Bowtie 2},
  author={Langmead, Ben and Salzberg, Steven L},
  journal={Nature methods},
  volume={9},
  number={4},
  pages={357--359},
  year={2012},
  publisher={Nature Publishing Group}
},

@article{jpell2012,
  title={Scaling metagenome sequence assembly with probabilistic de Bruijn graphs},
  author={Pell, Jason and Hintze, Arend and Canino-Koning, Rosangela and Howe, Adina and Tiedje, James M and Brown, C Titus},
  journal={Proceedings of the National Academy of Sciences},
  volume={109},
  number={33},
  pages={13272--13277},
  year={2012},
  publisher={National Acad Sciences}
},

@online{FXtoolkit,
  author =  {Hannon Lab},
  title = {FASTX Toolkit},
  year = {},
  url ={hannonlab.cshl.edu/fastx\_toolkit/index.html} ,
  urldate ={}
},

@article{ahowe2014,
  title={Tackling soil diversity with the assembly of large, complex metagenomes},
  author={Howe, Adina Chuang and Jansson, Janet K and Malfatti, Stephanie A and Tringe, Susannah G and Tiedje, James M and Brown, C Titus},
  journal={Proceedings of the National Academy of Sciences},
  volume={111},
  number={13},
  pages={4904--4909},
  year={2014},
  publisher={National Acad Sciences}
},

@article{brown2012,
  title={A reference-free algorithm for computational normalization of shotgun sequencing data},
  author={Brown, C Titus and Howe, Adina and Zhang, Qingpeng and Pyrkosz, Alexis B and Brom, Timothy H},
  journal={arXiv preprint arXiv:1203.4802},
  year={2012}
},

@article{qingpeng2014,
  title={These Are Not the K-mers You Are Looking For: Efficient Online K-mer Counting Using a Probabilistic Data Structure},
  author={Zhang, Qingpeng and Pell, Jason and Canino-Koning, Rosangela and Howe, Adina Chuang and Brown, C Titus},
  journal={PLoS One},
  volume={9},
  number={7},
  year={2014},
  publisher={Public Library of Science}
}
,
@article{sam-stools,
  title={The sequence alignment/map format and SAMtools},
  author={Li, Heng and Handsaker, Bob and Wysoker, Alec and Fennell, Tim and Ruan, Jue and Homer, Nils and Marth, Gabor and Abecasis, Goncalo and Durbin, Richard and others},
  journal={Bioinformatics},
  volume={25},
  number={16},
  pages={2078--2079},
  year={2009},
  publisher={Oxford Univ Press}
}
,
@article{metaclass,
  title={An evaluation of the accuracy and speed of metagenome analysis tools},
  author={Lindgreen, Stinus and Adair, Karen L and Gardner, Paul P},
  journal={Scientific reports},
  volume={6},
  year={2016},
  publisher={Nature Publishing Group}
},
@article{huzefa2011,
  title={Evaluation of short read metagenomic assembly},
  author={Charuvaka, Anveshi and Rangwala, Huzefa},
  journal={BMC genomics},
  volume={12},
  number={2},
  pages={1},
  year={2011},
  publisher={BioMed Central}
},
@article{abyss,
  title={ABySS: a parallel assembler for short read sequence data},
  author={Simpson, Jared T and Wong, Kim and Jackman, Shaun D and Schein, Jacqueline E and Jones, Steven JM and Birol, Inan{\c{c}}},
  journal={Genome research},
  volume={19},
  number={6},
  pages={1117--1123},
  year={2009},
  publisher={Cold Spring Harbor Lab}
},
@article{mavromatis2007,
  title={Use of simulated data sets to evaluate the fidelity of metagenomic processing methods},
  author={Mavromatis, Konstantinos and Ivanova, Natalia and Barry, Kerrie and Shapiro, Harris and Goltsman, Eugene and McHardy, Alice C and Rigoutsos, Isidore and Salamov, Asaf and Korzeniewski, Frank and Land, Miriam and others},
  journal={Nature methods},
  volume={4},
  number={6},
  pages={495--500},
  year={2007},
  publisher={Nature Publishing Group}
},
@article{arachne,
  title={Whole-genome sequence assembly for mammalian genomes: Arachne 2},
  author={Jaffe, David B and Butler, Jonathan and Gnerre, Sante and Mauceli, Evan and Lindblad-Toh, Kerstin and Mesirov, Jill P and Zody, Michael C and Lander, Eric S},
  journal={Genome research},
  volume={13},
  number={1},
  pages={91--96},
  year={2003},
  publisher={Cold Spring Harbor Lab}
},
@article{jazz,
  title={Whole-genome shotgun assembly and analysis of the genome of Fugu rubripes},
  author={Aparicio, Samuel and Chapman, Jarrod and Stupka, Elia and Putnam, Nik and Chia, Jer-ming and Dehal, Paramvir and Christoffels, Alan and Rash, Sam and Hoon, Shawn and Smit, Arian and others},
  journal={Science},
  volume={297},
  number={5585},
  pages={1301--1310},
  year={2002},
  publisher={American Association for the Advancement of Science}
},
 @article{moya2014,
  title={Comparison of different assembly and annotation tools on analysis of simulated viral metagenomic communities in the gut},
  author={V{\'a}zquez-Castellanos, Jorge F and Garc{\'\i}a-L{\'o}pez, Rodrigo and P{\'e}rez-Brocal, Vicente and Pignatelli, Miguel and Moya, Andr{\'e}s},
  journal={BMC genomics},
  volume={15},
  number={1},
  pages={1},
  year={2014},
  publisher={BioMed Central}
},
@article{mummer3.0,
  title={Versatile and open software for comparing large genomes},
  author={Kurtz, Stefan and Phillippy, Adam and Delcher, Arthur L and Smoot, Michael and Shumway, Martin and Antonescu, Corina and Salzberg, Steven L},
  journal={Genome biology},
  volume={5},
  number={2},
  pages={1},
  year={2004},
  publisher={BioMed Central}
},
@article{samstat,
  title={SAMStat: monitoring biases in next generation sequencing data},
  author={Lassmann, Timo and Hayashizaki, Yoshihide and Daub, Carsten O},
  journal={Bioinformatics},
  volume={27},
  number={1},
  pages={130--131},
  year={2011},
  publisher={Oxford Univ Press}
},
@article{prokka,
  title={Prokka: rapid prokaryotic genome annotation},
  author={Seemann, Torsten},
  journal={Bioinformatics},
  pages={btu153},
  year={2014},
  publisher={Oxford Univ Press}
}

@Article{chitsaz2011,
   author = "H Chitsaz and JL Yee-Greenbaum and G Tesler and MJ Lombardo and CL Dupont and JH Badger and M Novotny and DB Rusch and LJ Fraser and NA Gormley and O Schulz-Trieglaff and GP Smith and DJ Evers and PA Pevzner and RS Lasken",
   title = "Efficient de novo assembly of single-cell bacterial genomes from short-read data sets.",
   journal = "Nat Biotechnol",
   year = "2011",
   volume = "29",
   number = "10",
   pages = "915-21"
}

@article{macmanes2014optimal,
  title={On the optimal trimming of high-throughput mRNA sequence data},
  author={MacManes, Matthew D},
  journal={Frontiers in genetics},
  volume={5},
  pages={13},
  year={2014},
  publisher={Frontiers}
}

@article{sourmash,
  doi = {10.21105/joss.00027},
  url = {https://doi.org/10.21105/joss.00027},
  year  = {2016},
  month = {sep},
  publisher = {The Open Journal},
  volume = {1},
  number = {5},
  author = {C. Titus Brown and Luiz Irber},
  title = {sourmash: a library for {MinHash} sketching of {DNA}},
  journal = {The Journal of Open Source Software}
}

@article {metapalette,
	author = {Koslicki, David and Falush, Daniel},
	editor = {Jansson, Janet K.},
	title = {MetaPalette: a k-mer Painting Approach for Metagenomic Taxonomic Profiling and Quantification of Novel Strain Variation},
	volume = {1},
	number = {3},
	year = {2016},
	doi = {10.1128/mSystems.00020-16},
	publisher = {American Society for Microbiology Journals},
	abstract = {Metagenomic profiling is challenging in part because of the highly uneven sampling of the tree of life by genome sequencing projects and the limitations imposed by performing phylogenetic inference at fixed taxonomic ranks. We present the algorithm MetaPalette, which uses long k-mer sizes (k~=~30,~50) to fit a k-mer {\textquotedblleft}palette{\textquotedblright} of a given sample to the k-mer palette of reference organisms. By modeling the k-mer palettes of unknown organisms, the method also gives an indication of the presence, abundance, and evolutionary relatedness of novel organisms present in the sample. The method returns a traditional, fixed-rank taxonomic profile which is shown on independently simulated data to be one of the most accurate to date. Tree figures are also returned that quantify the relatedness of novel organisms to reference sequences, and the accuracy of such figures is demonstrated on simulated spike-ins and a metagenomic soil sample. The software implementing MetaPalette is available at: https://github.com/dkoslicki/MetaPalette. Pretrained databases are included for Archaea, Bacteria, Eukaryota, and viruses.IMPORTANCE Taxonomic profiling is a challenging first step when analyzing a metagenomic sample. This work presents a method that facilitates fine-scale characterization of the presence, abundance, and evolutionary relatedness of organisms present in a given sample but absent from the training database. We calculate a {\textquotedblleft}k-mer palette{\textquotedblright} which summarizes the information from all reads, not just those in conserved genes or containing taxon-specific markers. The compositions of palettes are easy to model, allowing rapid inference of community composition. In addition to providing strain-level information where applicable, our approach provides taxonomic profiles that are more accurate than those of competing methods.Author Video: An author video summary of this article is available.},
	URL = {http://msystems.asm.org/content/1/3/e00020-16},
	eprint = {http://msystems.asm.org/content/1/3/e00020-16.full.pdf},
	journal = {mSystems}
}

@article{metaspades,
  doi = {10.1101/gr.213959.116},
  url = {https://doi.org/10.1101/gr.213959.116},
  year  = {2017},
  month = {mar},
  publisher = {Cold Spring Harbor Laboratory Press},
  volume = {27},
  number = {5},
  pages = {824--834},
  author = {Sergey Nurk and Dmitry Meleshko and Anton Korobeynikov and Pavel A. Pevzner},
  title = {{metaSPAdes}: a new versatile metagenomic assembler},
  journal = {Genome Research}
}

@Article{khmer2,
AUTHOR = { Crusoe, MR and Alameldin, HF and Awad, S and Boucher, E and Caldwell, A and Cartwright, R and Charbonneau, A and Constantinides, B and Edvenson, G and Fay, S and Fenton, J and Fenzl, T and Fish, J and Garcia-Gutierrez, L and Garland, P and Gluck, J and González, I and Guermond, S and Guo, J and Gupta, A and Herr, JR and Howe, A and Hyer, A and Härpfer, A and Irber, L and Kidd, R and Lin, D and Lippi, J and Mansour, T and McA'Nulty, P and McDonald, E and Mizzi, J and Murray, KD and Nahum, JR and Nanlohy, K and Nederbragt, AJ and Ortiz-Zuazaga, H and Ory, J and Pell, J and Pepe-Ranney, C and Russ, ZN and Schwarz, E and Scott, C and Seaman, J and Sievert, S and Simpson, J and Skennerton, CT and Spencer, J and Srinivasan, R and Standage, D and Stapleton, JA and Steinman, SR and Stein, J and Taylor, B and Trimble, W and Wiencko, HL and Wright, M and Wyss, B and Zhang, Q and zyme, e and Brown, CT},
TITLE = {The khmer software package: enabling efficient nucleotide sequence analysis [version 1; referees: 2 approved, 1 approved with reservations]
},
JOURNAL = {F1000Research},
VOLUME = {4},
YEAR = {2015},
NUMBER = {900},
DOI = {10.12688/f1000research.6924.1}
}

@article {CAMI,
	author = {Sczyrba, Alexander and Hofmann, Peter and Belmann, Peter and Koslicki, David and Janssen, Stefan and Droege, Johannes and Gregor, Ivan and Majda, Stephan and Fiedler, Jessika and Dahms, Eik and Bremges, Andreas and Fritz, Adrian and Garrido-Oter, Ruben and Sparholt Jorgensen, Tue and Shapiro, Nicole and Blood, Philip D and Gurevich, Alexey and Bai, Yang and Turaev, Dmitrij and DeMaere, Matthew Z and Chikhi, Rayan and Nagarajan, Niranjan and Quince, Christopher and Hestbjerg Hansen, Lars and Sorensen, Soren J and Chia, Burton K H and Denis, Bertrand and Froula, Jeff L and Wang, Zhong and Egan, Robert and Kang, Dongwan Don and Cook, Jeffrey J and Deltel, Charles and Beckstette, Michael and Lemaitre, Claire and Peterlongo, Pierre and Rizk, Guillaume and Lavenier, Dominique and Wu, Yu-Wei and Singer, Steven W and Jain, Chirag and Strous, Marc and Klingenberg, Heiner and Meinicke, Peter and Barton, Michael and Lingner, Thomas and Lin, Hsin-Hung and Liao, Yu-Chieh and Gueiros Z. Silva, Genivaldo and Cuevas, Daniel A and Edwards, Robert A and Saha, Surya and Piro, Vitor C and Renard, Bernhard Y and Pop, Mihai and Klenk, Hans-Peter and Goeker, Markus and Kyrpides, Nikos and Woyke, Tanja and Vorholt, Julia A and Schulze-Lefert, Paul and Rubin, Edward M and Darling, Aaron E and Rattei, Thomas and McHardy, Alice C},
	title = {Critical Assessment of Metagenome Interpretation - a benchmark of computational metagenomics software},
	year = {2017},
	doi = {10.1101/099127},
	publisher = {Cold Spring Harbor Labs Journals},
	abstract = {In metagenome analysis, computational methods for assembly, taxonomic profiling and binning are key components facilitating downstream biological data interpretation. However, a lack of consensus about benchmarking datasets and evaluation metrics complicates proper performance assessment. The Critical Assessment of Metagenome Interpretation (CAMI) challenge has engaged the global developer community to benchmark their programs on datasets of unprecedented complexity and realism. Benchmark metagenomes were generated from newly sequenced ~700 microorganisms and ~600 novel viruses and plasmids, including genomes with varying degrees of relatedness to each other and to publicly available ones and representing common experimental setups. Across all datasets, assembly and genome binning programs performed well for species represented by individual genomes, while performance was substantially affected by the presence of related strains. Taxonomic profiling and binning programs were proficient at high taxonomic ranks, with a notable performance decrease below the family level. Parameter settings substantially impacted performances, underscoring the importance of program reproducibility. While highlighting current challenges in computational metagenomics, the CAMI results provide a roadmap for software selection to answer specific research questions.},
	URL = {http://biorxiv.org/content/early/2017/01/09/099127},
	eprint = {http://biorxiv.org/content/early/2017/01/09/099127.full.pdf},
	journal = {bioRxiv}
}

@article{mash,
  doi = {10.1186/s13059-016-0997-x},
  url = {https://doi.org/10.1186/s13059-016-0997-x},
  year  = {2016},
  month = {jun},
  publisher = {Springer Nature},
  volume = {17},
  number = {1},
  author = {Brian D. Ondov and Todd J. Treangen and P{\'{a}}ll Melsted and Adam B. Mallonee and Nicholas H. Bergman and Sergey Koren and Adam M. Phillippy},
  title = {Mash: fast genome and metagenome distance estimation using {MinHash}},
  journal = {Genome Biology}
}

@article {metag_one,
	author = {van der Walt, Andries Johannes and Van Goethem, Marc Warwick and Ramond, Jean-Baptiste and Makhalanyane, Thulani Peter and Reva, Oleg and Cowan, Don Arthur},
	title = {Assembling Metagenomes, One Community At A Time},
	year = {2017},
	doi = {10.1101/120154},
	publisher = {Cold Spring Harbor Labs Journals},
	abstract = {Background: Metagenomics allows unprecedented access to uncultured environmental microorganisms. The analysis of metagenomic sequences facilitates gene prediction and annotation, and enables the assembly of draft genomes, including uncultured members of a community. However, while several platforms have been developed for this critical step, there is currently no clear framework for the assembly of metagenomic sequence data. Results: To assist with selection of an appropriate metagenome assembler we evaluated the capabilities of nine prominent assembly tools on nine publicly-available environmental metagenomes, as well as three simulated datasets. Overall, we found that SPAdes provided the largest contigs and highest N50 values across 6 of the 9 environmental datasets, followed by MEGAHIT and metaSPAdes. MEGAHIT emerged as a computationally inexpensive alternative to SPAdes, assembling the most complex dataset using less than 500 GB of RAM and within 10 hours. Conclusions: We found that assembler choice ultimately depends on the scientific question, the available resources and the bioinformatic competence of the researcher. We provide a concise workflow for the selection of the best assembly tool.},
	URL = {http://biorxiv.org/content/early/2017/06/06/120154},
	eprint = {http://biorxiv.org/content/early/2017/06/06/120154.full.pdf},
	journal = {bioRxiv}
}

@article{geba,
  doi = {10.1371/journal.pbio.1001920},
  url = {https://doi.org/10.1371/journal.pbio.1001920},
  year  = {2014},
  month = {aug},
  publisher = {Public Library of Science ({PLoS})},
  volume = {12},
  number = {8},
  pages = {e1001920},
  author = {Nikos C. Kyrpides and Philip Hugenholtz and Jonathan A. Eisen and Tanja Woyke and Markus G\"{o}ker and Charles T. Parker and Rudolf Amann and Brian J. Beck and Patrick S. G. Chain and Jongsik Chun and Rita R. Colwell and Antoine Danchin and Peter Dawyndt and Tom Dedeurwaerdere and Edward F. DeLong and John C. Detter and Paul De Vos and Timothy J. Donohue and Xiu-Zhu Dong and Dusko S. Ehrlich and Claire Fraser and Richard Gibbs and Jack Gilbert and Paul Gilna and Frank Oliver Gl\"{o}ckner and Janet K. Jansson and Jay D. Keasling and Rob Knight and David Labeda and Alla Lapidus and Jung-Sook Lee and Wen-Jun Li and Juncai MA and Victor Markowitz and Edward R. B. Moore and Mark Morrison and Folker Meyer and Karen E. Nelson and Moriya Ohkuma and Christos A. Ouzounis and Norman Pace and Julian Parkhill and Nan Qin and Ramon Rossello-Mora and Johannes Sikorski and David Smith and Mitch Sogin and Rick Stevens and Uli Stingl and Ken-ichiro Suzuki and Dorothea Taylor and Jim M. Tiedje and Brian Tindall and Michael Wagner and George Weinstock and Jean Weissenbach and Owen White and Jun Wang and Lixin Zhang and Yu-Guang Zhou and Dawn Field and William B. Whitman and George M. Garrity and Hans-Peter Klenk},
  title = {Genomic Encyclopedia of Bacteria and Archaea: Sequencing a Myriad of Type Strains},
  journal = {{PLoS} Biology}
}

@article{Brown2015,
  doi = {10.1038/nbt.3375},
  url = {https://doi.org/10.1038/nbt.3375},
  year  = {2015},
  month = {oct},
  publisher = {Springer Nature},
  volume = {33},
  number = {10},
  pages = {1041--1043},
  author = {C Titus Brown},
  title = {Strain recovery from metagenomes},
  journal = {Nature Biotechnology}
}

@article{Sharon2015,
  doi = {10.1101/gr.183012.114},
  url = {https://doi.org/10.1101/gr.183012.114},
  year  = {2015},
  month = {feb},
  publisher = {Cold Spring Harbor Laboratory Press},
  volume = {25},
  number = {4},
  pages = {534--543},
  author = {Itai Sharon and Michael Kertesz and Laura A. Hug and Dmitry Pushkarev and Timothy A. Blauwkamp and Cindy J. Castelle and Mojgan Amirebrahimi and Brian C. Thomas and David Burstein and Susannah G. Tringe and Kenneth H. Williams and Jillian F. Banfield},
  title = {Accurate,  multi-kb reads resolve complex populations and detect rare microorganisms},
  journal = {Genome Research}
}

@article{laczny2017busybee,
  title={BusyBee Web: metagenomic data analysis by bootstrapped supervised binning and annotation},
  author={Laczny, Cedric C and Kiefer, Christina and Galata, Valentina and Fehlmann, Tobias and Backes, Christina and Keller, Andreas},
  journal={Nucleic Acids Research},
  pages={gkx348},
  year={2017},
  publisher={Oxford University Press}
}

@article{Cleary2015,
  doi = {10.1038/nbt.3329},
  url = {https://doi.org/10.1038/nbt.3329},
  year  = {2015},
  month = {sep},
  publisher = {Springer Nature},
  volume = {33},
  number = {10},
  pages = {1053--1060},
  author = {Brian Cleary and Ilana Lauren Brito and Katherine Huang and Dirk Gevers and Terrance Shea and Sarah Young and Eric J Alm},
  title = {Detection of low-abundance bacterial strains in metagenomic datasets by eigengenome partitioning},
  journal = {Nature Biotechnology}
}

@article{paten2017genome,
  title={Genome graphs and the evolution of genome inference},
  author={Paten, Benedict and Novak, Adam M and Eizenga, Jordan M and Garrison, Erik},
  journal={Genome research},
  volume={27},
  number={5},
  pages={665--676},
  year={2017},
  publisher={Cold Spring Harbor Lab}
}

@article{Brown2017,
  doi = {10.1093/gigascience/gix007},
  url = {https://doi.org/10.1093/gigascience/gix007},
  year  = {2017},
  month = {feb},
  publisher = {Oxford University Press ({OUP})},
  volume = {6},
  number = {3},
  pages = {1--10},
  author = {Bonnie L. Brown and Mick Watson and Samuel S. Minot and Maria C. Rivera and Rima B. Franklin},
  title = {{MinION}{\texttrademark} nanopore sequencing of environmental metagenomes: a synthetic approach},
  journal = {{GigaScience}}
}

@article{Kim2007,
  doi = {10.1101/gr.5894107},
  url = {https://doi.org/10.1101/gr.5894107},
  year  = {2007},
  month = {jun},
  publisher = {Cold Spring Harbor Laboratory Press},
  volume = {17},
  number = {7},
  pages = {1101--1110},
  author = {J. H. Kim and M. S. Waterman and L. M. Li},
  title = {Diploid genome reconstruction of Ciona intestinalis and comparative analysis with Ciona savignyi},
  journal = {Genome Research}
}

@article{Cherf2012,
  doi = {10.1038/nbt.2147},
  url = {https://doi.org/10.1038/nbt.2147},
  year  = {2012},
  month = {feb},
  publisher = {Springer Nature},
  volume = {30},
  number = {4},
  pages = {344--348},
  author = {Gerald M Cherf and Kate R Lieberman and Hytham Rashid and Christopher E Lam and Kevin Karplus and Mark Akeson},
  title = {Automated forward and reverse ratcheting of {DNA} in a nanopore at 5-{AA} precision},
  journal = {Nature Biotechnology}
}

@article{Eid2009,
  doi = {10.1126/science.1162986},
  url = {https://doi.org/10.1126/science.1162986},
  year  = {2009},
  month = {jan},
  publisher = {American Association for the Advancement of Science ({AAAS})},
  volume = {323},
  number = {5910},
  pages = {133--138},
  author = {J. Eid and A. Fehr and J. Gray and K. Luong and J. Lyle and G. Otto and P. Peluso and D. Rank and P. Baybayan and B. Bettman and A. Bibillo and K. Bjornson and B. Chaudhuri and F. Christians and R. Cicero and S. Clark and R. Dalal and A. deWinter and J. Dixon and M. Foquet and A. Gaertner and P. Hardenbol and C. Heiner and K. Hester and D. Holden and G. Kearns and X. Kong and R. Kuse and Y. Lacroix and S. Lin and P. Lundquist and C. Ma and P. Marks and M. Maxham and D. Murphy and I. Park and T. Pham and M. Phillips and J. Roy and R. Sebra and G. Shen and J. Sorenson and A. Tomaney and K. Travers and M. Trulson and J. Vieceli and J. Wegener and D. Wu and A. Yang and D. Zaccarin and P. Zhao and F. Zhong and J. Korlach and S. Turner},
  title = {Real-Time {DNA} Sequencing from Single Polymerase Molecules},
  journal = {Science}
}

@article{Salter2014,
  doi = {10.1186/s12915-014-0087-z},
  url = {https://doi.org/10.1186/s12915-014-0087-z},
  year  = {2014},
  month = {nov},
  publisher = {Springer Nature},
  volume = {12},
  number = {1},
  author = {Susannah J Salter and Michael J Cox and Elena M Turek and Szymon T Calus and William O Cookson and Miriam F Moffatt and Paul Turner and Julian Parkhill and Nicholas J Loman and Alan W Walker},
  title = {Reagent and laboratory contamination can critically impact sequence-based microbiome analyses},
  journal = {{BMC} Biology}
}

@article {Moss125211,
	author = {Moss, Eli and Bishara, Alex and Tkachenko, Ekaterina and Kang, Joyce B and Andermann, Tessa M and Wood, Christina and Handy, Christine and Ji, Hanlee and Batzoglou, Serafim and Bhatt, Ami S},
	title = {De novo assembly of microbial genomes from human gut metagenomes using barcoded short read sequences},
	year = {2017},
	doi = {10.1101/125211},
	publisher = {Cold Spring Harbor Labs Journals},
	abstract = {Shotgun short-read sequencing methods facilitate study of the genomic content and strain-level architecture of complex microbial communities. However, existing methodologies do not capture structural differences between closely related co-occurring strains such as those arising from horizontal gene transfer and insertion sequence mobilization. Recent techniques that partition large DNA molecules, then barcode short fragments derived from them, produce short-read sequences containing long-range information. Here, we present a novel application of these short-read barcoding techniques to metagenomic samples, as well as Athena, an assembler that uses these barcodes to produce improved metagenomic assemblies. We apply our approach to longitudinal samples from the gut microbiome of a patient with a hematological malignancy. This patient underwent an intensive regimen of multiple antibiotics, chemotherapeutics and immunosuppressants, resulting in profound disruption of the microbial gut community and eventual domination by Bacteroides caccae. We significantly improve draft completeness over conventional techniques, uncover strains of B. caccae differing in the positions of transposon integration, and find the abundance of individual strains to fluctuate widely over the course of treatment. In addition, we perform RNA sequencing to investigate relative transcription of genes in B. caccae, and find overexpression of antibiotic resistance genes in our de novo assembled draft genome of B. caccae coinciding with both antibiotic administration and the appearance of proximal transposons harboring a putative bacterial promoter region. Our approach produces overall improvements in contiguity of metagenomic assembly and enables assembly of whole classes of genomic elements inaccessible to existing short-read approaches.},
	URL = {http://biorxiv.org/content/early/2017/04/07/125211},
	eprint = {http://biorxiv.org/content/early/2017/04/07/125211.full.pdf},
	journal = {bioRxiv}
}

@article {SmukowskiHeil150722,
	author = {Smukowski Heil, Caiti and Burton, Joshua N. and Liachko, Ivan and Friedrich, Anne and Hanson, Noah A. and Morris, Cody L. and Schacherer, Joseph and Shendure, Jay and Thomas, James H. and Dunham, Maitreya J.},
	title = {Identification of a novel interspecific hybrid yeast from a metagenomic open fermentation sample using Hi-C},
	year = {2017},
	doi = {10.1101/150722},
	publisher = {Cold Spring Harbor Labs Journals},
	abstract = {Interspecific hybridization is a common mechanism enabling genetic diversification and adaptation; however, the detection of hybrid species has been quite difficult. The identification of microbial hybrids is made even more complicated, as most environmental microbes are resistant to culturing and must be studied in their native mixed communities. We have previously adapted the chromosome conformation capture method Hi-C to the assembly of genomes from mixed populations. Here, we show the method{\textquoteright}s application in assembling a hybrid genome directly from an uncultured, mixed population from an open-fermentation beer sample. Our assembly method has enabled us to de-convolute 4 bacterial and 4 yeast genomes from this sample, including a putative yeast hybrid. Downstream isolation and analysis of this hybrid confirmed its genome to consist of Pichia membranifaciens and that of another related, but undescribed yeast. Our work shows that Hi-C-based metagenomic methods can overcome the limitation of traditional sequencing methods in studying complex mixtures of genomes.},
	URL = {http://biorxiv.org/content/early/2017/06/15/150722},
	eprint = {http://biorxiv.org/content/early/2017/06/15/150722.full.pdf},
	journal = {bioRxiv}
}

@article{Burton2014,
  doi = {10.1534/g3.114.011825},
  url = {https://doi.org/10.1534/g3.114.011825},
  year  = {2014},
  month = {may},
  publisher = {Genetics Society of America},
  volume = {4},
  number = {7},
  pages = {1339--1346},
  author = {Joshua N. Burton and Ivan Liachko and Maitreya J. Dunham and Jay Shendure},
  title = {Species-Level Deconvolution of Metagenome Assemblies with Hi-C{\textendash}Based Contact Probability Maps},
  journal = {G3}
}

@article{Marbouty2014,
  doi = {10.7554/elife.03318},
  url = {https://doi.org/10.7554/elife.03318},
  year  = {2014},
  month = {dec},
  publisher = {{eLife} Sciences Organisation,  Ltd.},
  volume = {3},
  author = {Martial Marbouty and Axel Cournac and Jean-Fran{\c{c}}ois Flot and Herv{\'{e}} Marie-Nelly and Julien Mozziconacci and Romain Koszul},
  title = {Metagenomic chromosome conformation capture (meta3C) unveils the diversity of chromosome organization in microorganisms},
  journal = {{eLife}}
}

@article{Beitel2014,
  doi = {10.7717/peerj.415},
  url = {https://doi.org/10.7717/peerj.415},
  year  = {2014},
  month = {may},
  publisher = {{PeerJ}},
  volume = {2},
  pages = {e415},
  author = {Christopher W. Beitel and Lutz Froenicke and Jenna M. Lang and Ian F. Korf and Richard W. Michelmore and Jonathan A. Eisen and Aaron E. Darling},
  title = {Strain- and plasmid-level deconvolution of a synthetic metagenome by sequencing proximity ligation products},
  journal = {{PeerJ}}
}

@article{Seah2015,
  doi = {10.3389/fmicb.2015.01451},
  url = {https://doi.org/10.3389/fmicb.2015.01451},
  year  = {2015},
  month = {dec},
  publisher = {Frontiers Media {SA}},
  volume = {6},
  author = {Brandon K. B. Seah and Harald R. Gruber-Vodicka},
  title = {gbtools: Interactive Visualization of Metagenome Bins in R},
  journal = {Frontiers in Microbiology}
}

@article{Li2016,
  doi = {10.1016/j.ymeth.2016.02.020},
  url = {https://doi.org/10.1016/j.ymeth.2016.02.020},
  year  = {2016},
  month = {jun},
  publisher = {Elsevier {BV}},
  volume = {102},
  pages = {3--11},
  author = {Dinghua Li and Ruibang Luo and Chi-Man Liu and Chi-Ming Leung and Hing-Fung Ting and Kunihiko Sadakane and Hiroshi Yamashita and Tak-Wah Lam},
  title = {{MEGAHIT} v1.0: A fast and scalable metagenome assembler driven by advanced methodologies and community practices},
  journal = {Methods}
}

@article{Greenwald2017,
  doi = {10.1186/s12864-017-3679-5},
  url = {https://doi.org/10.1186/s12864-017-3679-5},
  year  = {2017},
  month = {apr},
  publisher = {Springer Nature},
  volume = {18},
  number = {1},
  author = {William W. Greenwald and Niels Klitgord and Victor Seguritan and Shibu Yooseph and J. Craig Venter and Chad Garner and Karen E. Nelson and Weizhong Li},
  title = {Utilization of defined microbial communities enables effective evaluation of meta-genomic assemblies},
  journal = {{BMC} Genomics}
}

@article{White2016,
  doi = {10.1128/msystems.00045-16},
  url = {https://doi.org/10.1128/msystems.00045-16},
  year  = {2016},
  month = {jun},
  publisher = {American Society for Microbiology},
  volume = {1},
  number = {3},
  pages = {e00045--16},
  author = {Richard Allen White and Eric M. Bottos and Taniya Roy Chowdhury and Jeremy D. Zucker and Colin J. Brislawn and Carrie D. Nicora and Sarah J. Fansler and Kurt R. Glaesemann and Kevin Glass and Janet K. Jansson},
  editor = {Morgan Langille},
  title = {Moleculo Long-Read Sequencing Facilitates Assembly and Genomic Binning from Complex Soil Metagenomes},
  journal = {{mSystems}}
}

@article{ghurye2016metagenomic,
  title={Metagenomic Assembly: Overview, Challenges and Applications},
  author={Ghurye, Jay and Cepeda-Espinoza, Victoria and Pop, Mihai},
  journal={The Yale Journal of Biology and Medicine},
  volume={89},
  number={3},
  pages={353--362},
  year={2016},
  publisher={YJBM}
}

@article{Sharon2012,
  doi = {10.1101/gr.142315.112},
  url = {https://doi.org/10.1101/gr.142315.112},
  year  = {2012},
  month = {aug},
  publisher = {Cold Spring Harbor Laboratory Press},
  volume = {23},
  number = {1},
  pages = {111--120},
  author = {I. Sharon and M. J. Morowitz and B. C. Thomas and E. K. Costello and D. A. Relman and J. F. Banfield},
  title = {Time series community genomics analysis reveals rapid shifts in bacterial species,  strains,  and phage during infant gut colonization},
  journal = {Genome Research}
}

@article{Hu2016,
  doi = {10.1128/mbio.01669-15},
  url = {https://doi.org/10.1128/mbio.01669-15},
  year  = {2016},
  month = {jan},
  publisher = {American Society for Microbiology},
  volume = {7},
  number = {1},
  pages = {e01669--15},
  author = {Ping Hu and Lauren Tom and Andrea Singh and Brian C. Thomas and Brett J. Baker and Yvette M. Piceno and Gary L. Andersen and Jillian F. Banfield},
  title = {Genome-Resolved Metagenomic Analysis Reveals Roles for Candidate Phyla and Other Microbial Community Members in Biogeochemical Transformations in Oil Reservoirs},
  journal = {{mBio}}
}

@article{Vollmers2017,
  doi = {10.1371/journal.pone.0169662},
  url = {https://doi.org/10.1371/journal.pone.0169662},
  year  = {2017},
  month = {jan},
  publisher = {Public Library of Science ({PLoS})},
  volume = {12},
  number = {1},
  pages = {e0169662},
  author = {John Vollmers and Sandra Wiegand and Anne-Kristin Kaster},
  editor = {Francisco Rodriguez-Valera},
  title = {Comparing and Evaluating Metagenome Assembly Tools from a Microbiologist's Perspective - Not Only Size Matters!},
  journal = {{PLOS} {ONE}}
}

@article{Greshake2015,
  doi = {10.1111/1755-0998.12463},
  url = {https://doi.org/10.1111/1755-0998.12463},
  year  = {2015},
  month = {sep},
  publisher = {Wiley-Blackwell},
  volume = {16},
  number = {2},
  pages = {511--523},
  author = {Bastian Greshake and Simonida Zehr and Francesco Dal Grande and Anjuli Meiser and Imke Schmitt and Ingo Ebersberger},
  title = {Potential and pitfalls of eukaryotic metagenome skimming: a test case for lichens},
  journal = {Molecular Ecology Resources}
}

gha_language: Standard ML