text:
// Code generated by the Pulumi SDK Generator DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package v1alpha1

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-google-native/sdk/go/google/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Creates a new source in a given project and location.
// Auto-naming is currently not supported for this resource.
type Source struct {
	pulumi.CustomResourceState

	// The timestamp when the source was created.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// Free-text description.
	Description pulumi.StringOutput `pulumi:"description"`
	// User-friendly display name.
	DisplayName pulumi.StringOutput `pulumi:"displayName"`
	// The number of frames that were reported by the source and contained errors.
	ErrorFrameCount pulumi.IntOutput `pulumi:"errorFrameCount"`
	// If `true`, the source is managed by other service(s).
	IsManaged pulumi.BoolOutput   `pulumi:"isManaged"`
	Location  pulumi.StringOutput `pulumi:"location"`
	// The full name of the source.
	Name pulumi.StringOutput `pulumi:"name"`
	// Number of frames that are still being processed.
	PendingFrameCount pulumi.IntOutput `pulumi:"pendingFrameCount"`
	// The information confidence of the source. The higher the value, the higher the confidence.
	Priority pulumi.IntOutput    `pulumi:"priority"`
	Project  pulumi.StringOutput `pulumi:"project"`
	// Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
	RequestId pulumi.StringPtrOutput `pulumi:"requestId"`
	// Required. User specified ID for the source. It will become the last component of the source name. The ID must be unique within the project, must conform with RFC-1034, is restricted to lower-cased letters, and has a maximum length of 63 characters. The ID must match the regular expression: `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
	SourceId pulumi.StringOutput `pulumi:"sourceId"`
	// The state of the source.
	State pulumi.StringOutput `pulumi:"state"`
	// Data source type.
	Type pulumi.StringOutput `pulumi:"type"`
	// The timestamp when the source was last updated.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

// NewSource registers a new resource with the given unique name, arguments, and options.
func NewSource(ctx *pulumi.Context,
	name string, args *SourceArgs, opts ...pulumi.ResourceOption) (*Source, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.SourceId == nil {
		return nil, errors.New("invalid value for required argument 'SourceId'")
	}
	replaceOnChanges := pulumi.ReplaceOnChanges([]string{
		"location",
		"project",
		"sourceId",
	})
	opts = append(opts, replaceOnChanges)
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource Source
	err := ctx.RegisterResource("google-native:migrationcenter/v1alpha1:Source", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetSource gets an existing Source resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetSource(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SourceState, opts ...pulumi.ResourceOption) (*Source, error) {
	var resource Source
	err := ctx.ReadResource("google-native:migrationcenter/v1alpha1:Source", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering Source resources.
type sourceState struct {
}

type SourceState struct {
}

func (SourceState) ElementType() reflect.Type {
	return reflect.TypeOf((*sourceState)(nil)).Elem()
}

type sourceArgs struct {
	// Free-text description.
	Description *string `pulumi:"description"`
	// User-friendly display name.
	DisplayName *string `pulumi:"displayName"`
	// If `true`, the source is managed by other service(s).
	IsManaged *bool   `pulumi:"isManaged"`
	Location  *string `pulumi:"location"`
	// The information confidence of the source. The higher the value, the higher the confidence.
	Priority *int    `pulumi:"priority"`
	Project  *string `pulumi:"project"`
	// Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
	RequestId *string `pulumi:"requestId"`
	// Required. User specified ID for the source. It will become the last component of the source name. The ID must be unique within the project, must conform with RFC-1034, is restricted to lower-cased letters, and has a maximum length of 63 characters. The ID must match the regular expression: `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
	SourceId string `pulumi:"sourceId"`
	// Data source type.
	Type *SourceType `pulumi:"type"`
}

// The set of arguments for constructing a Source resource.
type SourceArgs struct {
	// Free-text description.
	Description pulumi.StringPtrInput
	// User-friendly display name.
	DisplayName pulumi.StringPtrInput
	// If `true`, the source is managed by other service(s).
	IsManaged pulumi.BoolPtrInput
	Location  pulumi.StringPtrInput
	// The information confidence of the source. The higher the value, the higher the confidence.
	Priority pulumi.IntPtrInput
	Project  pulumi.StringPtrInput
	// Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
	RequestId pulumi.StringPtrInput
	// Required. User specified ID for the source. It will become the last component of the source name. The ID must be unique within the project, must conform with RFC-1034, is restricted to lower-cased letters, and has a maximum length of 63 characters. The ID must match the regular expression: `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
	SourceId pulumi.StringInput
	// Data source type.
	Type SourceTypePtrInput
}

func (SourceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*sourceArgs)(nil)).Elem()
}

type SourceInput interface {
	pulumi.Input

	ToSourceOutput() SourceOutput
	ToSourceOutputWithContext(ctx context.Context) SourceOutput
}

func (*Source) ElementType() reflect.Type {
	return reflect.TypeOf((**Source)(nil)).Elem()
}

func (i *Source) ToSourceOutput() SourceOutput {
	return i.ToSourceOutputWithContext(context.Background())
}

func (i *Source) ToSourceOutputWithContext(ctx context.Context) SourceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SourceOutput)
}

type SourceOutput struct{ *pulumi.OutputState }

func (SourceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Source)(nil)).Elem()
}

func (o SourceOutput) ToSourceOutput() SourceOutput {
	return o
}

func (o SourceOutput) ToSourceOutputWithContext(ctx context.Context) SourceOutput {
	return o
}

// The timestamp when the source was created.
func (o SourceOutput) CreateTime() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.CreateTime }).(pulumi.StringOutput)
}

// Free-text description.
func (o SourceOutput) Description() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.Description }).(pulumi.StringOutput)
}

// User-friendly display name.
func (o SourceOutput) DisplayName() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.DisplayName }).(pulumi.StringOutput)
}

// The number of frames that were reported by the source and contained errors.
func (o SourceOutput) ErrorFrameCount() pulumi.IntOutput {
	return o.ApplyT(func(v *Source) pulumi.IntOutput { return v.ErrorFrameCount }).(pulumi.IntOutput)
}

// If `true`, the source is managed by other service(s).
func (o SourceOutput) IsManaged() pulumi.BoolOutput {
	return o.ApplyT(func(v *Source) pulumi.BoolOutput { return v.IsManaged }).(pulumi.BoolOutput)
}

func (o SourceOutput) Location() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.Location }).(pulumi.StringOutput)
}

// The full name of the source.
func (o SourceOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
}

// Number of frames that are still being processed.
func (o SourceOutput) PendingFrameCount() pulumi.IntOutput {
	return o.ApplyT(func(v *Source) pulumi.IntOutput { return v.PendingFrameCount }).(pulumi.IntOutput)
}

// The information confidence of the source. The higher the value, the higher the confidence.
func (o SourceOutput) Priority() pulumi.IntOutput {
	return o.ApplyT(func(v *Source) pulumi.IntOutput { return v.Priority }).(pulumi.IntOutput)
}

func (o SourceOutput) Project() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.Project }).(pulumi.StringOutput)
}

// Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
func (o SourceOutput) RequestId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Source) pulumi.StringPtrOutput { return v.RequestId }).(pulumi.StringPtrOutput)
}

// Required. User specified ID for the source. It will become the last component of the source name. The ID must be unique within the project, must conform with RFC-1034, is restricted to lower-cased letters, and has a maximum length of 63 characters. The ID must match the regular expression: `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
func (o SourceOutput) SourceId() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.SourceId }).(pulumi.StringOutput)
}

// The state of the source.
func (o SourceOutput) State() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.State }).(pulumi.StringOutput)
}

// Data source type.
func (o SourceOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.Type }).(pulumi.StringOutput)
}

// The timestamp when the source was last updated.
func (o SourceOutput) UpdateTime() pulumi.StringOutput {
	return o.ApplyT(func(v *Source) pulumi.StringOutput { return v.UpdateTime }).(pulumi.StringOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*SourceInput)(nil)).Elem(), &Source{})
	pulumi.RegisterOutputType(SourceOutput{})
}

repository: pulumi/pulumi-google-native

repo_name: pulumi/pulumi-google-native


text:
SUMMARY = "OpenSwitch system certificate generation"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

RDEPENDS_${PN} = "bash"

SRC_URI = "file://certificate.service \
           file://fix-certificate \
"

S = "${WORKDIR}"

do_install () {
    install -d ${D}${sbindir}
    install -d ${D}${systemd_unitdir}/system

    install -m 0644 ${WORKDIR}/certificate.service ${D}${systemd_unitdir}/system
    install -m 0755 ${WORKDIR}/fix-certificate ${D}${sbindir}/fix-certificate
}

SYSTEMD_PACKAGES = "${PN}"
SYSTEMD_SERVICE_${PN} = "certificate.service"

inherit systemd

repository: billyjbryant/ops-build

license_type: permissive

repo_name: billyjbryant/ops-build

branch_name: refs/heads/master

gha_license_id: NOASSERTION

gha_language: Python

extension: bb


text:
DESCRIPTION = "Helper script for packaged-staging.bbclass"
PR = "r11"

SRC_URI = "file://stage-manager \
           file://stage-manager-ipkg \
           file://stage-manager-ipkg-build "
LICENSE = "GPLv2"

PACKAGE_ARCH = "all"

inherit native

DEPENDS = " "
PACKAGE_DEPENDS = " "
PATCHDEPENDENCY = ""
INHIBIT_DEFAULT_DEPS = "1"

do_install() {
	install -d ${STAGING_BINDIR}
	install -m 0755 ${WORKDIR}/stage-manager ${STAGING_BINDIR}
	install -m 0755 ${WORKDIR}/stage-manager-ipkg ${STAGING_BINDIR}
	install -m 0755 ${WORKDIR}/stage-manager-ipkg-build ${STAGING_BINDIR}
}

do_stage() {
	:
}

license: MIT


text:
@inbook{2009ASPC..411..493S,
 abstract = {The Berkeley Transients Classification Pipeline (TCP) is a parallelized
source identification, classification, and broadcast pipeline
which ingests several real-time data torrents and emits science
events of pre-articulated interest. The TCP's classification
machine-learning algorithms are trained using a comprehensive
science class hierarchy of light-curves which are resampled to
emulate the cadence and quality of incoming observatory data
streams. The referenced classified light-curves are contained
within our growing public data warehouse, DotAstro.org
(http://dotastro.org/). To effectively distinguish a source's
classification from neighboring classes or hierarchical parents,
dozens of real-number metrics (``features'') are derived from
its light-curve, color information, spatial context, and
historical data. Upon science class identification (or
reclassification), a VOEvent XML containing all available
information is broadcast to subscribed telescopes and science
groups for followup. Subsequently acquired data for that source
can then be fed back to DotAstro.org which the TCP will use to
reinforce its internal model of the source's science class. <P
/>},
 adsnote = {Provided by the SAO/NASA Astrophysics Data System},
 adsurl = {https://ui.adsabs.harvard.edu/abs/2009ASPC..411..493S},
 author = {Starr, D.~L. and Bloom, J.~S. and Brewer, J.~M. and
Butler, N.~R. and Poznanski, D. and Rischard, M. and Klein, C.},
 booktitle = {Astronomical Data Analysis Software and Systems XVIII ASP Conference Series, Vol. 411, proceedings of the conference held 2-5 November 2008 at Hotel Loews Le Concorde, Québec City, QC, Canada. Edited by David A. Bohlender, Daniel Durand, and Patrick Dowler.  San Francisco: Astronomical Society of the Pacific, 2009., p.493},
 editor = {Bohlender, D.~A. and Durand, D. and Dowler, P.},
 pages = {493},
 series = {Astronomical Society of the Pacific Conference Series},
 title = {The Berkeley Transient Classification Pipeline: Deriving Real-time Knowledge from Time-domain Surveys},
 volume = {411},
 year = {2009}
}

repository: profjsb/my-content

repo_name: profjsb/my-content

gha_license_id: MIT

gha_language: TeX

extension: bib


text:
DESCRIPTION = "Viewer for a network enabled fbgrab"
HOMEPAGE = "http://svn.openezx.org/trunk/src/userspace/fbgrab/"
LICENSE = "GPL"
SECTION = "console/network"
DEPENDS = "libpng-native"
SRCREV = "1943"
PV = "0.0+svn${SRCDATE}"
PR = "r30"

SRC_URI = "svn://svn.openezx.org/trunk/src/userspace;module=fbgrab;proto=http"
S = "${WORKDIR}/fbgrab"

inherit native

do_compile() {
	${CC} ${CFLAGS} ${LDFLAGS} -g -Wall -lpng -lX11 -o fbgrab-viewer fbgrab-viewer.c
}

do_deploy() {
	install -d ${DEPLOY_DIR_IMAGE}
	install -m 0755 fbgrab-viewer ${DEPLOY_DIR_IMAGE}/fbgrab-viewer
}

do_stage() {
    :
}

do_install() {
    :
}

addtask deploy before do_install after do_compile

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
#
# Copyright (C) 2007 OpenedHand Ltd.
#
# derived from oe-core: meta/recipes-core/packagegroups/packagegroup-core-boot.bb

SUMMARY = "Minimal GUI requirements"
DESCRIPTION = "The minimal set of packages required by NEXELL Tiny GUI"
LICENSE = "MIT"

#PACKAGE_ARCH = "${MACHINE_ARCH}"

inherit packagegroup

PACKAGES = "\
    packagegroup-nexell-tinygui \
    "

RPROVIDES_${PN} = "virtual/egl virtual/libgles1 virtual/libgles2"
RDEPENDS_${PN} = "\
    clutter-example \
    mx-tests \
    mx-1.0 \
    "

#CORE_IMAGE_BASE_INSTALL += "clutter-1.0-examples"
#CORE_IMAGE_BASE_INSTALL += "clutter-1.0-examples mx-1.0 mx-tests"

#CORE_IMAGE_EXTRA_INSTALL += " \
#    ${@base_contains('DISTRO_FEATURES', 'directfb', 'packagegroup-core-directfb', '', d)} \
#    ${@base_contains('DISTRO_FEATURES', 'x11', '', \
#                       base_contains('DISTRO_FEATURES', 'wayland', \
#                                     'weston weston-init clutter-1.0-examples', '', d), d)} \
#"
#export IMAGE_BASENAME = "nexell-image-tiny-gui"


text:
package workermodel

import (
	"errors"
	"strconv"
	"time"

	"github.com/go-gorp/gorp"

	"github.com/ovh/cds/engine/api/cache"
	"github.com/ovh/cds/sdk"
	"github.com/ovh/cds/sdk/log"
)

const (
	bookRegisterTTLInSeconds = 360
)

// ComputeRegistrationNeeds checks if worker models need to be register
// if requirements contains "binary" type: all workers model need to be registered again by
// setting flag need_registration to true in DB.
func ComputeRegistrationNeeds(db gorp.SqlExecutor, allBinaryReqs sdk.RequirementList, reqs sdk.RequirementList) error {
	log.Debug("ComputeRegistrationNeeds>")
	var nbModelReq int
	var nbOSArchReq int
	var nbHostnameReq int

	for _, r := range reqs {
		switch r.Type {
		case sdk.BinaryRequirement:
			exist := false
			for _, e := range allBinaryReqs {
				if e.Value == r.Value {
					exist = true
					break
				}
			}
			if !exist {
				return updateAllToCheckRegistration(db)
			}
		case sdk.OSArchRequirement:
			nbOSArchReq++
		case sdk.ModelRequirement:
			nbModelReq++
		case sdk.HostnameRequirement:
			nbHostnameReq++
		}
	}

	if nbOSArchReq > 1 {
		return sdk.NewError(sdk.ErrWrongRequest, errors.New("invalid os-architecture requirement usage"))
	}
	if nbModelReq > 1 {
		return sdk.NewError(sdk.ErrWrongRequest, errors.New("invalid model requirement usage"))
	}
	if nbHostnameReq > 1 {
		return sdk.NewError(sdk.ErrWrongRequest, errors.New("invalid hostname requirement usage"))
	}

	return nil
}

// updateAllToCheckRegistration is like need_registration but without exclusive mode
func updateAllToCheckRegistration(db gorp.SqlExecutor) error {
	query := `UPDATE worker_model SET check_registration = $1`
	res, err := db.Exec(query, true)
	if err != nil {
		return sdk.WithStack(err)
	}

	rows, err := res.RowsAffected()
	if err != nil {
		return sdk.WithStack(err)
	}
	log.Debug("updateAllToCheckRegistration> %d worker model(s) check registration", rows)
	return nil
}

// UpdateSpawnErrorWorkerModel updates worker model error registration
func UpdateSpawnErrorWorkerModel(db gorp.SqlExecutor, modelID int64, spawnError sdk.SpawnErrorForm) error {
	// some times when the docker container fails to start, the docker logs is not empty but only contains utf8 null char
	if spawnError.Error == string([]byte{0x00}) {
		spawnError.Error = ""
	}

	query := `UPDATE worker_model SET nb_spawn_err=nb_spawn_err+1, last_spawn_err=$3, last_spawn_err_log=$4, date_last_spawn_err=$2 WHERE id = $1`
	res, err := db.Exec(query, modelID, time.Now(), spawnError.Error, spawnError.Logs)
	if err != nil {
		return sdk.WithStack(err)
	}

	n, err := res.RowsAffected()
	if err != nil {
		return sdk.WithStack(err)
	}
	if n == 0 {
		return sdk.WithStack(sdk.ErrNoWorkerModel)
	}
	return nil
}

// UpdateRegistration updates need_registration to false and last_registration time, reset err registration.
func UpdateRegistration(db gorp.SqlExecutor, modelID int64) error {
	query := `UPDATE worker_model SET need_registration=false, check_registration=false, last_registration = $2, nb_spawn_err=0, last_spawn_err=NULL, last_spawn_err_log=NULL WHERE id = $1`
	res, err := db.Exec(query, modelID, time.Now())
	if err != nil {
		return sdk.WithStack(err)
	}

	rows, err := res.RowsAffected()
	if err != nil {
		return sdk.WithStack(err)
	}
	log.Debug("UpdateRegistration> %d worker model updated", rows)
	return nil
}

// UpdateOSAndArch updates os and arch for a worker model.
func UpdateOSAndArch(db gorp.SqlExecutor, modelID int64, OS, arch string) error {
	query := `UPDATE worker_model SET registered_os=$1, registered_arch = $2 WHERE id = $3`
	res, err := db.Exec(query, OS, arch, modelID)
	if err != nil {
		return sdk.WithStack(err)
	}

	rows, err := res.RowsAffected()
	if err != nil {
		return sdk.WithStack(err)
	}
	log.Debug("updateOSAndArch> %d worker model updated", rows)
	return nil
}

// KeyBookWorkerModel returns cache key for given model id.
func KeyBookWorkerModel(id int64) string {
	return cache.Key("book", "workermodel", strconv.FormatInt(id, 10))
}

// BookForRegister books a worker model for register, used by hatcheries
func BookForRegister(store cache.Store, id int64, hatchery *sdk.Service) (*sdk.Service, error) {
	k := KeyBookWorkerModel(id)
	h := sdk.Service{}
	if !store.Get(k, &h) {
		// worker model not already booked, book it for 6 min
		store.SetWithTTL(k, hatchery, bookRegisterTTLInSeconds)
		return nil, nil
	}
	return &h, sdk.WrapError(sdk.ErrWorkerModelAlreadyBooked, "worker model %d already booked by %s (%d)", id, h.Name, h.ID)
}

// UnbookForRegister release the book
func UnbookForRegister(store cache.Store, id int64) {
	k := KeyBookWorkerModel(id)
	store.Delete(k)
}

repository: raylee/cds

repo_name: raylee/cds

extension: go


text:
inherit pypi setuptools3 update-alternatives
require python-argcomplete.inc

ALTERNATIVE_${PN} = "\
    activate-global-python-argcomplete \
    python-argcomplete-check-easy-install-script \
    register-python-argcomplete \
"

ALTERNATIVE_LINK_NAME[activate-global-python-argcomplete] = "${bindir}/activate-global-python-argcomplete"
ALTERNATIVE_LINK_NAME[python-argcomplete-check-easy-install-script] = "${bindir}/python-argcomplete-check-easy-install-script"
ALTERNATIVE_LINK_NAME[register-python-argcomplete] = "${bindir}/register-python-argcomplete"

ALTERNATIVE_PRIORITY = "30"

repository: dwalkes/meta-iot-cloud

repo_name: dwalkes/meta-iot-cloud


text:
DESCRIPTION = "GNU ddrescue is a data recovery tool"
AUTHOR = "Antonio Diaz Diaz"
HOMEPAGE = "http://www.gnu.org/software/ddrescue/ddrescue.html"
SECTION = "console"
PRIORITY = "optional"
LICENSE = "GPLv3+"

SRC_URI = "${GNU_MIRROR}/${PN}/${P}.tar.gz"
SRC_URI[md5sum] = "d6f6cc63df9ad352bc6e43b65c975af5"
SRC_URI[sha256sum] = "cd17b92d64d68ecdef5a61ae17741d45c856a8c5f49e44fbf1f4381d29aaa906"

inherit autotools

EXTRA_OECONF = "'CXX=${CXX}' 'CPPFLAGS=${CPPFLAGS}' 'CXXFLAGS=${CXXFLAGS}' 'LDFLAGS=${LDFLAGS}'"


text:
DESCRIPTION = "OpenGL CTS"

require khronos-cts.inc

SRCREV_amber = "d26ee22dd7faab1845a531d410f7ec1db407402a"
SRCREV_glslang = "c538b5d796fb24dd418fdd650c7f76e56bcc3dd8"
SRCREV_spirv-headers = "e4322e3be589e1ddd44afb20ea842a977c1319b8"
SRCREV_spirv-tools = "1eb89172a82b436d8037e8a8c29c80f7e1f7df74"
SRC_URI[renderdoc.sha256sum] = "e7b5f0aa5b1b0eadc63a1c624c0ca7f5af133aa857d6a4271b0ef3d0bdb6868e"

S = "${WORKDIR}/git"

do_install() {
	install -d ${D}/${CTSDIR}
	cp -r ${B}/external/openglcts/modules/* ${D}/${CTSDIR}
	rm -r ${D}/${CTSDIR}/*.a ${D}/${CTSDIR}/cmake_install.cmake ${D}/${CTSDIR}/CMakeFiles
	rm -r ${D}/${CTSDIR}/*/*.a ${D}/${CTSDIR}/*/cmake_install.cmake ${D}/${CTSDIR}/*/CMakeFiles
	rm -r ${D}/${CTSDIR}/common/subgroups/*.a ${D}/${CTSDIR}/common/subgroups/cmake_install.cmake ${D}/${CTSDIR}/common/subgroups/CMakeFiles
}

repository: johanjeppsson/meta-openembedded

repo_name: johanjeppsson/meta-openembedded


text:
package main

import (
	"time"

	"github.com/kataras/iris/v12/_examples/dependency-injection/sessions/routes"

	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/sessions"
)

func main() {
	app := iris.New()
	sessionManager := sessions.New(sessions.Config{
		Cookie:       "site_session_id",
		Expires:      60 * time.Minute,
		AllowReclaim: true,
	})

	// Session is automatically binded through `sessions.Get(ctx)`
	// if a *sessions.Session input argument is present on the handler's function,
	// which `routes.Index` does.
	app.Use(sessionManager.Handler())

	// Method: GET
	// Path: http://localhost:8080
	app.ConfigureContainer(registerRoutes)

	app.Listen(":8080")
}

func registerRoutes(api *iris.APIContainer) {
	api.Get("/", routes.Index)
}

repository: kataras/iris

repo_name: kataras/iris

gha_language: Go


text:
@InProceedings{burnaev14,
  author = {Burnaev, Evgeny and Vovk, Vladimir},
  title = {Efficiency of conformalized ridge regression},
  pages = {605-622},
  abstract = {Conformal prediction is a method of producing prediction sets that can be applied on top of a wide range of prediction algorithms. The method has a guaranteed coverage probability under the standard IID assumption regardless of whether the assumptions (often considerably more restrictive) of the underlying algorithm are satisfied. However, for the method to be really useful it is desirable that in the case where the assumptions of the underlying algorithm are satisfied, the conformal predictor loses little in efficiency as compared with the underlying algorithm (whereas being a conformal predictor, it has the stronger guarantee of validity). In this paper we explore the degree to which this additional requirement of efficiency is satisfied in the case of Bayesian ridge regression; we find that asymptotically conformal prediction sets differ little from ridge regression prediction intervals when the standard Bayesian assumptions are satisfied.},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
@article{jensen-jisis11-1-23-00,
 author = {Christian Damsgaard Jensen and Nicola Dragoni and Basu, Anirban and Clara Mancini},
 journal = {Journal of Internet Services and Information Security (JISIS)},
 month = {11},
 number = {4},
 pages = {1--4},
 title = {Frontiers in Trust Management},
 volume = {1},
 year = {2011}
}


text:
@book{bolzano2014paradoxes,
  title={Paradoxes of the Infinite (Routledge Revivals)},
  author={Bolzano, Bernard},
  year={2014},
  publisher={Routledge}
}

branch_name: refs/heads/main


text:
@inproceedings{ostendorff-etal-2020-aspect,
    title = "Aspect-based Document Similarity for Research Papers",
    author = "Ostendorff, Malte  and
      Ruas, Terry  and
      Blume, Till  and
      Gipp, Bela  and
      Rehm, Georg",
    booktitle = "Proceedings of the 28th International Conference on Computational Linguistics",
    month = dec,
    year = "2020",
    address = "Barcelona, Spain (Online)",
    publisher = "International Committee on Computational Linguistics",
    url = "https://www.aclweb.org/anthology/2020.coling-main.545",
    doi = "10.18653/v1/2020.coling-main.545",
    pages = "6194--6206",
    abstract = "Traditional document similarity measures provide a coarse-grained distinction between similar and dissimilar documents. Typically, they do not consider in what aspects two documents are similar. This limits the granularity of applications like recommender systems that rely on document similarity. In this paper, we extend similarity with aspect information by performing a pairwise document classification task. We evaluate our aspect-based document similarity approach for research papers. Paper citations indicate the aspect-based similarity, i.e., the title of a section in which a citation occurs acts as a label for the pair of citing and cited paper. We apply a series of Transformer models such as RoBERTa, ELECTRA, XLNet, and BERT variations and compare them to an LSTM baseline. We perform our experiments on two newly constructed datasets of 172,073 research paper pairs from the ACL Anthology and CORD-19 corpus. According to our results, SciBERT is the best performing system with F1-scores of up to 0.83. A qualitative analysis validates our quantitative results and indicates that aspect-based document similarity indeed leads to more fine-grained recommendations.",
}

branch_name: refs/heads/src


text:
@inproceedings{10.1145/192506.192521,
author = {Cunningham, Kevin M.},
title = {An Introduction to Mosaic and the World Wide Web for Technical Communicators},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192521},
doi = {10.1145/192506.192521},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {1},
numpages = {1},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192524,
author = {Knorr, Bruce W. and Norton, Ann Zabriskie},
title = {We Will Write No Online before Its Time: Timing the Development of a Quality Online Help System to Minimize Panic and Save Costs},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192524},
doi = {10.1145/192506.192524},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {2–5},
numpages = {4},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192526,
author = {Smart, Karl L. and Whiting, Matthew E.},
title = {Reassessing the Documentation Paradigm: Writing for Print and Online},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192526},
doi = {10.1145/192506.192526},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {6–9},
numpages = {4},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192530,
author = {Russell, Glenn C.},
title = {A Combined Project Planning Model for Documentation/Training at BNR},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192530},
doi = {10.1145/192506.192530},
abstract = {Bell-Northern Research (BNR) is a global leader in the design and development of advanced telecommunications systems and products. Documentation and training groups at BNR have historically been autonomous; that is until last year. Both organizations have now integrated under one management team. With this association was the understanding that the new organization would encounter a number of problems; for example, differences concerning culture, processes, and functions.The basic premise of the new organization was to provide a more comprehensive service for our internal -BNR- customer base. To do this effectively, we needed an appropriate strategy to eliminate duplication of effort and reduce development interval time, and an organizational structure to accommodate our customer's requirements.To provide a more comprehensive and coordinated service to our customers, required a formalized and planning mechanism. We developed an Information Development Plan (IDP) as a method to capture the combined project plans for documentation and training.  At this point, the IDP has been used for about one year and will develop or evolve into a more integrated plan for our customer base.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {10–16},
numpages = {7},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192531,
author = {Relihan, Liam and Cahill, Tony and Hinchey, Michael G.},
title = {Untangling the World-Wide Web},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192531},
doi = {10.1145/192506.192531},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {17–24},
numpages = {8},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192532,
author = {Abdullah, Abdul Hanan and Gay, Brian},
title = {Implementing an Interface to Networked Services},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192532},
doi = {10.1145/192506.192532},
abstract = {This paper highlights the general problems and difficulties in using networked services. A prototype has been developed to help users interact with networked services. General design principles which arise in implementing a prototype user interface to networked services are discussed. The construction of the prototype is based on an object-oriented approach. The way it communicates with networked services and a help facility are also described.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {25–33},
numpages = {9},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192533,
author = {Freeman, David},
title = {Object Help for GUIs},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192533},
doi = {10.1145/192506.192533},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {34–38},
numpages = {5},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192534,
author = {Johnson, Leslie A.},
title = {Joining the GUI Design Team: A Case Study},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192534},
doi = {10.1145/192506.192534},
abstract = {This paper discusses the experiences of the writing department at a small (85 person or so) high technology company when that department was enlisted to coordinate and design user interfaces for the company's software products. In particular, it takes an in depth look at one particular project.We found that many of the skills necessary for success as technical writers in the computer software industry are also important when designing user interfaces, and that the “self instruction” skills writers acquire can be applied to gaining other, more specialized user interface (UI) design skills. The resulting transfer and augmentation of skills enhances our value as technical communicators},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {39–43},
numpages = {5},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192536,
author = {Killpack, Robbi Bean and Williams, Jaelynn},
title = {Interoperability: Rethinking the Documentation Paradigm},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192536},
doi = {10.1145/192506.192536},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {44–48},
numpages = {5},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192547,
author = {Horberg, John K.},
title = {A Future for Professional Communicators in Software Engineering},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192547},
doi = {10.1145/192506.192547},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {76–87},
numpages = {12},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192548,
author = {Thomas, Brian J.},
title = {Creating a CD-ROM from Scratch: A Case Study},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192548},
doi = {10.1145/192506.192548},
abstract = {Technology has moved us to the point where creating a CD-ROM as an alternative to paper volumes is not only cost effective, but also provides an opportunity to add significant value to the information presented, both in terms of quantity and usefulness. The past year has been a pivotal one in terms of access to simple and cost-effective tools and technologies that push “personal publishing” of CD-ROMs closer to reality for a whole range of publishers and information providers. This paper will review the development cycle of SPIE's first CD-ROM product, the Electronic Imaging '93 Proceedings on CD-ROM, a hybrid Windows/Macintosh disc that was created without the use of any of the proprietary (and often expensive) software royalty-based contracts that have been the established turn-key solution until now. The intent of this paper is to provide a first-hand look at the developmental, technical, and financial issues involved in creating a CD-ROM publication.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {88–95},
numpages = {8},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192549,
author = {Beam, Paul and Burke, Diane},
title = {Learners as Authors: Helping ESL Employees in a Canadian Bank Prepare Customer Relations and Documentation Material},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192549},
doi = {10.1145/192506.192549},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {96–104},
numpages = {9},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192550,
author = {Beam, Paul},
title = {Hands Drawing Each Other: CAL Help Tools as the Base for CAL Instruction},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192550},
doi = {10.1145/192506.192550},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {105–114},
numpages = {10},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192551,
author = {Dicks, R. Stanley},
title = {Integrating Online Help, Documentation, and Training},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192551},
doi = {10.1145/192506.192551},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {115–118},
numpages = {4},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192552,
author = {Goeller, Karen E.},
title = {Zen and the Art of Learning Support: Combining Documentation, Training, and Online Help Functions for a Unique Organizational Approach to Information Development},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192552},
doi = {10.1145/192506.192552},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {119–125},
numpages = {7},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192553,
author = {Ryan, Mark and Helms, Rich},
title = {A Development Process for Large Multimedia Titles},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192553},
doi = {10.1145/192506.192553},
abstract = {Within IBM there are many groups that have made small-scale multimedia titles. Large titles, however, are not so common. This paper describes the process that we followed to create a large title, Experience C++. It begins with a description of why we decided to create a multimedia title about C++. It then describes the process that we followed to make the title. Finally, it describes the lessons that we learned and our plans for the future.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {126–138},
numpages = {13},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192555,
author = {Keller, Rudolf K. and Garg, Anurag and Noaman, Amin and Tao, Tao},
title = {Multi-Level Documentation of Organizational Architectures and Processes},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192555},
doi = {10.1145/192506.192555},
abstract = {The modelling and analysis of organizational architectures and processes should be complemented with adequate documentation such as forms, database information, pieces of software, and anecdotal experience. The resulting models are not only more expressive and useful, but may also serve as on-line training vehicles and means for communication in a multi-person environment. They can be seen as multi-level documentation of the underlying architectures and processes, comprising both formal and informal elements, and allowing for the execution of their formal parts.These concepts are being validated in Macrotec, an environment for organizational modelling and analysis, which is complemented with Hypertec, a hypertext-based component supporting authoring, display and navigation of the documentation that cannot be captured in the formal part of our models. In this paper, we shall discuss Macrotec and Hypertec, illustrate our approach with an example and report on our experience at applying it.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {139–144},
numpages = {6},
keywords = {petri net, hypertext, business process reengineering, action workflow, organizational modelling, computer-supported cooperative work, information system, documentation},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192556,
author = {Gonzales, Joseph I. B.},
title = {A Theory of Organization},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192556},
doi = {10.1145/192506.192556},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {145–155},
numpages = {11},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192557,
author = {Kremer, Rob and Gaines, Brian R.},
title = {Groupware Concept Mapping Techniques},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192557},
doi = {10.1145/192506.192557},
abstract = {Concept maps have been used in education, policy studies and the philosophy of science to provide a visual representation of knowledge structures and argument forms. They provide a complementary alternative to natural language as a means of communicating knowledge. In many disciplines various forms of concept map are already used as formal knowledge representation systems, for example: semantic networks in artificial intelligence, bond graphs in mechanical and electrical engineering, Petri nets in communications, and category graphs in mathematics. This paper describes the design and application of a groupware concept mapping tool designed to support the knowledge processes of geographically dispersed communities.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {156–165},
numpages = {10},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192559,
author = {Shaw, Mildred L. G. and Gaines, Brian R.},
title = {Active Documents Combining Multimedia and Expert Systems},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192559},
doi = {10.1145/192506.192559},
abstract = {An active multimedia document publication system is described which integrates a number of different representation technologies to provide a medium offering a wide spectrum of usage, including new forms of scholarly communication. The capabilities range from emulation of current paper publication, through electronic document delivery on the Internet or CD-ROM, multimedia inclusion of video and sound, hypermedia linkage, to formal knowledge representation for simulation and inference. Aspects of the implementation are described, and examples are given of applications, including one in which an active document forms the knowledge base of an expert system.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {166–175},
numpages = {10},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192560,
author = {Cox, Kevin},
title = {A Unified Approach to Indexing and Retrieval of Information},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192560},
doi = {10.1145/192506.192560},
abstract = {This paper takes another look at information retrieval. It starts from the purposes of retrieval, looks at what people would like from a retrieval system, builds a conceptual model for how a retrieval system could work and from that determines what and how to do appropriate indexing to fit the model. The approach leads to the idea of the duality of indexing and retrieval. The ideas are illustrated by giving the design of a text based system and of a system to store pictures of faces. It is shown that the underlying mechanisms are the same for both systems and it suggests that other retrieval systems using this approach will have similar structures. Other implications of the approach are that retrieval and indexing can be monitored by the machine and the systems can learn to better respond to human needs. Ongoing research in this area is outlined.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {176–181},
numpages = {6},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192562,
author = {Northrop, Mary Jane},
title = {The Fate of Indexes in an Online World},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192562},
doi = {10.1145/192506.192562},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {182–189},
numpages = {8},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192563,
author = {Donnelly, Rich and Hermann, Rick},
title = {Building an Internet Resource for a Specialized Online Community},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192563},
doi = {10.1145/192506.192563},
abstract = {SPIE is a nonprofit organization with 11,000 members worldwide. The society's constituency comprises optical and optoelectronic scientists and engineers in communications, biomedical, manufacturing, aerospace, and other applications. The perceived need to link our technical community electronically is both a response to a future scenario of pervasive interconnectivity among the scientific community and a need to address the issues raised by a changing paradigm for technical publishing, wherein the rise of electronic communication may obviate the need for the traditional publisher (and its capital investment). Through a growing but still modest effort over the last two years, SPIE has created an array of online services that are essentially paving the way for our organization's future offerings in the electronic publishing world. Many of our experiences and observations may apply to any group involved in setting up such a resource, and we hope this case study will provide some assistance to others embarking on that process.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {190–197},
numpages = {8},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192564,
author = {Bednarcyk, Lauren A.},
title = {Issues and Guidelines for Authoring a WWW Project (Extended Abstract): The SAS Experience},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192564},
doi = {10.1145/192506.192564},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {198–199},
numpages = {2},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192565,
author = {Carlshamre, P\"{a}r},
title = {Technical Communicators and System Developers Collaborating in Usability-Oriented Systems Development: A Case Study},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192565},
doi = {10.1145/192506.192565},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {200–207},
numpages = {8},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192566,
author = {Sy, Desir\'{e}e},
title = {Bridging the Communication Gap in the Workplace with Usability Engineering},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192566},
doi = {10.1145/192506.192566},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {208–212},
numpages = {5},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192568,
author = {Mehlenbacher, Brad and Hardin, Beth and Barrett, Chris and Clagett, Jim},
title = {Multi-User Domains and Virtual Campuses: Implications for Computer-Mediated Collaboration and Technical Communication},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192568},
doi = {10.1145/192506.192568},
abstract = {Despite being the focus of 170 articles in the Fall of 1993, few researchers have documented how the Internet, an environment that attracts over 6000 new users per month, will affect the technical communication profession. In particular, researchers have devoted little attention to the rapid emergence of an Internet tool that has the potential to increase collaboration among professional technical communicators. This paper represents one such attempt and describes an electronic tool we are building at NCSU called the TechComm-VC (Virtual Campus), a Multi-User Domain, or MUD.},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {213–219},
numpages = {7},
keywords = {email, virtual communities, computer-mediated collaboration, productivity, internet, multiuser domains},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192571,
author = {Blondheim, Menahem},
title = {Information Ecologies and System Design: A Developmental Perspective on Mass Multimedia Networks},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192571},
doi = {10.1145/192506.192571},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {220–226},
numpages = {7},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192573,
author = {Porter, Lynnette R.},
title = {The Changing Roles of Educators: Using e-Mail, CD-ROM, and Online Documentation in the Technical Writing Classroom},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192573},
doi = {10.1145/192506.192573},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {227–233},
numpages = {7},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192575,
author = {Herold, Phil and Merrill, Carla},
title = {Developing a Hypertext Help System: A Cooperative Effort between a Software Developer and a Technical Writer},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192575},
doi = {10.1145/192506.192575},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {234–245},
numpages = {12},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

@inproceedings{10.1145/192506.192576,
author = {Smart, Karl and Whiting, Matt and Husic, Freda and Moore, Lisa and Orbeton, Peter},
title = {Traversing the Divide: Documentation Challenges of the 90s},
year = {1994},
isbn = {0897916816},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/192506.192576},
doi = {10.1145/192506.192576},
booktitle = {Proceedings of the 12th Annual International Conference on Systems Documentation: Technical Communications at the Great Divide},
pages = {246–250},
numpages = {5},
location = {Banff, Alberta, Canada},
series = {SIGDOC '94}
}

license: Unlicense

repository: goyalkaraniit/acm-cr

repo_name: goyalkaraniit/acm-cr


text:
package gpdb

//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.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

// Backup is a nested struct in gpdb response
type Backup struct {
	BackupMode           string `json:"BackupMode" xml:"BackupMode"`
	BaksetName           string `json:"BaksetName" xml:"BaksetName"`
	LogFileName          string `json:"LogFileName" xml:"LogFileName"`
	BackupSetId          string `json:"BackupSetId" xml:"BackupSetId"`
	BackupEndTime        string `json:"BackupEndTime" xml:"BackupEndTime"`
	LogTime              string `json:"LogTime" xml:"LogTime"`
	BackupSize           int64  `json:"BackupSize" xml:"BackupSize"`
	DataType             string `json:"DataType" xml:"DataType"`
	LogFileSize          int64  `json:"LogFileSize" xml:"LogFileSize"`
	BackupStatus         string `json:"BackupStatus" xml:"BackupStatus"`
	BackupEndTimeLocal   string `json:"BackupEndTimeLocal" xml:"BackupEndTimeLocal"`
	BackupStartTime      string `json:"BackupStartTime" xml:"BackupStartTime"`
	ConsistentTime       int64  `json:"ConsistentTime" xml:"ConsistentTime"`
	BackupStartTimeLocal string `json:"BackupStartTimeLocal" xml:"BackupStartTimeLocal"`
	DBInstanceId         string `json:"DBInstanceId" xml:"DBInstanceId"`
	SegmentName          string `json:"SegmentName" xml:"SegmentName"`
	BackupId             string `json:"BackupId" xml:"BackupId"`
}

repository: aliyun/alibaba-cloud-sdk-go

repo_name: aliyun/alibaba-cloud-sdk-go


text:
DESCRIPTION = "USB serial drivers"
RDEPENDS_${PN} = "kernel-module-usbserial kernel-module-ftdi-sio kernel-module-pl2303 kernel-module-belkin-sa kernel-module-keyspan"

PV = "1.0"
PR = "r0"

ALLOW_EMPTY_${PN} = "1"

gha_language: C


text:
require bug-app.inc

DESCRIPTION = "A basic N-body simulation that shows some objects in a window and calculates the change in motion based on the combination of all masses.  Source based on code available at Princeton class COS 126:\
http://www.cs.princeton.edu/courses/archive/spr01/cs126/assignments/nbody.html"
HOMEPAGE = "http://buglabs.net/applications/NBody"

DEPENDS += "service-tracker com.buglabs.common com.buglabs.bug.module.lcd "

PV = "2"

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

APIVERSION = ""


text:
require gdb.inc
LICENSE = "GPLv3"

PR = "${INC_PR}.0"
# there is a bug in GCC for SH4 it ICE's at Optlevel >O1
# so workaround that for now.

CFLAGS_append_sh4 = " -O1"
SRC_URI += "file://gdb-6.8-fix-compile-karmic.patch \
	    file://gdb-tcsetpgrp.patch \
	    file://gdb-fix-sim-ppc.patch \
	    file://renesas-sh-native-support.patch \
	   "

# Work-around problems while creating libbfd.a
EXTRA_OECONF += "--enable-static"
SRC_URI[md5sum] = "950b766466bee748e554765c86b8b495"
SRC_URI[sha256sum] = "34919cb51334c8149ae36ed086f35e79fe3fa2b2a85b568d7c0edad20cd972d4"


text:
require litephone.inc

SRCREV = "4c9f16d9acc6cd18fc3f647b7e4f44a2d3bdd7b6"
PV = "0.1+gitr${SRCPV}"
PR = "${INC_PR}.1"

SRC_URI = "git://git.senfdax.de/git/litephone;protocol=http \
           file://litephone.desktop"

S = "${WORKDIR}/git/"

do_install() {
    install -d ${D}/${datadir}/pixmaps
    install -m 644 ${S}/pics/blue/Mobile.png ${D}/${datadir}/pixmaps/litephone-mobile.png
    install -d ${D}/${bindir}
    install -m 0755 ${S}/litephone ${D}/${bindir}
    install -d ${D}/etc/litephone
    install ${S}/style_sheet.conf ${D}/etc/litephone/
    install -d ${D}/${datadir}/litephone/translations
    install ${S}/translations/*.qm ${D}/${datadir}/litephone/translations/
    install -d ${D}/${datadir}/applications
    install ${WORKDIR}/litephone.desktop ${D}/${datadir}/applications/
}

FILES_${PN}-locale-pl-pl += "/usr/share/litephone/translations/litephone_pl.qm"
PACKAGES =+ "${PN}-locale-pl-pl"


text:
package events

import (
	"encoding/json"
	"runtime/debug"
	"sync"

	"github.com/nats-io/stan.go"
	log "github.com/sirupsen/logrus"
	"github.com/spf13/viper"

	"github.com/Bnei-Baruch/feed-api/utils"
)

var (
	eventsMutex sync.Mutex
	events      []Data
	DebugMode   bool
)

func ReadAndClearEvents() []Data {
	eventsMutex.Lock()
	defer eventsMutex.Unlock()

	ret := make([]Data, len(events))
	copy(ret, events)
	events = []Data(nil)

	return ret
}

func AddEvent(d Data) {
	eventsMutex.Lock()
	defer eventsMutex.Unlock()

	events = append(events, d)
}

// Returns shut down function.
func RunListener() func() {
	var err error

	log.Info("Initialize connection to nats")
	natsURL := viper.GetString("nats.url")
	natsClientID := viper.GetString("nats.client-id")
	natsClusterID := viper.GetString("nats.cluster-id")
	natsSubject := viper.GetString("nats.subject")
	sc, err := stan.Connect(natsClusterID, natsClientID, stan.NatsURL(natsURL))
	utils.Must(err)

	DebugMode = viper.GetString("nats.mode") == "debug"

	log.Info("Subscribing to nats subject")
	var startOpt stan.SubscriptionOption
	if viper.GetBool("nats.durable") == true {
		startOpt = stan.DurableName(viper.GetString("nats.durable-name"))
	} else {
		startOpt = stan.DeliverAllAvailable()
	}
	_, err = sc.Subscribe(natsSubject, msgHandler, startOpt, stan.SetManualAckMode())
	utils.Must(err)

	return func() { sc.Close() }
}

// Data struct for unmarshaling data from nats
type Data struct {
	ID                  string                 `json:"id"`
	Type                string                 `json:"type"`
	ReplicationLocation string                 `json:"rloc"`
	Payload             map[string]interface{} `json:"payload"`
}

// msgHandler checks message type and calls "eventHandler"
func msgHandler(msg *stan.Msg) {
	// don't panic !
	defer func() {
		if rval := recover(); rval != nil {
			log.Errorf("msgHandler panic: %v while handling %v", rval, msg)
			debug.PrintStack()
		}
	}()

	var d Data
	err := json.Unmarshal(msg.Data, &d)
	if err != nil {
		log.Errorf("json.Unmarshal error: %s\n", err)
	}

	// Acknowledge the message
	if !DebugMode {
		msg.Ack()
	}

	// log.Infof("Adding %+v", d)
	AddEvent(d)
}

repository: Bnei-Baruch/feed-api

repo_name: Bnei-Baruch/feed-api


text:
# Find if a Python module is installed
# Found at http://www.cmake.org/pipermail/cmake/2011-January/041666.html
# To use do: find_python_module(PyQt4 REQUIRED)

# Keep filename as is
# lint_cmake: -convention/filename, -package/stdargs

include(FindPackageHandleStandardArgs)

function(find_python_module module)
    string(TOUPPER ${module} module_upper)
    if(NOT PY_${module_upper})
        if(ARGC GREATER 1 AND ARGV1 STREQUAL "REQUIRED")
            set(PY_${module}_FIND_REQUIRED TRUE)
        endif()
        if($ENV{SSG_USE_PIP_PACKAGES})
            execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
                "import platform; print(''.join('python'+platform.python_version()[:-2]))"
                RESULT_VARIABLE _python_version_status
                OUTPUT_VARIABLE _python_version
                ERROR_QUIET
                OUTPUT_STRIP_TRAILING_WHITESPACE)
            if(NOT ${_python_version_status})
                set(ENV{PYTHONPATH} "/usr/local/lib/${_python_version}/site-packages:/usr/local/lib64/${_python_version}/site-packages")
            endif()
        endif()
        # A module's location is usually a directory, but for binary modules
        # it's a .so file.
        execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
            "import re, ${module}; print(re.compile('/__init__.py.*').sub('',${module}.__file__))"
            RESULT_VARIABLE _${module}_status
            OUTPUT_VARIABLE _${module}_location
            ERROR_QUIET
            OUTPUT_STRIP_TRAILING_WHITESPACE)
        if(NOT _${module}_status)
            set(PY_${module_upper} ${_${module}_location} CACHE STRING
                "Location of Python module ${module}")
        endif()
    endif()
    find_package_handle_standard_args(PY_${module} DEFAULT_MSG PY_${module_upper})
endfunction()

repository: ComplianceAsCode/content

repo_name: ComplianceAsCode/content

gha_language: Shell

extension: cmake


text:
@ARTICLE{Penna2002,
  author = {Paolo Penna},
  title = {On the approximability of two tree drawing conventions},
  journal = {Information Processing Letters},
  year = {2002},
  volume = {82},
  pages = {237--242},
  number = {5},
  abstract = {We consider two aesthetic criteria for the visualization of rooted trees: inclusion and tip-over. Finding the minimum area layout according to either of these two standards is an NP-hard task, even when we restrict ourselves to binary trees. We provide a fully polynomial time approximation scheme for this problem. This result applies to any tree for tip-over layouts and to bounded degree trees in the case of the inclusion convention. We also prove that such restriction is necessary since, for unbounded degree trees, the inclusion problem is strongly NP-hard. Hence, neither a fully polynomial time approximation scheme nor a pseudopolynomial time algorithm exists, unless P=NP. Our technique, combined with the parallel algorithm by Metaxas et al., also yields an NC fully parallel approximation scheme. This latter result holds for inclusion of binary trees and for the slicing floorplanning problem. Although this problem is in P, it is unknown whether it belongs to NC or not. All the above results also apply to other size functions of the drawing (e.g., the perimeter).},
  doi = {10.1016/S0020-0190(01)00280-0}
}

repository: vis-au/treevisnet

repo_name: vis-au/treevisnet


text:
DESCRIPTION = "Creates menu entries from menu-cache data for openbox Window Manager"
SECTION = "x11/wm"
DEPENDS = "openbox glib-2.0 gtk+ menu-cache"
LICENSE = "GPLv3"
LIC_FILES_CHKSUM = "file://COPYING;md5=d32239bcb673463ab874e80d47fae504"

PR="r4"

SRCREV = "6a684325d6be780b3355a4ee993b174e0a2e3103"

SRC_URI = "git://code.google.com/p/pandora-openbox-menu/;protocol=http"
S = "${WORKDIR}/git"

inherit pkgconfig

do_compile() {
	#oe_runmake
	${CC} $(pkg-config --cflags glib-2.0 gtk+-2.0 libmenu-cache) -c menu.c -o menu.o
	${CC} $(pkg-config --libs glib-2.0 gtk+-2.0 libmenu-cache) -o openbox-menu menu.o
}

do_install() {
	oe_runmake install DESTDIR=${D}/usr
}

repository: DougBarry/meta-openpandora-vendor

repo_name: DougBarry/meta-openpandora-vendor


text:
package service

import (
	"context"
	"crypto/sha256"
	"errors"
	"fmt"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v4"
	"github.com/moguchev/meloman/internal/auth"
	"github.com/moguchev/meloman/internal/models"
	"github.com/moguchev/meloman/pkg/api/meloman"
	"go.uber.org/zap"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"
)

func (s *implimentation) Auth(ctx context.Context, req *meloman.AuthRequest) (*meloman.AuthResponse, error) {
	const api = "service.Auth"

	// validate input
	if err := validateCredentials(req.GetCredentials()); err != nil {
		return nil, status.Error(codes.InvalidArgument, err.Error())
	}

	db := s.repo.DB()
	var (
		id               uuid.UUID
		hash, salt, role string
	)

	row := db.QueryRow(ctx, "SELECT id, password, salt, role FROM users WHERE login = $1", req.GetCredentials().GetLogin())
	if err := row.Scan(&id, &hash, &salt, &role); err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return nil, status.Errorf(codes.NotFound, codes.NotFound.String())
		}
		return nil, status.Errorf(codes.Internal, codes.Internal.String())
	}

	hashPassword := sha256.Sum256([]byte(req.GetCredentials().GetPassword() + salt))
	if fmt.Sprintf("%x", hashPassword[:]) != hash {
		return nil, status.Errorf(codes.Unauthenticated, codes.Unauthenticated.String())
	}

	// set auth headers
	token, err := s.authManager.Generate(req.GetCredentials().GetLogin(), models.ParseRole(role).String())
	if err != nil {
		s.log.Error(api, zap.Error(err))
		return nil, status.Error(codes.Internal, codes.Internal.String())
	}
	// create and send header
	header := metadata.Pairs(auth.Header, token)
	grpc.SendHeader(ctx, header)
	// create and set trailer
	trailer := metadata.Pairs(auth.Header, token)
	grpc.SetTrailer(ctx, trailer)

	return &meloman.AuthResponse{Id: id.String()}, nil
}

repository: moguchev/meloman

repo_name: moguchev/meloman


text:
@misc{jsr222,
  title={JSR 222: JavaTM Architecture for XML Binding (JAXB) 2.0},
  author={Oracle},
  year={2009},
  howpublished="\url{https://jcp.org/en/jsr/detail?id=222}"
}

@misc{vogella,
    title={JAXB - Tutorial},
    author={Lars Vogel},
    year={2012},
    howpublished="\url{vogella.com/tutorials/JAXB/article.html}"
}

repository: stetro/DBW

repo_name: stetro/DBW


text:
@inproceedings{Jung:2018:DRI:3266037.3266089,
 author = {Jung, Hyeungshik and Shin, Hijung Valentina and Kim, Juho},
 title = {DynamicSlide: Reference-based Interaction Techniques for Slide-based Lecture Videos},
 booktitle = {The 31st Annual ACM Symposium on User Interface Software and Technology Adjunct Proceedings},
 series = {UIST '18 Adjunct},
 year = {2018},
 isbn = {978-1-4503-5949-8},
 location = {Berlin, Germany},
 pages = {23--25},
 numpages = {3},
 url = {http://doi.acm.org/10.1145/3266037.3266089},
 doi = {10.1145/3266037.3266089},
 acmid = {3266089},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {/visual navigation, educational videos, video learning},
}

@inproceedings{Shin:2017:Thesis,
    title    = {Designing effective interfaces for audiovisual media},
    school   = {Massachusetts Institute of Technology},
    author   = {Shin, Hijung Valentina},
    year     = {2017},
    month    = 9,
    url = {https://scholar.google.com/scholar?oi=bibs&cluster=6924001139520393670&btnI=1&hl=en},
    publisher = {Massachusetts Institute of Technology}
}

@inproceedings{Jung:2018:DED:3264856.3264861,
 author = {Jung, Hyeungshik and Shin, Hijung Valentina and Kim, Juho},
 title = {DynamicSlide: Exploring the Design Space of Reference-based Interaction Techniques for Slide-based Lecture Videos},
 booktitle = {Proceedings of the 2018 Workshop on Multimedia for Accessible Human Computer Interface},
 series = {MAHCI'18},
 year = {2018},
 isbn = {978-1-4503-5980-1},
 location = {Seoul, Republic of Korea},
 pages = {33--41},
 numpages = {9},
 url = {http://doi.acm.org/10.1145/3264856.3264861},
 doi = {10.1145/3264856.3264861},
 acmid = {3264861},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {educational videos, multimedia learning, video content analysis, video learning, visual navigation},
}

@article{Huber:2019,
 author = {Huber, Bernd and Shin, Hijung Valentina and Russel, Bryan and Wang, Oliver and Mysore, Gautham J.},
 title = {B-Script: Transcript-based B-roll Video Editing with Recommendations},
 journal = {To Appear in CHI 2019},
 issue_date = {May 2019},
 month = may,
 year = {2019},
 url = {http://arxiv.org/abs/1902.11216},
 doi = {10.1145/3290605.3300311},
 keywords = {Video, Vlog, Script-based video editing},
}

@article{Funkhouser:2011:LMF:2037820.2037824,
 author = {Funkhouser, Thomas and Shin, Hijung and Toler-Franklin, Corey and Casta\~{n}eda, Antonio Garc\'{\i}a and Brown, Benedict and Dobkin, David and Rusinkiewicz, Szymon and Weyrich, Tim},
 title = {Learning How to Match Fresco Fragments},
 journal = {J. Comput. Cult. Herit.},
 issue_date = {November 2011},
 volume = {4},
 number = {2},
 month = nov,
 year = {2011},
 issn = {1556-4673},
 pages = {7:1--7:13},
 articleno = {7},
 numpages = {13},
 url = {http://doi.acm.org/10.1145/2037820.2037824},
 doi = {10.1145/2037820.2037824},
 acmid = {2037824},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Shape matching, cultural heritage computer-assisted fresco reconstruction, machine learning},
}

@article{Funkhouser:2011:LMF:2037820.2037824,
 author = {Funkhouser, Thomas and Shin, Hijung and Toler-Franklin, Corey and Casta\~{n}eda, Antonio Garc\'{\i}a and Brown, Benedict and Dobkin, David and Rusinkiewicz, Szymon and Weyrich, Tim},
 title = {Learning How to Match Fresco Fragments},
 journal = {J. Comput. Cult. Herit.},
 issue_date = {November 2011},
 volume = {4},
 number = {2},
 month = nov,
 year = {2011},
 issn = {1556-4673},
 pages = {7:1--7:13},
 articleno = {7},
 numpages = {13},
 url = {http://doi.acm.org/10.1145/2037820.2037824},
 doi = {10.1145/2037820.2037824},
 acmid = {2037824},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Shape matching, cultural heritage computer-assisted fresco reconstruction, machine learning},
}

@article{Whiting:2012:SOM:2366145.2366178,
 author = {Whiting, Emily and Shin, Hijung and Wang, Robert and Ochsendorf, John and Durand, Fr{\'e}do},
 title = {Structural Optimization of 3D Masonry Buildings},
 journal = {ACM Trans. Graph.},
 issue_date = {November 2012},
 volume = {31},
 number = {6},
 month = nov,
 year = {2012},
 issn = {0730-0301},
 pages = {159:1--159:11},
 articleno = {159},
 numpages = {11},
 url = {http://doi.acm.org/10.1145/2366145.2366178},
 doi = {10.1145/2366145.2366178},
 acmid = {2366178},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {architecture, optimization, statics, structural stability},
}

@article{Shin:2015:VTL:2816795.2818123,
 author = {Shin, Hijung Valentina and Berthouzoz, Floraine and Li, Wilmot and Durand, Fr{\'e}do},
 title = {Visual Transcripts: Lecture Notes from Blackboard-style Lecture Videos},
 journal = {ACM Trans. Graph.},
 issue_date = {November 2015},
 volume = {34},
 number = {6},
 month = oct,
 year = {2015},
 issn = {0730-0301},
 pages = {240:1--240:10},
 articleno = {240},
 numpages = {10},
 url = {http://doi.acm.org/10.1145/2816795.2818123},
 doi = {10.1145/2816795.2818123},
 acmid = {2818123},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {blackboard-style lectures, lecture videos, video navigation, video summarization},
}

@inproceedings{Shin:2010:AFP,
  author = "Hijung Shin and Christos Doumas and Thomas Funkhouser and Szymon
    Rusinkiewicz and Kenneth Steiglitz and Andreas
    Vlachopoulos and Tim Weyrich",
  title = "Analyzing Fracture Patterns in {Theran} Wall Paintings",
  booktitle = "International Symposium on Virtual Reality, Archaeology, and
    Cultural Heritage (VAST)",
  year = "2010",
  month = sep
}

@article{Shin:2012:ASF:2362402.2362404,
 author = {Shin, Hijung and Doumas, Christos and Funkhouser, Thomas and Rusinkiewicz, Szymon and Steiglitz, Kenneth and Vlachopoulos, Andreas and Weyrich, Tim},
 title = {Analyzing and Simulating Fracture Patterns of Theran Wall Paintings},
 journal = {J. Comput. Cult. Herit.},
 issue_date = {October 2012},
 volume = {5},
 number = {3},
 month = oct,
 year = {2012},
 issn = {1556-4673},
 pages = {10:1--10:14},
 articleno = {10},
 numpages = {14},
 url = {http://doi.acm.org/10.1145/2362402.2362404},
 doi = {10.1145/2362402.2362404},
 acmid = {2362404},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Statistical modeling, cultural heritage, hierarchical fracture},
}

@article{Shin:2016:REE:2882845.2835173,
 author = {Shin, Hijung V. and Porst, Christopher F. and Vouga, Etienne and Ochsendorf, John and Durand, Fr{\'e}do},
 title = {Reconciling Elastic and Equilibrium Methods for Static Analysis},
 journal = {ACM Trans. Graph.},
 issue_date = {May 2016},
 volume = {35},
 number = {2},
 month = feb,
 year = {2016},
 issn = {0730-0301},
 pages = {13:1--13:16},
 articleno = {13},
 numpages = {16},
 url = {http://doi.acm.org/10.1145/2835173},
 doi = {10.1145/2835173},
 acmid = {2835173},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Static equilibrium analysis, contact constraints, finite element method, limit-state analysis, masonry analysis, self-supporting masonry},
}

@inproceedings{Shin:2016:DAA:2984511.2984561,
 author = {Shin, Hijung Valentina and Li, Wilmot and Durand, Fr{\'e}do},
 title = {Dynamic Authoring of Audio with Linked Scripts},
 booktitle = {Proceedings of the 29th Annual Symposium on User Interface Software and Technology},
 series = {UIST '16},
 year = {2016},
 isbn = {978-1-4503-4189-9},
 location = {Tokyo, Japan},
 pages = {509--516},
 numpages = {8},
 url = {http://doi.acm.org/10.1145/2984511.2984561},
 doi = {10.1145/2984511.2984561},
 acmid = {2984561},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {audio recording, dynamic workflows, scripting, transcript-based editing, voice-over},
}

@inproceedings{Kim2018on,
  author    = {Changil Kim and Hijung Valentina Shin and Tae-Hyun Oh and Alexandre Kaspar and Mohamed Elgharib and Wojciech Matusik},
  title     = {On Learning Associations of Faces and Voices},
  booktitle = {Proceedings of Asian Conference on Computer Vision (ACCV)},
  year      = {2018},
}


text:
package loggo

import (
	"testing"
)

func TestFlag(t *testing.T) {
	flags := []struct {
		f Flag
		n string
	}{
		{ FATAL, "FATAL"},
		{ ERROR, "ERROR"},
		{ WARNING, "WARNING"},
		{ NOTICE, "NOTICE"},
		{ INFO, "INFO"},
		{ DEBUG, "DEBUG"},
	}

	for _, f := range flags {
		if f.n != f.f.String() {
			t.Errorf("%b %s != %s", f.f, f.n, f.f)
		}
	}
}

func TestParseFlag(t *testing.T) {
	test_data := []struct {
		f Flag
		n string
	}{
		{ FATAL, "fatal"},
		{ ERROR, "ERROR"},
		{ WARNING, "WARNING"},
		{ WARNING, "Warn"},
		{ NOTICE, "NOTICE"},
		{ INFO, "INFO"},
		{ DEBUG, "Debug"},
		{ DEBUG, "debug"},
		{ DEBUG, "DEBUG"},
	}

	for _, data := range test_data{
		if data.f != ParseLevel(data.n) {
			t.Errorf("%b %s != %s", data.f, data.n, data.f)
		}
	}
}

repository: wllenyj/loggo

repo_name: wllenyj/loggo


text:
package main

import (
	"context"

	log "github.com/Sirupsen/logrus"
	"github.com/gravitational/monitoring-app/watcher/lib"
	"github.com/gravitational/trace"
)

func runDashboardsWatcher() error {
	kubernetesClient, err := lib.NewKubernetesClient()
	if err != nil {
		return trace.Wrap(err)
	}

	grafanaClient, err := lib.NewGrafanaClient()
	if err != nil {
		return trace.Wrap(err)
	}

	err = lib.WaitForAPI(context.TODO(), grafanaClient)
	if err != nil {
		return trace.Wrap(err)
	}

	ch := make(chan string)
	go kubernetesClient.WatchConfigMaps(context.TODO(), lib.DashboardPrefix, ch)
	receiveAndCreateDashboards(context.TODO(), grafanaClient, ch)
	return nil
}

// receiveAndCreateDashboards listens on the provided channel that receives new dashboards data and creates
// them in Grafana using the provided client
func receiveAndCreateDashboards(ctx context.Context, client *lib.GrafanaClient, ch <-chan string) {
	for {
		select {
		case data, ok := <-ch:
			if !ok {
				log.Warningf("dashboards channel closed")
				return
			}

			err := client.CreateDashboard(data)
			if err != nil {
				log.Errorf("failed to create dashboard: %v", trace.DebugReport(err))
			}
		case <-ctx.Done():
			log.Infof("stopping")
			return
		}
	}
}


text:
@incollection{NIPS2017_7117,
title = {Can Decentralized Algorithms Outperform Centralized Algorithms? A Case Study for Decentralized Parallel Stochastic Gradient Descent},
author = {Lian, Xiangru and Zhang, Ce and Zhang, Huan and Hsieh, Cho-Jui and Zhang, Wei and Liu, Ji},
booktitle = {Advances in Neural Information Processing Systems 30},
editor = {I. Guyon and U. V. Luxburg and S. Bengio and H. Wallach and R. Fergus and S. Vishwanathan and R. Garnett},
pages = {5330--5340},
year = {2017},
publisher = {Curran Associates, Inc.},
url = {http://papers.nips.cc/paper/7117-can-decentralized-algorithms-outperform-centralized-algorithms-a-case-study-for-decentralized-parallel-stochastic-gradient-descent.pdf}
}

@inproceedings{shokri2015privacy,
  title={Privacy-preserving deep learning},
  author={Shokri, Reza and Shmatikov, Vitaly},
  booktitle={Proceedings of the 22nd ACM SIGSAC conference on computer and communications security},
  pages={1310--1321},
  year={2015},
  organization={ACM}

} # github code: https://github.com/NagabhushanS/PrivacyPreservingDL

@article{abadi2016deep,
title={Deep Learning with Differential Privacy},
author={Abadi, Martin and Chu, Andy and Goodfellow, Ian J and Mcmahan, H Brendan and Mironov, Ilya and Talwar, Kunal and Zhang, Li},
journal={computer and communications security},
pages={308--318},
year={2016}
}	#github code: https://github.com/tensorflow/models/tree/master/research/differential_privacy

@article{ossia2017a,
title={A Hybrid Deep Learning Architecture for Privacy-Preserving Mobile Analytics},
author={Ossia, Seyed Ali and Shamsabadi, Ali Shahin and Taheri, Ali and Rabiee, Hamid R and Lane, Nicholas D and Haddadi, Hamed},
journal={arXiv: Learning},
year={2017}}

@article{Serviarodriguez2018Privacy,
  title={Privacy-Preserving Personal Model Training},
  author={Serviarodriguez, Sandra and Wang, Liang and Zhao, Jianxin R. and Mortier, Richard and Haddadi, Hamed},
  year={2018},
}

@article{Phan2017Adaptive,
  title={Adaptive Laplace Mechanism: Differential Privacy Preservation in Deep Learning},
  author={Phan, Nhat Hai and Wu, Xintao and Hu, Han and Dou, Dejing},
  pages={385-394},
  year={2017},
}
githttps://github.com/haiphanNJIT/PrivateDeepLearning/tree/master/AdLM

@article{Li2017PrivyNet,
  title={PrivyNet: A Flexible Framework for Privacy-Preserving Deep Neural Network Training},
  author={Li, Meng and Lai, Liangzhen and Suda, Naveen and Chandra, Vikas and Pan, David Z.},
  year={2017},
}

@incollection{NIPS2017_6850,
title = {Accuracy First: Selecting a Differential Privacy Level for Accuracy Constrained ERM},
author = {Ligett, Katrina and Neel, Seth and Roth, Aaron and Waggoner, Bo and Wu, Steven Z.},
booktitle = {Advances in Neural Information Processing Systems 30},
editor = {I. Guyon and U. V. Luxburg and S. Bengio and H. Wallach and R. Fergus and S. Vishwanathan and R. Garnett},
pages = {2566--2576},
year = {2017},
publisher = {Curran Associates, Inc.},
url = {http://papers.nips.cc/paper/6850-accuracy-first-selecting-a-differential-privacy-level-for-accuracy-constrained-erm.pdf}
}

@incollection{NIPS2017_7113,
title = {Renyi Differential Privacy Mechanisms for Posterior Sampling},
author = {Geumlek, Joseph and Song, Shuang and Chaudhuri, Kamalika},
booktitle = {Advances in Neural Information Processing Systems 30},
editor = {I. Guyon and U. V. Luxburg and S. Bengio and H. Wallach and R. Fergus and S. Vishwanathan and R. Garnett},
pages = {5289--5298},
year = {2017},
publisher = {Curran Associates, Inc.},
url = {http://papers.nips.cc/paper/7113-renyi-differential-privacy-mechanisms-for-posterior-sampling.pdf}
}

@incollection{NIPS2017_7117,
title = {Can Decentralized Algorithms Outperform Centralized Algorithms? A Case Study for Decentralized Parallel Stochastic Gradient Descent},
author = {Lian, Xiangru and Zhang, Ce and Zhang, Huan and Hsieh, Cho-Jui and Zhang, Wei and Liu, Ji},
booktitle = {Advances in Neural Information Processing Systems 30},
editor = {I. Guyon and U. V. Luxburg and S. Bengio and H. Wallach and R. Fergus and S. Vishwanathan and R. Garnett},
pages = {5330--5340},
year = {2017},
publisher = {Curran Associates, Inc.},
url = {http://papers.nips.cc/paper/7117-can-decentralized-algorithms-outperform-centralized-algorithms-a-case-study-for-decentralized-parallel-stochastic-gradient-descent.pdf}
}

@incollection{NIPS2016_6050,
title = {Differential Privacy without Sensitivity},
author = {Minami, Kentaro and Arai, HItomi and Sato, Issei and Nakagawa, Hiroshi},
booktitle = {Advances in Neural Information Processing Systems 29},
editor = {D. D. Lee and M. Sugiyama and U. V. Luxburg and I. Guyon and R. Garnett},
pages = {956--964},
year = {2016},
publisher = {Curran Associates, Inc.},
url = {http://papers.nips.cc/paper/6050-differential-privacy-without-sensitivity.pdf}
}

@incollection{NIPS2016_6170,
title = {Privacy Odometers and Filters: Pay-as-you-Go Composition},
author = {Rogers, Ryan M and Roth, Aaron and Ullman, Jonathan and Vadhan, Salil},
booktitle = {Advances in Neural Information Processing Systems 29},
editor = {D. D. Lee and M. Sugiyama and U. V. Luxburg and I. Guyon and R. Garnett},
pages = {1921--1929},
year = {2016},
publisher = {Curran Associates, Inc.},
url = {http://papers.nips.cc/paper/6170-privacy-odometers-and-filters-pay-as-you-go-composition.pdf}
}

@incollection{NIPS2015_6004,
title = {Secure Multi-party Differential Privacy},
author = {Kairouz, Peter and Oh, Sewoong and Viswanath, Pramod},
booktitle = {Advances in Neural Information Processing Systems 28},
editor = {C. Cortes and N. D. Lawrence and D. D. Lee and M. Sugiyama and R. Garnett},
pages = {2008--2016},
year = {2015},
publisher = {Curran Associates, Inc.},
url = {http://papers.nips.cc/paper/6004-secure-multi-party-differential-privacy.pdf}
}

@paper{AAAI1816065,
	author = {Leye Wang and Gehua Qin and Dingqi Yang and Xiao Han and Xiaojuan Ma},
	title = {Geographic Differential Privacy for Mobile Crowd Coverage Maximization},
	conference = {AAAI Conference on Artificial Intelligence},
	year = {2018},
	keywords = {location privacy; differential privacy; mobility},
	url = {https://aaai.org/ocs/index.php/AAAI/AAAI18/paper/view/16065}
}

@paper{AAAI1816123,
	author = {Chaochao Chen and Ziqi Liu and Peilin Zhao and Jun Zhou and Xiaolong Li},
	title = {Privacy Preserving Point-of-Interest Recommendation Using Decentralized Matrix Factorization},
	conference = {AAAI Conference on Artificial Intelligence},
	year = {2018},
	keywords = {recommender system, decentralized learning, POI recommendation},
	url = {https://aaai.org/ocs/index.php/AAAI/AAAI18/paper/view/16123}
}

@paper{AAAI1714971,
	author = {Ke Xu and Tongyi Cao and Swair Shah and Crystal Maung and Haim Schweitzer},
	title = {Cleaning the Null Space: A Privacy Mechanism for Predictors},
	conference = {AAAI Conference on Artificial Intelligence},
	year = {2017},
	keywords = {Privacy; Multi-label Learning; Linear Regression},
	url = {https://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14971}
}

gha_language: Jupyter Notebook


text:
package main

import (
	"errors"
	"fmt"
	"strconv"

	"github.com/manifoldco/promptui"
)

func main() {
	Number()
	Select()
	Custom()
	Confirm()
}

func Number() {
	validate := func(input string) error {
		_, err := strconv.ParseFloat(input, 64)
		if err != nil {
			return errors.New("Invalid number")
		}
		return nil
	}

	prompt := promptui.Prompt{
		Label:    "Number",
		Validate: validate,
	}

	result, err := prompt.Run()

	if err != nil {
		fmt.Printf("Prompt failed %v\n", err)
		return
	}

	fmt.Printf("You choose %q\n", result)
}

func Select() {
	prompt := promptui.Select{
		Label: "Select Day",
		Items: []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
			"Saturday", "Sunday"},
	}

	_, result, err := prompt.Run()

	if err != nil {
		fmt.Printf("Prompt failed %v\n", err)
		return
	}

	fmt.Printf("You choose %q\n", result)
}

func Custom() {
	validate := func(input string) error {
		_, err := strconv.ParseFloat(input, 64)
		return err
	}

	templates := &promptui.PromptTemplates{
		Prompt:  "{{ . }} ",
		Valid:   "{{ . | green }} ",
		Invalid: "{{ . | red }} ",
		Success: "{{ . | bold }} ",
	}

	prompt := promptui.Prompt{
		Label:     "Spicy Level",
		Templates: templates,
		Validate:  validate,
	}

	result, err := prompt.Run()

	if err != nil {
		fmt.Printf("Prompt failed %v\n", err)
		return
	}

	fmt.Printf("You answered %s\n", result)
}

func Confirm() {
	prompt := promptui.Prompt{
		Label:     "Delete Resource",
		IsConfirm: true,
	}

	result, err := prompt.Run()

	if err != nil {
		fmt.Printf("Prompt failed %v\n", err)
		return
	}

	fmt.Printf("You choose %q\n", result)
}


text:
package climacell

import (
	"net/http"
	"time"
)

// BaseURL is the base url of the climacell API
var BaseURL string

func init() {
	BaseURL = "https://api.climacell.co/v3"
}

// Client represents the climacell API client
type Client struct {
	httpClient *http.Client
	baseURL    string
	apiKey     string
}

// NewClient returns a new climacell Client and checks for the
// validity of the provided baseURL
func NewClient(apiKey string, httpClient *http.Client) (*Client, error) {
	client := &Client{}

	if BaseURL == "" {
		return nil, ErrInvalidBaseURL
	}

	if apiKey == "" {
		return nil, ErrInvalidAPIKey
	}

	client.baseURL = BaseURL
	client.apiKey = apiKey

	if httpClient == nil {
		httpClient = &http.Client{
			Timeout: 15 * time.Second,
		}
	}

	client.httpClient = httpClient

	return client, nil
}

repository: marcelblijleven/climacell

repo_name: marcelblijleven/climacell


text:
#FindSharedStructs.cmake
#
# Find the SharedStructs library.
#
# This will define the following variables
#
#    SharedStructs_FOUND
#    SharedStructs_INCLUDE_DIRS
#
# and the following imported targets
#
#     SharedStructs::SharedStructs
#
# Author: Mason U'Ren - mason.uren600@myci.csuci.edu

######################################
# Set package specific variables
######################################
set(PACKAGE_TARGET_NAME "SharedStructs")
set(TARGET_DIRECTORY_NAME "shared_structs")
set(INCLUDE_HDRS
        SharedMemoryStructs.h
        SLAMConfigIn.h
)

######################################
# Generic package creation
######################################
find_package(PkgConfig)
pkg_check_modules(PC_${PACKAGE_TARGET_NAME} QUIET ${PACKAGE_TARGET_NAME})

find_path(
    ${PACKAGE_TARGET_NAME}_INCLUDE_DIR
    NAMES
        ${INCLUDE_HDRS}
    PATHS
        ${CMAKE_CURRENT_SOURCE_DIR}/include/${TARGET_DIRECTORY_NAME}/include
    PATH_SUFFIXES
        ${TARGET_DIRECTORY_NAME}
)

set(${PACKAGE_TARGET_NAME}_VERSION PC_${PACKAGE_TARGET_NAME}_VERSION)

mark_as_advanced(
        ${PACKAGE_TARGET_NAME}_FOUND
        ${PACKAGE_TARGET_NAME}_INCLUDE_DIR
        ${PACKAGE_TARGET_NAME}_VERSION
)

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(
        ${PACKAGE_TARGET_NAME}
        REQUIRED_VARS
            ${PACKAGE_TARGET_NAME}_INCLUDE_DIR
        VERSION_VAR
            ${PACKAGE_TARGET_NAME}_VERSION
)

if (${PACKAGE_TARGET_NAME}_FOUND)
    #Set include dirs to parent, to enable includes like #include <PACKAGE_TARGET_NAME/document.h>
    get_filename_component(
            ${PACKAGE_TARGET_NAME}_INCLUDE_DIRS
            ${${PACKAGE_TARGET_NAME}_INCLUDE_DIR}
            DIRECTORY
    )
endif ()

if (${PACKAGE_TARGET_NAME}_FOUND AND NOT TARGET ${PACAKGE_TARGET_NAME}::${PACKAGE_TARGET_NAME})
    add_library(${PACKAGE_TARGET_NAME}::${PACKAGE_TARGET_NAME} INTERFACE IMPORTED)
    set_target_properties(
            ${PACKAGE_TARGET_NAME}::${PACKAGE_TARGET_NAME}
            PROPERTIES
                INTERFACE_INCLUDE_DIRECTORIES "${${PACKAGE_TARGET_NAME}_INCLUDE_DIRS}"
    )
endif ()

if (${PACKAGE_TARGET_NAME}_FOUND)
    message(STATUS "${PACKAGE_TARGET_NAME}_INCLUDE_DIR: ${${PACKAGE_TARGET_NAME}_INCLUDE_DIRS}")
    #    message(STATUS "${PACKAGE_TARGET_NAME}_VERSION: ${${PACKAGE_TARGET_NAME}_VERSION}")
endif ()

repository: ganechean/MultiAgentSlam-ROS

repo_name: ganechean/MultiAgentSlam-ROS


text:
/*
Copyright 2016 The Kubernetes Authors.

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 master

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"testing"

	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
)

func TestCreateCertsAndConfigForClients(t *testing.T) {
	var tests = []struct {
		a         kubeadmapi.API
		cn        []string
		caKeySize int
		expected  bool
	}{
		{
			a:         kubeadmapi.API{AdvertiseAddresses: []string{"foo"}},
			cn:        []string{"localhost"},
			caKeySize: 128,
			expected:  false,
		},
		{
			a:         kubeadmapi.API{AdvertiseAddresses: []string{"foo"}},
			cn:        []string{},
			caKeySize: 128,
			expected:  true,
		},
		{
			a:         kubeadmapi.API{AdvertiseAddresses: []string{"foo"}},
			cn:        []string{"localhost"},
			caKeySize: 2048,
			expected:  true,
		},
	}

	for _, rt := range tests {
		caKey, err := rsa.GenerateKey(rand.Reader, rt.caKeySize)
		if err != nil {
			t.Fatalf("Couldn't create rsa Private Key")
		}
		caCert := &x509.Certificate{}
		_, actual := CreateCertsAndConfigForClients(rt.a, rt.cn, caKey, caCert)
		if (actual == nil) != rt.expected {
			t.Errorf(
				"failed CreateCertsAndConfigForClients:\n\texpected: %t\n\t  actual: %t",
				rt.expected,
				(actual == nil),
			)
		}
	}
}

repository: leaddevops/kubernetes

repo_name: leaddevops/kubernetes


text:
DESCRIPTION = "CellHunter - A game to collect information about mobile phone cells"
SECTION = "x11/utils"
DEPENDS = "python"
RDEPENDS_${PN} = "python-subprocess python-netclient python-math python-core python-io python-pygtk python-dbus frameworkd"
PR = "r1"

SRC_URI = "\
  http://ch.omoco.de/cellhunter/files/cellhunter-${PV}.tar.gz \
"

do_configure () {
    :
}

do_compile () {
    :
}

do_install () {
    install -d ${D}${bindir}
    install -m 0755 cellhunter.py ${D}${bindir}/
    install -m 0755 cellhunter_upload.sh ${D}${bindir}/
    install -d ${D}${datadir}/pixmaps
    install -d ${D}${datadir}/applications
    install -m 0644 cellhunter.desktop ${D}${datadir}/applications/cellhunter.desktop
    install -m 0644 cellhunter.png ${D}${datadir}/pixmaps/cellhunter.png
}

SRC_URI[md5sum] = "1ac5c56a85fb12bea0bf0a4a2ea664de"
SRC_URI[sha256sum] = "1210dab4e3b23c2a5083d12e9c1527bf099a89f06867e1210b7d9992204c24f8"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty


text:
@techreport{dunn2016,
  title = {Validation of a Mussel Community Assessment Tool for the Upper Mississippi River System},
  number = {2014 MCA2},
  author = {Dunn, Heidi and Zigler, Steve and Newton, Teresa},
  institution = {U.S. Army Corps of Engineers, Rock Island District},
  address = {Rock Island, IL},
  month = {September},
  year = {2016}
}

@article{steuer2008use,
  title={Use of complex hydraulic variables to predict the distribution and density of unionids in a side channel of the Upper Mississippi River},
  author={Steuer, Jeffrey J and Newton, Teresa J and Zigler, Steven J},
  journal={Hydrobiologia},
  volume={610},
  number={1},
  pages={67--82},
  year={2008},
  publisher={Springer},
  url = {https://doi.org/10.1007/s10750-008-9423-z}
}

@article{zigler2008importance,
  title={Importance of physical and hydraulic characteristics to unionid mussels: a retrospective analysis in a reach of large river},
  author={Zigler, Steven J and Newton, Teresa J and Steuer, Jeffrey J and Bartsch, Michelle R and Sauer, Jennifer S},
  journal={Hydrobiologia},
  volume={598},
  number={1},
  pages={343--360},
  year={2008},
  publisher={Springer},
  url = {https://doi.org/10.1007/s10750-007-9167-1}
}

@article{newton2011population,
  title={Population assessment and potential functional roles of native mussels in the Upper Mississippi River},
  author={Newton, Teresa J and Zigler, Steven J and Rogala, James T and Gray, Brian R and Davis, Mike},
  journal={Aquatic Conservation: Marine and Freshwater Ecosystems},
  volume={21},
  number={2},
  pages={122--131},
  year={2011},
  publisher={Wiley Online Library},
  url = {https://doi.org/10.1002/aqc.1170}
}

@article{zigler2012patterns,
  title={Patterns in species richness and assemblage structure of native mussels in the Upper Mississippi River},
  author={Zigler, Steven J and Newton, Teresa J and Davis, Mike and Rogala, James T},
  journal={Aquatic Conservation: Marine and Freshwater Ecosystems},
  volume={22},
  number={5},
  pages={577--587},
  year={2012},
  publisher={Wiley Online Library},
  url = {https://doi.org/10.1002/aqc.2255}
}

repository: mpdougherty/mcat

repo_name: mpdougherty/mcat