text:
@article{campbell2019limits,
  title={Limits in the Revision Theory},
  author={Campbell-Moore, Catrin},
  journal={Journal of Philosophical Logic},
  volume={48},
  number={1},
  pages={11--35},
  year={2019},
  publisher={Springer}
}

repository: catrincm/personal-website

repo_name: catrincm/personal-website


text:
/*
 * ProjectMan
 *
 * devcloud projectman api
 *
 */

package model

import (
	"encoding/json"

	"strings"
)

// Response Object
type ListProjectBugStaticsV4Response struct {
	// bug统计
	BugStatistics  *[]BugStatisticResponseV4 `json:"bug_statistics,omitempty"`
	HttpStatusCode int                       `json:"-"`
}

func (o ListProjectBugStaticsV4Response) String() string {
	data, _ := json.Marshal(o)
	return strings.Join([]string{"ListProjectBugStaticsV4Response", string(data)}, " ")
}

license_type: permissive

branch_name: refs/heads/master

extension: go


text:
package servicecatalogaddons

import (
	"strings"

	"github.com/kyma-project/kyma/components/console-backend-service/internal/gqlschema"
	"github.com/kyma-project/kyma/components/helm-broker/pkg/apis/addons/v1alpha1"
	v1 "k8s.io/api/core/v1"
)

type clusterAddonsConfigurationConverter struct{}

func (c *clusterAddonsConfigurationConverter) ToGQL(item *v1alpha1.ClusterAddonsConfiguration) *gqlschema.AddonsConfiguration {
	if item == nil {
		return nil
	}

	var urls []string
	for _, repo := range item.Spec.Repositories {
		urls = append(urls, repo.URL)
	}

	addonsCfg := gqlschema.AddonsConfiguration{
		Name:   item.Name,
		Labels: item.Labels,
		Urls:   urls,
	}

	return &addonsCfg
}

func (c *clusterAddonsConfigurationConverter) ToGQLs(in []*v1alpha1.ClusterAddonsConfiguration) []gqlschema.AddonsConfiguration {
	var result []gqlschema.AddonsConfiguration
	for _, u := range in {
		converted := c.ToGQL(u)
		if converted != nil {
			result = append(result, *converted)
		}
	}
	return result
}

// Deprecated, the ClusterAddonsConfiguration should be used instead
func (c *clusterAddonsConfigurationConverter) ConfigMapToGQL(item *v1.ConfigMap) *gqlschema.AddonsConfiguration {
	if item == nil {
		return nil
	}

	var urls []string
	if len(item.Data["URLs"]) > 0 {
		urls = strings.Split(item.Data["URLs"], "\n")
	}

	addonsCfg := gqlschema.AddonsConfiguration{
		Name:   item.Name,
		Labels: item.Labels,
		Urls:   urls,
	}

	return &addonsCfg
}

// Deprecated, the ClusterAddonsConfiguration should be used instead
func (c *clusterAddonsConfigurationConverter) ConfigMapToGQLs(in []*v1.ConfigMap) []gqlschema.AddonsConfiguration {
	var result []gqlschema.AddonsConfiguration
	for _, u := range in {
		converted := c.ConfigMapToGQL(u)
		if converted != nil {
			result = append(result, *converted)
		}
	}
	return result
}

repository: obadrawi/kyma

repo_name: obadrawi/kyma


text:
SUMMARY = "OpenBMC org.openbmc.control.Chassis example implementation"
DESCRIPTION = "An example implementation of the org.openbmc.control.Chassis DBUS API."
PR = "r1"
PV = "1.0+git${SRCPV}"

inherit skeleton-python
inherit obmc-phosphor-dbus-service

RDEPENDS:${PN} += "\
        python-dbus \
        python-pygobject \
        python-netclient \
        pyphosphor-dbus \
        "

SKELETON_DIR = "pychassisctl"

FMT = "org.openbmc.control.Chassis@{0}.service"
DBUS_SERVICE:${PN} += "${@compose_list(d, 'FMT', 'OBMC_CHASSIS_INSTANCES')}"

repository: Intel-BMC/openbmc

repo_name: Intel-BMC/openbmc

gha_license_id: NOASSERTION

gha_language: Python

extension: bb


text:
package webapi

import (
	"log"
	"yap/nlp/format/conll"
	"yap/alg/search"
	"yap/alg/transition"
	"github.com/gonuts/commander"
	"yap/util"
	"fmt"
	"yap/util/conf"
	"yap/nlp/format/lattice"
	"strings"
	"yap/app"
	transitionmodel "yap/alg/transition/model"
	. "yap/nlp/parser/dependency/transition"
	nlp "yap/nlp/types"
	"bytes"
	"sync"
)

var (
	depBeam *search.Beam
	depLock sync.Mutex
)

func DepParserInitialize(cmd *commander.Command, args []string) {
	var (
		arcSystem transition.TransitionSystem
		terminalStack int
	)
	arcSystem = &ArcEager{}
	terminalStack = 0
	arcSystem.AddDefaultOracle()
	transitionSystem := transition.TransitionSystem(arcSystem)
	featuresLocation, found := util.LocateFile(app.DepFeaturesFile, app.DEFAULT_CONF_DIRS)
	if !found {
		panic(fmt.Sprintf("Dep features not found"))
	}
	app.DepFeaturesFile = featuresLocation
	labelsLocation, found := util.LocateFile(app.DepLabelsFile, app.DEFAULT_CONF_DIRS)
	if !found {
		panic(fmt.Sprintf("Dep labels not found"))
	}
	app.DepLabelsFile = labelsLocation
	var (
		model *transitionmodel.AvgMatrixSparse = &transitionmodel.AvgMatrixSparse{}
	)
	modelLocation, found := util.LocateFile(app.DepModelName, app.DEFAULT_MODEL_DIRS)
	if !found {
		panic(fmt.Sprintf("Dep model not found"))
	}
	app.DepModelName = modelLocation
	app.DepConfigOut(modelLocation, &search.Beam{}, transitionSystem)
	relations, err := conf.ReadFile(labelsLocation)
	if err != nil {
		panic(fmt.Sprintf("Failed reading Dep labels from file: %v", labelsLocation))
	}
	app.SetupDepEnum(relations.Values)
	arcSystem = &ArcEager{
		ArcStandard: ArcStandard{
			SHIFT: app.SH.Value(),
			LEFT: app.LA.Value(),
			RIGHT: app.RA.Value(),
			Relations: app.ERel,
			Transitions: app.ETrans,
		},
		REDUCE: app.RE.Value(),
		POPROOT: app.PR.Value(),
	}
	arcSystem.AddDefaultOracle()
	transitionSystem = transition.TransitionSystem(arcSystem)
	log.Println()
	log.Println("Loading features")

	featureSetup, err := transition.LoadFeatureConfFile(featuresLocation)
	if err != nil {
		panic(fmt.Sprintf("Failed reading Dep features from file: %v", featuresLocation))
	}
	extractor := app.SetupExtractor(featureSetup, []byte("A"))
	group, _ := extractor.TransTypeGroups['A']
	formatters := make([]util.Format, len(group.FeatureTemplates))
	for i, formatter := range group.FeatureTemplates {
		formatters[i] = formatter
	}

	log.Println("Found model file", modelLocation, " ... loading model")
	serialization := app.ReadModel(modelLocation)
	model.Deserialize(serialization.WeightModel)
	app.EWord = serialization.EWord
	app.EPOS = serialization.EPOS
	app.EWPOS = serialization.EWPOS
	app.EMHost = serialization.EMHost
	app.EMSuffix = serialization.EMSuffix
	log.Println("Loaded model")

	conf := &SimpleConfiguration{
		EWord: app.EWord,
		EPOS: app.EPOS,
		EWPOS: app.EWPOS,
		EMHost: app.EMHost,
		EMSuffix: app.EMSuffix,
		ERel: app.ERel,
		ETrans: app.ETrans,
		TerminalStack: terminalStack,
		TerminalQueue: 0,
	}

	depBeam = &search.Beam{
		TransFunc: transitionSystem,
		FeatExtractor: extractor,
		Base: conf,
		Model: model,
		Size: app.BeamSize,
		ConcurrentExec: app.ConcurrentBeam,
		ShortTempAgenda: true,
		EstimatedTransitions: app.EstimatedBeamTransitions(),
		ScoredStoreDense: true,
	}
}

func DepParseDisambiguatedLattice(input string) string {
	depLock.Lock()
	log.Println("Reading disambiguated lattice")
	log.Println("input:\n",input)
	reader := strings.NewReader(input)
	lDisamb, lDisambE := lattice.Read(reader, 0)
	if lDisambE != nil {
		panic(fmt.Sprintf("Failed reading raw input - %v", lDisamb))
	}
	internalSents := lattice.Lattice2SentenceCorpus(lDisamb, app.EWord, app.EPOS, app.EWPOS, app.EMorphProp, app.EMHost, app.EMSuffix)
	sents := make([]interface{}, len(internalSents))
	for i, instance := range internalSents {
		sents[i] = instance.(nlp.LatticeSentence).TaggedSentence()
	}
	parsedGraphs := app.Parse(sents, depBeam)
	graphAsConll := conll.Graph2ConllCorpus(parsedGraphs, app.EMHost, app.EMSuffix)
	buf := new(bytes.Buffer)
	conll.Write(buf, graphAsConll)
	depLock.Unlock()
	return buf.String()
}

repository: research-software-company/yap

repo_name: research-software-company/yap


text:
/*
Copyright 2018 Google Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://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 common

import (
	"fmt"
	"metacontroller/pkg/logging"
	"strings"

	"sigs.k8s.io/controller-runtime/pkg/client"

	"metacontroller/pkg/apis/metacontroller/v1alpha1"
	"metacontroller/pkg/options"

	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/client-go/discovery"

	"metacontroller/pkg/events"

	mcclientset "metacontroller/pkg/client/generated/clientset/internalclientset"
	mcinformers "metacontroller/pkg/client/generated/informer/externalversions"
	dynamicclientset "metacontroller/pkg/dynamic/clientset"

	"k8s.io/client-go/tools/record"

	"k8s.io/apimachinery/pkg/runtime/schema"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/client-go/tools/cache"

	dynamicdiscovery "metacontroller/pkg/dynamic/discovery"
	dynamicinformer "metacontroller/pkg/dynamic/informer"
)

var (
	KeyFunc = cache.DeletionHandlingMetaNamespaceKeyFunc
	scheme  = runtime.NewScheme()
)

func init() {
	if err := v1alpha1.AddToScheme(scheme); err != nil {
		logging.Logger.Error(err, "failed adding v1alpha1 to scheme")
	}
}

type HookType string
type ControllerType string

const (
	FinalizeHook        HookType       = "finalize"
	CustomizeHook       HookType       = "customize"
	SyncHook            HookType       = "sync"
	CompositeController ControllerType = "CompositeController"
	DecoratorController ControllerType = "DecoratorController"
)

func (h HookType) String() string {
	return string(h)
}

func (c ControllerType) String() string {
	return string(c)
}

// ControllerContext holds various object related to interacting with kubernetes cluster
type ControllerContext struct {
	// K8sClient is a client used to interact with the Kubernetes API
	K8sClient         client.Client
	Resources         *dynamicdiscovery.ResourceMap
	DynClient         *dynamicclientset.Clientset
	DynInformers      *dynamicinformer.SharedInformerFactory
	McInformerFactory mcinformers.SharedInformerFactory
	McClient          mcclientset.Interface
	EventRecorder     record.EventRecorder
	Broadcaster       record.EventBroadcaster
	configuration     options.Configuration
}

// NewControllerContext creates a new ControllerContext using given Configuration and metacontroller client
func NewControllerContext(configuration options.Configuration, mcClient *mcclientset.Clientset) (*ControllerContext, error) {
	// Periodically refresh discovery to pick up newly-installed resources.
	dc := discovery.NewDiscoveryClientForConfigOrDie(configuration.RestConfig)
	resources := dynamicdiscovery.NewResourceMap(dc)

	mcInformerFactory := mcinformers.NewSharedInformerFactory(mcClient, configuration.InformerRelist)

	// Create dynamic clientset (factory for dynamic clients).
	dynClient, err := dynamicclientset.New(configuration.RestConfig, resources)
	if err != nil {
		return nil, err
	}
	// Create dynamic informer factory (for sharing dynamic informers).
	dynInformers := dynamicinformer.NewSharedInformerFactory(dynClient, configuration.InformerRelist)

	// Start metacontrollers (controllers that spawn controllers).
	// Each one requests the informers it needs from the factory.
	broadcaster, err := events.NewBroadcaster(configuration.RestConfig, configuration.CorrelatorOptions)
	if err != nil {
		return nil, err
	}
	recorder := broadcaster.NewRecorder(scheme, corev1.EventSource{Component: "metacontroller"})

	return &ControllerContext{
		Resources:         resources,
		DynClient:         dynClient,
		DynInformers:      dynInformers,
		McInformerFactory: mcInformerFactory,
		EventRecorder:     recorder,
		Broadcaster:       broadcaster,
		configuration:     configuration,
	}, nil
}

// Start starts all informers created up to that point.
// Informers created after Start is called will not be automatically started
func (controllerContext ControllerContext) Start() {
	// We don't care about stopping this cleanly since it has no external effects.
	controllerContext.Resources.Start(controllerContext.configuration.DiscoveryInterval)
	// Start all requested informers.
	// We don't care about stopping this cleanly since it has no external effects.
	controllerContext.McInformerFactory.Start(nil)
}

// GroupVersionKind is metacontroller wrapper around schema.GroupVersionKind
// implementing encoding.TextMarshaler and encoding.TextUnmarshaler
type GroupVersionKind struct {
	schema.GroupVersionKind
}

// MarshalText is implementation of  encoding.TextMarshaler
func (gvk GroupVersionKind) MarshalText() ([]byte, error) {
	var marshalledText string
	if gvk.Group == "" {
		marshalledText = fmt.Sprintf("%s.%s", gvk.Kind, gvk.Version)
	} else {
		marshalledText = fmt.Sprintf("%s.%s/%s", gvk.Kind, gvk.Group, gvk.Version)
	}
	return []byte(marshalledText), nil
}

// UnmarshalText is implementation of encoding.TextUnmarshaler
func (gvk *GroupVersionKind) UnmarshalText(text []byte) error {
	kindGroupVersionString := string(text)
	parts := strings.SplitN(kindGroupVersionString, ".", 2)
	if len(parts) < 2 {
		return fmt.Errorf("could not unmarshall [%s], expected string in 'kind.group/version' format", string(text))
	}
	groupVersion, err := schema.ParseGroupVersion(parts[1])
	if err != nil {
		return err
	}
	*gvk = GroupVersionKind{
		groupVersion.WithKind(parts[0]),
	}
	return nil
}

// RelativeObjectMap holds object related to given parent object.
// The structure is [GroupVersionKind] -> [common.relativeName] -> *unstructured.Unstructured
// where:
//   GroupVersionKind - identifies type stored in entry
//   relativeName() - return path to object in relation to parent
//   *unstructured.Unstructured - object to store
type RelativeObjectMap map[GroupVersionKind]map[string]*unstructured.Unstructured

// InitGroup initializes a map for given schema.GroupVersionKind if not yet initialized
func (m RelativeObjectMap) InitGroup(gvk schema.GroupVersionKind) {
	internalGvk := GroupVersionKind{gvk}
	if m[internalGvk] == nil {
		m[internalGvk] = make(map[string]*unstructured.Unstructured)
	}
}

// Insert inserts given obj to RelativeObjectMap regarding parent
func (m RelativeObjectMap) Insert(parent metav1.Object, obj *unstructured.Unstructured) {
	internalGvk := GroupVersionKind{obj.GroupVersionKind()}
	if m[internalGvk] == nil {
		m.InitGroup(obj.GroupVersionKind())
	}
	group := m[internalGvk]
	name := relativeName(parent, obj)
	group[name] = obj
}

// InsertAll inserts given slice of objects to RelativeObjectMap regarding parent
func (m RelativeObjectMap) InsertAll(parent metav1.Object, objects []*unstructured.Unstructured) {
	for _, object := range objects {
		m.Insert(parent, object)
	}
}

// FindGroupKindName search object by name in each schema.GroupKind (ignoring version part)
func (m RelativeObjectMap) FindGroupKindName(gk schema.GroupKind, name string) *unstructured.Unstructured {
	// The map is keyed by group-version-kind, but we don't know the version.
	// So, check inside any GVK that matches the group and kind, ignoring version.
	for key, objects := range m {
		if key.GroupKind() == gk {
			for n, object := range objects {
				if n == name {
					return object
				}
			}
		}
	}
	return nil
}

// relativeName returns the name of the object relative to the parent.
// If the parent is cluster scoped and the object namespaced scoped the
// name is of the format <namespace>/<name>. Otherwise the name of the object
// is returned.
func relativeName(parent metav1.Object, obj *unstructured.Unstructured) string {
	if parent.GetNamespace() == "" && obj.GetNamespace() != "" {
		return fmt.Sprintf("%s/%s", obj.GetNamespace(), obj.GetName())
	}
	return obj.GetName()
}

// describeObject returns a human-readable string to identify a given object.
func describeObject(obj *unstructured.Unstructured) string {
	if ns := obj.GetNamespace(); ns != "" {
		return fmt.Sprintf("%s %s/%s", obj.GetKind(), ns, obj.GetName())
	}
	return fmt.Sprintf("%s %s", obj.GetKind(), obj.GetName())
}

// ReplaceObject replaces the object with the same name & namespace as
// the given object with the contents of the given object. If no object exists
// in the existing map then no action is taken.
func (m RelativeObjectMap) ReplaceObject(parent metav1.Object, obj *unstructured.Unstructured) {
	internalGvk := GroupVersionKind{obj.GroupVersionKind()}
	objects := m[internalGvk]
	if objects == nil {
		// We only want to replace if it already exists, so do nothing.
		return
	}
	name := relativeName(parent, obj)
	if _, found := objects[name]; found {
		objects[name] = obj
	}
}

// List expands the RelativeObjectMap into a flat list of relative objects, in random order.
func (m RelativeObjectMap) List() []*unstructured.Unstructured {
	var list []*unstructured.Unstructured
	for _, group := range m {
		for _, obj := range group {
			list = append(list, obj)
		}
	}
	return list
}

// MakeRelativeObjectMap builds the map of objects resources that is suitable for use
// in the `children` field of a CompositeController SyncRequest or
// `attachments` field of  the  DecoratorControllers SyncRequest or `customize` field of
// customize hook
//
// This function returns a RelativeObjectMap which is a map of maps. The outer most map
// is keyed  using the object's type and the inner map is keyed using the
// object's name. If the parent resource is clustered and the object resource
// is namespaced the inner map's keys are prefixed by the namespace of the
// object resource.
//
// This function requires parent resources has the meta.Namespace accurately
// set. If the namespace of the parent is empty it's considered a clustered
// resource.
//
// If a user returns a namespaced as a object of a clustered resources without
// the namespace set this is considered a user error but it's not handled here
// since the api errorstring to create the object is clear.
func MakeRelativeObjectMap(parent metav1.Object, list []*unstructured.Unstructured) RelativeObjectMap {
	relativeObjects := make(RelativeObjectMap)

	relativeObjects.InsertAll(parent, list)

	return relativeObjects
}

func ParseAPIVersion(apiVersion string) (group, version string) {
	parts := strings.SplitN(apiVersion, "/", 2)
	if len(parts) == 1 {
		// It's a core version.
		return "", parts[0]
	}
	return parts[0], parts[1]
}

type GroupKindMap map[schema.GroupKind]*dynamicdiscovery.APIResource

func (m GroupKindMap) Set(gk schema.GroupKind, resource *dynamicdiscovery.APIResource) {
	m[gk] = resource
}

func (m GroupKindMap) Get(gk schema.GroupKind) *dynamicdiscovery.APIResource {
	return m[gk]
}

type InformerMap map[schema.GroupVersionResource]*dynamicinformer.ResourceInformer

func (m InformerMap) Set(gvr schema.GroupVersionResource, informer *dynamicinformer.ResourceInformer) {
	m[gvr] = informer
}

func (m InformerMap) Get(gvr schema.GroupVersionResource) *dynamicinformer.ResourceInformer {
	return m[gvr]
}

// GetObject return object via Lister from given informer, namespaced or not.
func GetObject(informer *dynamicinformer.ResourceInformer, namespace, name string) (*unstructured.Unstructured, error) {
	if namespace == "" {
		return informer.Lister().Get(name)
	}
	return informer.Lister().Namespace(namespace).Get(name)
}

repository: srfrnk/metacontroller

repo_name: srfrnk/metacontroller


text:
@article{布什2004科学,
  title={科学: 没有止境的前沿},
  author={布什 and others},
  journal={译. 北京: 商务印书馆},
  year={2004}
}

@article{苏开源2005一份扭转乾坤的科学报告,
  title={一份扭转乾坤的科学报告——《 科学——没有止境的前沿》 60 年述评},
  author={苏开源},
  journal={世界科学},
  number={8},
  pages={41--42},
  year={2005}
}

@article{李勇2008v,
  title={V. 布什报告与美国战后科学研究信念的建构——从科学研究信念史的视角解读《 科学: 没有止境的前沿》},
  author={李勇},
  journal={自然辩证法研究},
  volume={24},
  number={3},
  pages={79--83},
  year={2008}
}

license: MIT

repository: RonDen/pku-report

repo_name: RonDen/pku-report

extension: bib


text:
package controllers

import (
	"k8s.io/apimachinery/pkg/api/meta"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	syncv1alpha1 "github.com/vshn/espejo/api/v1alpha1"
)

func (r *SyncConfigReconciler) shouldSkipStatusUpdate() bool {
	return r.NamespaceScope != ""
}

func (r *SyncConfigReconciler) updateStatus(rc *ReconciliationContext) error {
	if r.shouldSkipStatusUpdate() {
		return nil
	}
	status := rc.cfg.Status

	status.SynchronizedItemCount = rc.syncCount
	status.DeletedItemCount = rc.deleteCount
	status.FailedItemCount = rc.failCount

	rc.cfg.Status = status
	err := r.Client.Status().Update(rc.ctx, rc.cfg)
	if err != nil {
		r.Log.Error(err, "Could not update SyncConfig.", getLoggingKeysAndValuesForSyncConfig(rc.cfg)...)
		return err
	}
	r.Log.WithValues("syncCount", rc.syncCount, "deleteCount", rc.deleteCount, "failCount", rc.failCount).
		Info("Updated SyncConfig status.", getLoggingKeysAndValuesForSyncConfig(rc.cfg)...)
	return nil
}

// SetStatusCondition adds the given condition to the status condition of the SyncConfig. Overwrites existing conditions
// of the same type.
func (rc *ReconciliationContext) SetStatusCondition(condition metav1.Condition) {
	meta.SetStatusCondition(&rc.cfg.Status.Conditions, condition)
}

// SetStatusIfExisting sets the condition of the given type to the given status, if the condition already exists, otherwise noop
func (rc *ReconciliationContext) SetStatusIfExisting(conditionType syncv1alpha1.ConditionType, status metav1.ConditionStatus) {
	if condition := meta.FindStatusCondition(rc.cfg.Status.Conditions, conditionType.String()); condition != nil {
		condition.Status = status
		meta.SetStatusCondition(&rc.cfg.Status.Conditions, *condition)
	}
}

// CreateStatusConditionReady is a shortcut for adding a ConditionConfigReady condition.
func CreateStatusConditionReady(isReady bool) metav1.Condition {
	readyCondition := metav1.Condition{
		Status:             metav1.ConditionFalse,
		Type:               syncv1alpha1.ConditionConfigReady.String(),
		LastTransitionTime: metav1.Now(),
		Reason:             syncv1alpha1.SyncReasonFailed,
		Message:            "Synchronization failed",
	}
	if isReady {
		readyCondition.Status = metav1.ConditionTrue
		readyCondition.Reason = syncv1alpha1.SyncReasonSucceeded
		readyCondition.Message = "Synchronization completed successfully"
	}
	return readyCondition
}

// CreateStatusConditionErrored is a shortcut for adding a ConditionErrored condition with the given error message.
func CreateStatusConditionErrored(err error) metav1.Condition {
	return metav1.Condition{
		Status:  metav1.ConditionTrue,
		Type:    syncv1alpha1.ConditionErrored.String(),
		Reason:  syncv1alpha1.SyncReasonFailedWithError,
		Message: err.Error(),
	}
}

// CreateStatusConditionInvalid is a shortcut for adding a ConditionInvalid condition with the given error message.
func CreateStatusConditionInvalid(err error) metav1.Condition {
	return metav1.Condition{
		Status:             metav1.ConditionTrue,
		Type:               syncv1alpha1.ConditionInvalid.String(),
		LastTransitionTime: metav1.Now(),
		Reason:             syncv1alpha1.SyncReasonConfigInvalid,
		Message:            err.Error(),
	}
}

// IncrementSyncCount increments the sync count by 1
func (rc *ReconciliationContext) IncrementSyncCount() {
	rc.syncCount++
}

// IncrementDeleteCount increments the delete count by 1
func (rc *ReconciliationContext) IncrementDeleteCount() {
	rc.deleteCount++
}

// IncrementFailCount increments the fail count by 1
func (rc *ReconciliationContext) IncrementFailCount() {
	rc.failCount++
}

repository: vshn/espejo

repo_name: vshn/espejo

gha_language: Go


text:
/*
Copyright 2019 The Skaffold 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 runner

import (
	"context"
	"io"
	"io/ioutil"

	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/color"
	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/schema/latest"

	"github.com/pkg/errors"

	pipeline "github.com/GoogleContainerTools/skaffold/pkg/skaffold/generate_pipeline"
)

func (r *SkaffoldRunner) GeneratePipeline(ctx context.Context, out io.Writer, config *latest.SkaffoldConfig, fileOut string) error {
	// Keep track of files, configs, and profiles. This will be used to know which files to write
	// profiles to and what flags to add to task commands
	configFiles := []*pipeline.ConfigFile{
		{
			Path:    r.runCtx.Opts.ConfigurationFile,
			Config:  config,
			Profile: nil,
		},
	}

	// Will run the profile setup multiple times and require user input for each specified config
	color.Default.Fprintln(out, "Running profile setup...")
	for _, configFile := range configFiles {
		if err := pipeline.CreateSkaffoldProfile(out, r.runCtx, configFile); err != nil {
			return errors.Wrap(err, "setting up profile")
		}
	}

	color.Default.Fprintln(out, "Generating Pipeline...")
	pipelineYaml, err := pipeline.Yaml(out, r.runCtx, configFiles)
	if err != nil {
		return errors.Wrap(err, "generating pipeline yaml contents")
	}

	// write all yaml pieces to output
	return ioutil.WriteFile(fileOut, pipelineYaml.Bytes(), 0755)
}

repository: cuijxin/skaffold

repo_name: cuijxin/skaffold


text:
file(REMOVE_RECURSE
  "CMakeFiles/doc"
  "../doc_src/types.rst"
  "../doc_src/constants.rst"
  "../doc_src/types_generated.rst"
  "../doc_src/server.rst"
  "../doc_src/server_config.rst"
  "../doc_src/client.rst"
  "../doc_src/client_highlevel.rst"
  "../doc_src/plugin_log.rst"
  "../doc_src/plugin_network.rst"
  "../doc_src/services.rst"
  "../doc_src/plugin_access_control.rst"
  "../doc_src/nodestore.rst"
  "../doc_src/tutorial_datatypes.rst"
  "../doc_src/tutorial_client_firststeps.rst"
  "../doc_src/tutorial_server_firststeps.rst"
  "../doc_src/tutorial_server_variable.rst"
  "../doc_src/tutorial_server_variabletype.rst"
  "../doc_src/tutorial_server_datasource.rst"
  "../doc_src/tutorial_server_object.rst"
  "../doc_src/tutorial_server_method.rst"
)

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

extension: cmake


text:
% This file was created with JabRef 2.10.
% Encoding: UTF-8

@Article{csimcsekli2015alpha,
  Title                    = {Alpha-stable matrix factorization},
  Author                   = {{\c{S}}im{\c{s}}ekli, U. and Liutkus, A. and Cemgil, A.T.},
  Journal                  = IEEE_J_SPL,
  Year                     = {2015},
  Number                   = {12},
  Pages                    = {2289--2293},
  Volume                   = {22},

  Owner                    = {mafontai},
  Publisher                = {IEEE},
  Timestamp                = {2016.07.26}
}

@InProceedings{simsekli2018alphastable,
  Title                    = {Alpha-stable low-rank plus residual decomposition for speech enhancement},
  Author                   = {{\c{S}}im{\c{s}}ekli, U. and others},
  Booktitle                = {Acoustics, Speech and Signal Processing (ICASSP), 2018 IEEE International Conference on},
  Year                     = {2018},
  Organization             = {IEEE},

  Owner                    = {mafontai},
  Timestamp                = {2018.02.01}
}

@article{ansi1997,
  title={S3. 5-1997, Methods for the calculation of the speech intelligibility index},
  author={ANSI},
  journal={New York: American National Standards Institute},
  volume={19},
  pages={90--119},
  year={1997}
}

@InProceedings{arberet2010nonnegative,
  Title                    = {Nonnegative matrix factorization and spatial covariance model for under-determined reverberant audio source separation},
  Author                   = {Arberet, S. and Ozerov, A. and Duong, N. QK and Vincent, E. and Gribonval, R. and Bimbot, F. and Vandergheynst, P.},
  Booktitle                = {International Conference on Information Sciences Signal Processing and their Applications (ISSPA)},
  Year                     = {2010},
  Organization             = {IEEE},
  Pages                    = {1--4}
}

@Article{asmussen2003applied,
  Title                    = {Applied probability and queues: Stochastic modelling and applied probability},
  Author                   = {Asmussen, S.},
  Journal                  = {Applications of Mathematics (New York)},
  Year                     = {2003},
  Volume                   = {51}
}

@Article{benesty2008noncausal,
  Title                    = {Noncausal (frequency-domain) optimal filters},
  Author                   = {Benesty, J. and Chen, J. and Huang, Y.},
  Journal                  = {Microphone array signal processing},
  Year                     = {2008},
  Pages                    = {115--137},

  Owner                    = {mafontai},
  Publisher                = {Springer},
  Timestamp                = {2018.01.31}
}

@Article{Boutsidis2016,
  Title                    = {{SVD} based initialization: A head start for nonnegative matrix factorization},
  Author                   = {Boutsidis, C. and Gallopoulos, E.},
  Journal                  = {Pattern Recognition},
  Year                     = {2008},
  Number                   = {4},
  Pages                    = {1350--1362},
  Volume                   = {41},

  Publisher                = {Elsevier}
}

@Article{cambanis1983alpha,
  Title                    = {On $\alpha$-symmetric multivariate distributions},
  Author                   = {Cambanis, S. and Keener, R. and Simons, G.},
  Journal                  = {Journal of Multivariate Analysis},
  Year                     = {1983},
  Number                   = {2},
  Pages                    = {213--233},
  Volume                   = {13},

  Publisher                = {Elsevier}
}

@Article{cohen2002optimal,
  Title                    = {Optimal speech enhancement under signal presence uncertainty using log-spectral amplitude estimator},
  Author                   = {Cohen, I.},
  Journal                  = IEEE_J_SPL,
  Year                     = {2002},
  Number                   = {4},
  Pages                    = {113--116},
  Volume                   = {9},

  Publisher                = {IEEE}
}

@Article{doclo2002gsvd,
  title={GSVD-based optimal filtering for single and multimicrophone speech enhancement},
  author={Doclo, S. and Moonen, M.},
  journal={IEEE Transactions on Signal Processing},
  volume={50},
  number={9},
  pages={2230--2244},
  year={2002},
  publisher={IEEE}
}

@article{doclo2007frequency,
  title={Frequency-domain criterion for the speech distortion weighted multichannel wiener filter for robust noise reduction},
  author={Doclo, Simon and Spriet, Ann and Wouters, Jan and Moonen, Marc},
  journal={Speech Communication},
  volume={49},
  number={7-8},
  pages={636--656},
  year={2007},
  publisher={Elsevier}
}

@Article{duong_TSALP2010,
  Title                    = {Under-Determined Reverberant Audio Source Separation Using a Full-Rank Spatial Covariance Model},
  Author                   = {Duong, N.Q.K. and Vincent, E. and Gribonval, R.},
  Journal                  = IEEE_J_ASLP,
  Year                     = {2010},

  Month                    = {sept. },
  Number                   = {7},
  Pages                    = {1830 -1840},
  Volume                   = {18},

  Doi                      = {10.1109/TASL.2010.2050716},
  ISSN                     = {1558-7916},
  Keywords                 = {audio source separation;blind source separation;covariance encodes;full-rank unconstrained model;iterative expectation-maximization algorithms;mixture channels;spatial characteristics;spatial covariance model;time frequency domain;underdetermined reverberant;zero-mean Gaussian random variable;audio signal processing;covariance analysis;source separation;},
  Owner                    = {papa},
  Timestamp                = {2012.05.14}
}

@Article{ephraim1985speech,
  Title                    = {Speech enhancement using a minimum mean-square error log-spectral amplitude estimator},
  Author                   = {Ephraim, Y. and Malah, D.},
  Journal                  = IEEE_J_ASSP,
  Year                     = {1985},
  Number                   = {2},
  Pages                    = {443--445},
  Volume                   = {33},

  Owner                    = {mafontai},
  Publisher                = {IEEE},
  Timestamp                = {2018.01.18}
}

@Article{ephraim1984speech,
  Title                    = {Speech enhancement using a minimum-mean square error short-time spectral amplitude estimator},
  Author                   = {Ephraim, Y. and Malah, D.},
  Journal                  = IEEE_J_ASSP,
  Year                     = {1984},
  Number                   = {6},
  Pages                    = {1109--1121},
  Volume                   = {32},

  Owner                    = {mafontai},
  Publisher                = {IEEE},
  Timestamp                = {2018.01.18}
}

@Article{fevotte2011algorithms,
  Title                    = {Algorithms for nonnegative matrix factorization with the $\beta$-divergence},
  Author                   = {F{\'e}votte, C. and Idier, J.},
  Journal                  = {Neural computation},
  Year                     = {2011},
  Number                   = {9},
  Pages                    = {2421--2456},
  Volume                   = {23},

  Owner                    = {mafontai},
  Publisher                = {MIT Press},
  Timestamp                = {2018.01.25}
}

@Article{fitzgerald2016projection,
  Title                    = {Projection-based demixing of spatial audio},
  Author                   = {Fitzgerald, D. and Liutkus, A. and Badeau, R.},
  Journal                  = IEEE_J_ASLP,
  Year                     = {2016},

  Month                    = sep,
  Number                   = {9},
  Pages                    = {1560--1572},
  Volume                   = {24},

  __markedentry            = {[mafontai:1]},
  Owner                    = {mafontai},
  Publisher                = {IEEE},
  Timestamp                = {2016.07.22}
}

@InProceedings{fontaine2017WASPAA,
  Title                    = {Parameterized {W}iener filtering for single-channel denoising},
  Author                   = {Fontaine, M. and Liutkus, A. and Girin, L. and Badeau, R.},
  Booktitle                = {Workshop on Applications of Signal Processing to Audio and Acoustics (WASPAA)},
  Year                     = {2017},

  Owner                    = {mafontai},
  Timestamp                = {2017.09.15}
}

@InProceedings{fontaine2017scalable,
  Title                    = {SCALABLE SOURCE LOCALIZATION WITH MULTICHANNEL $\alpha$-STABLE DISTRIBUTIONS},
  Author                   = {Fontaine, M.and Vanwynsberghe, C. and Liutkus, A. and Badeau, R.},
  Booktitle                = {25th European Signal Processing Conference (EUSIPCO 2017)},
  Year                     = {2017}
}

@Article{gannot2001signal,
  Title                    = {Signal enhancement using beamforming and nonstationarity with applications to speech},
  Author                   = {Gannot, S. and Burshtein, D. and Weinstein, E.},
  Journal                  = IEEE_J_SP,
  Year                     = {2001},
  Number                   = {8},
  Pages                    = {1614--1626},
  Volume                   = {49},

  Owner                    = {mafontai},
  Publisher                = {IEEE},
  Timestamp                = {2018.01.18}
}

@Article{goodman1963statistical,
  Title                    = {Statistical analysis based on a certain multivariate complex Gaussian distribution (an introduction)},
  Author                   = {Goodman, N. R.},
  Journal                  = {The Annals of mathematical statistics},
  Year                     = {1963},
  Number                   = {1},
  Pages                    = {152--177},
  Volume                   = {34},

  Publisher                = {JSTOR}
}

@Article{greenberg1993intelligibility,
  Title                    = {Intelligibility-weighted measures of speech-to-interference ratio and speech system performance},
  Author                   = {Greenberg, JE and Peterson, PM and Zurek, PM},
  Journal                  = {The Journal of the Acoustical Society of America},
  Year                     = {1993},
  Number                   = {5},
  Pages                    = {3009--3010},
  Volume                   = {94},

  Publisher                = {ASA}
}

@InProceedings{hirsch2000aurora,
  Title                    = {The Aurora experimental framework for the performance evaluation of speech recognition systems under noisy conditions},
  Author                   = {Hirsch, H. and Pearce, D.},
  Booktitle                = {ASR2000-Automatic Speech Recognition: Challenges for the new Millenium ISCA Tutorial and Research Workshop (ITRW)},
  Year                     = {2000}
}

@InProceedings{leglaive2017alpha,
  Title                    = {Alpha-Stable Multichannel Audio Source Separation},
  Author                   = {Leglaive, S and Simsekli, U and Liutkus, A and Badeau, R and Richard, G},
  Booktitle                = {42nd International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
  Year                     = {2017}
}

@InProceedings{liutkus2015generalized,
  Title                    = {Generalized {W}iener filtering with fractional power spectrograms},
  Author                   = {Liutkus, A. and Badeau, R.},
  Booktitle                = {International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
  Year                     = {2015},
  Organization             = {IEEE},
  Pages                    = {266--270},

  Owner                    = {mafontai},
  Timestamp                = {2016.05.17}
}

@Article{liutkus2011gaussian,
  Title                    = {Gaussian processes for underdetermined source separation},
  Author                   = {Liutkus, A. and Badeau, R. and Richard, G.},
  Journal                  = IEEE_J_SP,
  Year                     = {2011},
  Number                   = {7},
  Pages                    = {3155--3167},
  Volume                   = {59},

  __markedentry            = {[mafontai:1]},
  Owner                    = {mafontai},
  Publisher                = {IEEE},
  Timestamp                = {2016.07.22}
}

@Book{loizou2013speech,
  Title                    = {Speech enhancement: theory and practice},
  Author                   = {Loizou, P.C.},
  Publisher                = {CRC press},
  Year                     = {2013}
}

@Article{masry1984spectral,
  Title                    = {Spectral density estimation for stationary stable processes},
  Author                   = {Masry, E. and Cambanis, S.},
  Journal                  = {Stochastic processes and their applications},
  Year                     = {1984},
  Number                   = {1},
  Pages                    = {1--31},
  Volume                   = {18},

  Publisher                = {Elsevier}
}

@Article{mohammadiha2013supervised,
  Title                    = {Supervised and unsupervised speech enhancement using nonnegative matrix factorization},
  Author                   = {Mohammadiha, N. and Smaragdis, P. and Leijon, A.},
  Journal                  = IEEE_J_ASLP,
  Year                     = {2013},
  Number                   = {10},
  Pages                    = {2140--2151},
  Volume                   = {21},

  Publisher                = {IEEE}
}

@Book{nikias1995signal,
  Title                    = {Signal processing with alpha-stable distributions and applications},
  Author                   = {Nikias, C.L. and Shao, M.},
  Publisher                = {Wiley},
  Year                     = {1995},
  Series                   = {Adaptive and learning systems for signal processing, communications, and control},

  __markedentry            = {[mafontai:1]},
  ISBN                     = {9780471106470},
  Lccn                     = {lc95001482},
  Owner                    = {mafontai},
  Timestamp                = {2016.07.23},
  Url                      = {https://books.google.fr/books?id=qgBTAAAAMAAJ}
}

@InProceedings{nugraha2016multichannel,
  Title                    = {Multichannel music separation with deep neural networks},
  Author                   = {Nugraha, A. A. and Liutkus, A. and Vincent, E.},
  Booktitle                = {Signal Processing Conference (EUSIPCO), 2016 24th European},
  Year                     = {2016},
  Organization             = {IEEE},
  Pages                    = {1748--1752},

  Owner                    = {mafontai},
  Timestamp                = {2018.02.01}
}

@InProceedings{panayotov2015librispeech,
  Title                    = {Librispeech: an ASR corpus based on public domain audio books},
  Author                   = {Panayotov, V. and Chen, G. and Povey, D. and Khudanpur, S.},
  Booktitle                = {Acoustics, Speech and Signal Processing (ICASSP), 2015 IEEE International Conference on},
  Year                     = {2015},
  Organization             = {IEEE},
  Pages                    = {5206--5210},

  Owner                    = {mafontai},
  Timestamp                = {2018.02.02}
}

@Book{rasmussen2006gaussian,
  Title                    = {Gaussian processes for machine learning},
  Author                   = {Rasmussen, Carl Edward and Williams, Christopher KI},
  Publisher                = {MIT press Cambridge},
  Year                     = {2006},
  Volume                   = {1}
}

@Book{samoradnitsky1994stable,
  Title                    = {Stable non-{G}aussian random processes: stochastic models with infinite variance},
  Author                   = {Samoradnitsky, G. and Taqqu, M.},
  Publisher                = {CRC Press},
  Year                     = {1994},
  Volume                   = {1},

  __markedentry            = {[mafontai:3]},
  Owner                    = {mafontai},
  Timestamp                = {2017.10.02}
}

@InProceedings{sawada2012efficient,
  Title                    = {Efficient algorithms for multichannel extensions of Itakura-Saito nonnegative matrix factorization},
  Author                   = {Sawada, Hiroshi and Kameoka, Hirokazu and Araki, Shoko and Ueda, Naonori},
  Booktitle                = {International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
  Year                     = {2012},
  Organization             = {IEEE},
  Pages                    = {261--264},

  Owner                    = {mafontai},
  Timestamp                = {2018.01.16}
}

@InProceedings{scalart1996speech,
  Title                    = {Speech enhancement based on a priori signal to noise estimation},
  Author                   = {Scalart, P. and others},
  Booktitle                = {Acoustics, Speech, and Signal Processing, 1996. ICASSP-96. Conference Proceedings., 1996 IEEE International Conference on},
  Year                     = {1996},
  Organization             = {IEEE},
  Pages                    = {629--632},
  Volume                   = {2},

  Owner                    = {mafontai},
  Timestamp                = {2018.01.18}
}

@Book{seber2012linear,
  Title                    = {Linear regression analysis},
  Author                   = {Seber, George AF and Lee, Alan J},
  Publisher                = {John Wiley \& Sons},
  Year                     = {2012},
  Volume                   = {936}
}

@Article{serizel2014low,
  Title                    = {Low-rank approximation based multichannel Wiener filter algorithms for noise reduction with application in cochlear implants},
  Author                   = {Serizel, R. and Moonen, M. and Van Dijk, B. and Wouters, J.},
  Journal                  = {IEEE/ACM Transactions on Audio, Speech, and Language Processing},
  Year                     = {2014},
  Number                   = {4},
  Pages                    = {785--799},
  Volume                   = {22},

  Publisher                = {IEEE}
}

@Article{sun2015speech,
  Title                    = {Speech enhancement under low {SNR} conditions via noise estimation using sparse and low-rank {NMF} with Kullback--Leibler divergence},
  Author                   = {Sun, M. and Li, Y. and Gemmeke, J. F. and Zhang, X.},
  Journal                  = IEEE_J_ASLP,
  Year                     = {2015},
  Number                   = {7},
  Pages                    = {1233--1242},
  Volume                   = {23},

  Publisher                = {IEEE Press}
}

@Article{thomas2014polarization,
  Title                    = {A polarization identity for multilinear maps},
  Author                   = {Thomas, E. GF},
  Journal                  = {Indagationes Mathematicae},
  Year                     = {2014},
  Number                   = {3},
  Pages                    = {468--474},
  Volume                   = {25},

  Publisher                = {Elsevier}
}

@Book{unser2014introduction,
  Title                    = {An introduction to sparse stochastic processes},
  Author                   = {Unser, M. and Tafti, P.D.},
  Publisher                = {Cambridge University Press},
  Year                     = {2014}
}

@Article{van2009speech,
  Title                    = {Speech enhancement with multichannel {W}iener filter techniques in multimicrophone binaural hearing aids},
  Author                   = {Van den Bogaert, T. and Doclo, S. and Wouters, J. and Moonen, M.},
  Journal                  = {The Journal of the Acoustical Society of America},
  Year                     = {2009},
  Number                   = {1},
  Pages                    = {360--371},
  Volume                   = {125},

  Publisher                = {ASA}
}

@Article{van1988beamforming,
  Title                    = {Beamforming: A versatile approach to spatial filtering},
  Author                   = {Van Veen, B. D and Buckley, K. M},
  Journal                  = {IEEE assp magazine},
  Year                     = {1988},
  Number                   = {2},
  Pages                    = {4--24},
  Volume                   = {5},

  Publisher                = {IEEE}
}

@Article{vaughan1970nonrecursive,
  Title                    = {A nonrecursive algebraic solution for the discrete {R}iccati equation},
  Author                   = {Vaughan, D},
  Journal                  = IEEE_J_AC,
  Year                     = {1970},
  Number                   = {5},
  Pages                    = {597--599},
  Volume                   = {15},

  Owner                    = {mafontai},
  Publisher                = {IEEE},
  Timestamp                = {2018.01.17}
}

@Article{vincent2006performance,
  Title                    = {Performance measurement in blind audio source separation},
  Author                   = {Vincent, E. and Gribonval, R. and F{\'e}votte, C.},
  Journal                  = {IEEE transactions on audio, speech, and language processing},
  Year                     = {2006},
  Number                   = {4},
  Pages                    = {1462--1469},
  Volume                   = {14},

  Publisher                = {IEEE}
}

@InProceedings{yoshii2016student,
  Title                    = {Student's t nonnegative matrix factorization and positive semidefinite tensor factorization for single-channel audio source separation},
  Author                   = {Yoshii, K. and Itoyama, K. and Goto, M.},
  Booktitle                = {International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
  Year                     = {2016},
  Organization             = {IEEE},
  Pages                    = {51--55}
}

@comment{jabref-meta: databaseType:bibtex;}

repository: ANR-kamoulox/denoise-alphamf

repo_name: ANR-kamoulox/denoise-alphamf


text:
@article{DBLP:journals/tvcg/DengWCLWBZW20,
  author    = {Zikun Deng and
               Di Weng and
               Jiahui Chen and
               Ren Liu and
               Zhibin Wang and
               Jie Bao and
               Yu Zheng and
               Yingcai Wu},
  title     = {AirVis: Visual Analytics of Air Pollution Propagation},
  journal   = {{IEEE} Trans. Vis. Comput. Graph.},
  volume    = {26},
  number    = {1},
  pages     = {800--810},
  year      = {2020},
  url       = {https://doi.org/10.1109/TVCG.2019.2934670},
  doi       = {10.1109/TVCG.2019.2934670},
  timestamp = {Sat, 30 May 2020 19:48:02 +0200},
  biburl    = {https://dblp.org/rec/journals/tvcg/DengWCLWBZW20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

repository: zkrain/academic-kickstart

repo_name: zkrain/academic-kickstart


text:
@INPROCEEDINGS{Zeqiu2021,
	author = {Zeqiu Wu, Bo-Ru Lu, Hannaneh Hajishirzi, Mari Ostendorf},
	title = {DIALKI: Knowledge Identification in Conversational Systems throughDialogue-Document Contextualization},
	booktitle = {Proc. Conf. Empirical Methods Natural Language Process. (EMNLP)},
	year = {2021},
  pdf = {},
	codes = {https://github.com/ellenmellon/DIALKI},
}

gha_language: HTML


text:
// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vtrace_test

import (
	"bytes"
	"encoding/binary"
	"testing"
	"time"

	"v.io/v23/uniqueid"
	"v.io/v23/vtrace"
)

var nextid = uint64(1)

func id() uniqueid.Id {
	var out uniqueid.Id
	binary.BigEndian.PutUint64(out[8:], nextid)
	nextid++
	return out
}

func TestFormat(t *testing.T) {
	trid := id()
	trstart := time.Date(2014, 11, 6, 13, 1, 22, 400000000, time.UTC)
	spanIDs := make([]uniqueid.Id, 6)
	for i := range spanIDs {
		spanIDs[i] = id()
	}
	tr := vtrace.TraceRecord{
		Id: trid,
		Spans: []vtrace.SpanRecord{
			{
				Id:     spanIDs[0],
				Parent: trid,
				Name:   "",
				Start:  trstart,
			},
			{
				Id:     spanIDs[1],
				Parent: spanIDs[0],
				Name:   "Child1",
				Start:  trstart.Add(time.Second),
				End:    trstart.Add(10 * time.Second),
			},
			{
				Id:     spanIDs[2],
				Parent: spanIDs[0],
				Name:   "Child2",
				Start:  trstart.Add(20 * time.Second),
				End:    trstart.Add(30 * time.Second),
			},
			{
				Id:              spanIDs[3],
				Parent:          spanIDs[0],
				Name:            "Child2WithMetadata",
				Start:           trstart.Add(20 * time.Second),
				End:             trstart.Add(30 * time.Second),
				RequestMetadata: []byte{0x01, 0x02},
			},
			{
				Id:              spanIDs[4],
				Parent:          spanIDs[0],
				Name:            "Child2WithLongMetadata",
				Start:           trstart.Add(20 * time.Second),
				End:             trstart.Add(30 * time.Second),
				RequestMetadata: bytes.Repeat([]byte{0x01, 0x02}, 20),
				Annotations: []vtrace.Annotation{
					{
						Message: "First Annotation",
						When:    trstart.Add(4 * time.Second),
					},
				},
			},
			{
				Id:     spanIDs[5],
				Parent: spanIDs[1],
				Name:   "GrandChild1",
				Start:  trstart.Add(3 * time.Second),
				End:    trstart.Add(8 * time.Second),
				Annotations: []vtrace.Annotation{
					{
						Message: "First Annotation",
						When:    trstart.Add(4 * time.Second),
					},
					{
						Message: "Second Annotation",
						When:    trstart.Add(6 * time.Second),
					},
				},
			},
		},
	}

	var buf bytes.Buffer
	vtrace.FormatTrace(&buf, &tr, time.UTC)
	want := `Trace - 0x00000000000000000000000000000001 (2014-11-06 13:01:22.400000 UTC, ??)
    Span - Child1 [id: 00000003 parent 00000002] (1s, 10s: 9s)
        Span - GrandChild1 [id: 00000007 parent 00000003] (3s, 8s: 5s)
            @4s First Annotation
            @6s Second Annotation
    Span - Child2 [id: 00000004 parent 00000002] (20s, 30s: 10s)
    Span - Child2WithMetadata [id: 00000005 parent 00000002] (20s, 30s: 10s)
        [0x0102]
    Span - Child2WithLongMetadata [id: 00000006 parent 00000002] (20s, 30s: 10s)
        @4s First Annotation
        [0x01020102010201020102]
`
	if got := buf.String(); got != want {
		t.Errorf("Incorrect output, want\n%sgot\n%s", want, got)
	}
}

func TestFormatWithMissingSpans(t *testing.T) {
	trid := id()
	trstart := time.Date(2014, 11, 6, 13, 1, 22, 400000000, time.UTC)
	spanIDs := make([]uniqueid.Id, 6)
	for i := range spanIDs {
		spanIDs[i] = id()
	}
	tr := vtrace.TraceRecord{
		Id: trid,
		Spans: []vtrace.SpanRecord{
			{
				Id:     spanIDs[0],
				Parent: trid,
				Name:   "",
				Start:  trstart,
			},
			{
				Id:     spanIDs[1],
				Parent: spanIDs[0],
				Name:   "Child1",
				Start:  trstart.Add(time.Second),
				End:    trstart.Add(10 * time.Second),
			},
			{
				Id:     spanIDs[3],
				Parent: spanIDs[2],
				Name:   "Decendant2",
				Start:  trstart.Add(15 * time.Second),
				End:    trstart.Add(24 * time.Second),
			},
			{
				Id:     spanIDs[4],
				Parent: spanIDs[2],
				Name:   "Decendant1",
				Start:  trstart.Add(12 * time.Second),
				End:    trstart.Add(18 * time.Second),
			},
			{
				Id:     spanIDs[5],
				Parent: spanIDs[1],
				Name:   "GrandChild1",
				Start:  trstart.Add(3 * time.Second),
				End:    trstart.Add(8 * time.Second),
				Annotations: []vtrace.Annotation{
					{
						Message: "Second Annotation",
						When:    trstart.Add(6 * time.Second),
					},
					{
						Message: "First Annotation",
						When:    trstart.Add(4 * time.Second),
					},
				},
			},
		},
	}

	var buf bytes.Buffer
	vtrace.FormatTrace(&buf, &tr, time.UTC)
	want := `Trace - 0x00000000000000000000000000000008 (2014-11-06 13:01:22.400000 UTC, ??)
    Span - Child1 [id: 0000000a parent 00000009] (1s, 10s: 9s)
        Span - GrandChild1 [id: 0000000e parent 0000000a] (3s, 8s: 5s)
            @4s First Annotation
            @6s Second Annotation
    Span - Missing Data [id: 00000000 parent 00000000] (??, ??: ??)
        Span - Decendant1 [id: 0000000d parent 0000000b] (12s, 18s: 6s)
        Span - Decendant2 [id: 0000000c parent 0000000b] (15s, 24s: 9s)
`

	if got := buf.String(); got != want {
		t.Errorf("Incorrect output, want\n%sgot\n%s", want, got)
	}
}

repository: vanadium/core

repo_name: vanadium/core

branch_name: refs/heads/main


text:
SUMMARY = "Support for the Linux 2.6.x ALSA Sound System"
SECTION = "devel/python"
LICENSE = "PSF"
LIC_FILES_CHKSUM = "file://LICENSE;md5=1a3b161aa0fcec32a0c8907a2219ad9d"

SRC_URI[md5sum] = "1f22415a3d8da4b303182ad81c2d062e"
SRC_URI[sha256sum] = "b6df486f1c4035041a5f3800496b86c64e48e4a7d47f94dcbca11b0187aa3a15"

DEPENDS += "alsa-lib"

inherit pypi distutils

RDEPENDS_${PN} += "alsa-lib"

repository: klihub/meta-openembedded

repo_name: klihub/meta-openembedded


text:
DESCRIPTION = "TI Codecs for DM355"
HOMEPAGE = "http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent"
SECTION = "multimedia"
LICENSE = "TI"

# TODO :: Move to common .inc

PV = "1_13_000"

SRC_URI[dm355codecsbin.md5sum] = "f6221188bea76b7aaf0c45e9bcf26329"
SRC_URI[dm355codecsbin.sha256sum] = "f1a6dea51be9798903a0543fb50f463b0594b1f11b897bc50e40825fb7527c61"

PR = "r17"

require ti-paths.inc
require ti-staging.inc
require ti-eula-unpack.inc

PROVIDES += "ti-codecs-dm355-server"

S = "${WORKDIR}/dm355_codecs_${PV}"

SRC_URI = "http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/dvsdk/codecs/${BINFILE};name=dm355codecsbin \
           file://mapdmaq \
"

BINFILE = "dm355_codecs_setuplinux_${PV}.bin"
TI_BIN_UNPK_CMDS = "y:Y: qY:workdir"

do_compile() {
    echo "Do Nothing"
}

do_install() {

    install -d ${D}/${installdir}/ti-codecs-server
    cd ${S}

    install -m 0755 ${WORKDIR}/mapdmaq ${D}/${installdir}/ti-codecs-server

    install -d ${D}${CODEC_INSTALL_DIR_RECIPE}
    cp -pPrf ${S}/* ${D}${CODEC_INSTALL_DIR_RECIPE}
}

PACKAGES += "ti-codecs-dm355-server"
FILES_ti-codecs-dm355-server = "${installdir}/ti-codecs-server/*"

INSANE_SKIP_ti-codecs-dm355-server = True

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
package buildkite

import (
	"fmt"

	"github.com/hashicorp/terraform/helper/schema"
	"github.com/hashicorp/terraform/terraform"
)

func Provider() terraform.ResourceProvider {
	return &schema.Provider{
		ResourcesMap: map[string]*schema.Resource{
			"buildkite_pipeline": resourcePipeline(),
		},

		Schema: map[string]*schema.Schema{
			"organization": &schema.Schema{
				Type:        schema.TypeString,
				Required:    true,
				DefaultFunc: schema.EnvDefaultFunc("BUILDKITE_ORGANIZATION", nil),
			},
			"api_token": &schema.Schema{
				Type:        schema.TypeString,
				Required:    true,
				DefaultFunc: schema.EnvDefaultFunc("BUILDKITE_API_TOKEN", nil),
			},
		},

		ConfigureFunc: providerConfigure,
	}
}

func providerConfigure(d *schema.ResourceData) (interface{}, error) {
	orgName := d.Get("organization").(string)
	apiToken := d.Get("api_token").(string)

	orgURLStr := fmt.Sprintf("https://api.buildkite.com/v2/organizations/%s/", orgName)
	return NewClient(orgURLStr, apiToken)
}

repository: yougroupteam/terraform-buildkite

repo_name: yougroupteam/terraform-buildkite

gha_license_id: MIT


text:
@article{pmid33686539,
 author = {Yano, Y.  and Niiranen, T. J. },
 journal = {Curr Hypertens Rep},
 month = {Mar},
 number = {3},
 pages = {15},
 title = {Gut Microbiome over a Lifetime and the Association with Hypertension},
 volume = {23},
 year = {2021}
}

repository: hypertensioncenter/academic-kickstart

repo_name: hypertensioncenter/academic-kickstart

gha_language: TeX


text:
@Misc{probprog2020instructions,
    title = {Formatting Instructions for {PROBPROG 2020} Abstracts},
    author = {Mansinghka, Vikash and Pfeffer, Avi and Tristan, Jean-Baptiste and van de Meent, Jan-Willem},
    year = {2020},
    howpublished = {\url{https://probprog.cc/2020/probprog-2020-style.zip}}
}

@article{arviz2019,
  title={ArviZ a unified library for exploratory analysis of Bayesian models in Python},
  author={Kumar, Ravin and Colin, C and Hartikainen, Ari and Martin, Osvaldo A},
  journal={J. Open Source Software},
  volume={4},
  pages={1143},
  year={2019},
  doi={10.21105/joss.01143}
}

@article{pymc32016,
  title={Probabilistic programming in Python using PyMC3},
  author={Salvatier, John and Wiecki, Thomas V and Fonnesbeck, Christopher},
  journal={PeerJ Computer Science},
  volume={2},
  pages={e55},
  year={2016},
  publisher={PeerJ Inc.}
}

@article{pyro2018,
  author = {Bingham, Eli and Chen, Jonathan P. and Jankowiak, Martin and Obermeyer, Fritz and
            Pradhan, Neeraj and Karaletsos, Theofanis and Singh, Rohit and Szerlip, Paul and
            Horsfall, Paul and Goodman, Noah D.},
  title = {{Pyro: Deep Universal Probabilistic Programming}},
  journal = {arXiv preprint arXiv:1810.09538},
  year = {2018}
}

@article{emcee2013,
  title={emcee: the MCMC hammer},
  author={Foreman-Mackey, Daniel and Hogg, David W and Lang, Dustin and Goodman, Jonathan},
  journal={Publications of the Astronomical Society of the Pacific},
  volume={125},
  number={925},
  pages={306},
  year={2013},
  publisher={IOP Publishing}
}

@article{emcee2019,
  title={emcee v3: A Python ensemble sampling toolkit for affine-invariant MCMC},
  author={Foreman-Mackey, Daniel and Farr, Will M and Sinha, Manodeep and Archibald, Anne M and Hogg, David W and Sanders, Jeremy S and Zuntz, Joe and Val-Borro, Tobias Erhardt and Pashchenko, Ilya and Abril Pla, Oriol},
  journal={Journal of Open Source Software},
  year={2019},
  doi={https://doi.org/10.21105/joss.01864}
}

@misc{stan2018language,
  title={Stan Modeling Language Users Guide and Reference Manual},
  author={{Stan Development Team}},
  year={2018},
  howpublished={\url{http://mc-stan.org}}
}

@misc{stan2018math,
  title={The Stan Math Library},
  author={{Stan Development Team}},
  year={2018},
  howpublished={\url{http://mc-stan.org}}
}

@misc{stan2018core,
  title={The Stan Core Library},
  author={{Stan Development Team}},
  year={2018},
  howpublished={\url{http://mc-stan.org}}
}

@misc{pystan2018,
  title={PyStan: the Python interface to Stan},
  author={{Stan Development Team}},
  year={2018},
  howpublished={\url{http://mc-stan.org}}
}

@misc{cmdstan2018,
  title={CmdStan: the command-line interface to Stan},
  author={Stan Development Team},
  year={2018},
  howpublished={\url{http://mc-stan.org}}
}

@article{tensorflow_probability2017,
  title={Tensorflow distributions},
  author={Dillon, Joshua V and Langmore, Ian and Tran, Dustin and Brevdo, Eugene and Vasudevan, Srinivas and Moore, Dave and Patton, Brian and Alemi, Alex and Hoffman, Matt and Saurous, Rif A},
  journal={arXiv preprint arXiv:1711.10604},
  year={2017}
}

@article{unidata2011network,
  title={Network Common Data Form (netCDF)},
  author={Unidata},
  year={2011},
  doi={10.5065/D6H70CW6}
}

@article{hoyer2017xarray,
  title     = {xarray: {N-D} labeled arrays and datasets in {Python}},
  author    = {Hoyer, S. and J. Hamman},
  journal   = {Journal of Open Research Software},
  volume    = {5},
  number    = {1},
  year      = {2017},
  publisher = {Ubiquity Press},
  doi       = {10.5334/jors.148},
  url       = {http://doi.org/10.5334/jors.148}
}

@article{gelman1992rhat,
  title={A single series from the Gibbs sampler provides a false sense of security},
  author={Gelman, Andrew and Rubin, Donald B},
  journal={Bayesian statistics},
  volume={4},
  pages={625--631},
  year={1992},
  publisher={Oxford University Press Oxford,, UK}
}

@article{watanabe2010waic,
  title={Asymptotic equivalence of Bayes cross validation and widely applicable information criterion in singular learning theory},
  author={Watanabe, Sumio},
  journal={Journal of Machine Learning Research},
  volume={11},
  number={Dec},
  pages={3571--3594},
  year={2010}
}

@book{gelman2013bayesian,
  title={Bayesian data analysis},
  author={Gelman, Andrew and Carlin, John B and Stern, Hal S and Dunson, David B and Vehtari, Aki and Rubin, Donald B},
  year={2013},
  publisher={Chapman and Hall/CRC},
  address = {New York, NY, USA},
  doi={10.1201/b16018}
}

@inproceedings{lam2015numba,
  author = {Lam, Siu Kwan and Pitrou, Antoine and Seibert, Stanley},
  title = {Numba: A LLVM-Based Python JIT Compiler},
  year = {2015},
  isbn = {9781450340052},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/2833157.2833162},
  doi = {10.1145/2833157.2833162},
  booktitle = {Proceedings of the Second Workshop on the LLVM Compiler Infrastructure in HPC},
  articleno = {Article 7},
  numpages = {6},
  keywords = {LLVM, Python, compiler},
  location = {Austin, Texas},
  series = {LLVM '15}
}

@article{vehtari2019rank,
  title={Rank-normalization, folding, and localization: An improved $\widehat{R}$ for assessing convergence of MCMC},
  author={Vehtari, Aki and Gelman, Andrew and Simpson, Daniel and Carpenter, Bob and B{\"u}rkner, Paul-Christian},
  journal={arXiv preprint arXiv:1903.08008},
  year={2019}
}

@article{betancourt2016diagnosing,
  title={Diagnosing suboptimal cotangent disintegrations in Hamiltonian Monte Carlo},
  author={Betancourt, Michael},
  journal={arXiv preprint arXiv:1604.00695},
  year={2016}
}

@book{geweke1991evaluating,
  title={Evaluating the accuracy of sampling-based approaches to the calculation of posterior moments},
  author={Geweke, John},
  volume={196},
  year={1991},
  publisher={Federal Reserve Bank of Minneapolis, Research Department Minneapolis, MN},
  address={Minneapolis}
}

@article{vehtari2017practical,
  title={Practical Bayesian model evaluation using leave-one-out cross-validation and WAIC},
  author={Vehtari, Aki and Gelman, Andrew and Gabry, Jonah},
  journal={Statistics and computing},
  volume={27},
  number={5},
  pages={1413--1432},
  year={2017},
  publisher={Springer}
}

@article{vehtari2015pareto,
  title={Pareto smoothed importance sampling},
  author={Vehtari, Aki and Gelman, Andrew and Gabry, Jonah},
  journal={arXiv preprint arXiv:1507.02646},
  year={2015}
}

@article{gabry2019visualization,
  title={Visualization in Bayesian workflow},
  author={Gabry, Jonah and Simpson, Daniel and Vehtari, Aki and Betancourt, Michael and Gelman, Andrew},
  journal={Journal of the Royal Statistical Society: Series A (Statistics in Society)},
  volume={182},
  number={2},
  pages={389--402},
  year={2019},
  publisher={Wiley Online Library}
}

@article{gelman2014understanding,
  title={Understanding predictive information criteria for Bayesian models},
  author={Gelman, Andrew and Hwang, Jessica and Vehtari, Aki},
  journal={Statistics and computing},
  volume={24},
  number={6},
  pages={997--1016},
  year={2014},
  publisher={Springer}
}

@Article{Hunter2007matplotlib,
  Author    = {Hunter, J. D.},
  Title     = {Matplotlib: A 2D graphics environment},
  Journal   = {Computing in Science \& Engineering},
  Volume    = {9},
  Number    = {3},
  Pages     = {90--95},
  abstract  = {Matplotlib is a 2D graphics package used for Python for
  application development, interactive scripting, and publication-quality
  image generation across user interfaces and operating systems.},
  publisher = {IEEE COMPUTER SOC},
  doi       = {10.1109/MCSE.2007.55},
  year      = 2007
}

@article{bokeh,
title = {Bokeh: Python library for interactive visualization},
author = {{Bokeh Development Team}},
year = {2019},
url = {https://bokeh.org/},
}

gha_language: Jupyter Notebook


text:
@proceedings{SRSM19,
author={Sharma, Shubham and  Roy, Subhajit and  Soos, Mate and Meel, Kuldeep S.},
title={GANAK: A Scalable Probabilistic Exact Model Counter},
year={2019},
booktitle={Proceedings of International Joint Conference on Artificial Intelligence (IJCAI)}
}

repository: meelgroup/meelgroup-website

repo_name: meelgroup/meelgroup-website


text:
@article{Zahmatkesh-2021-Understanding,
    title = "Understanding Uncertainty in Probabilistic Floodplain Mapping in the Time of Climate Change",
    author = "Zahmatkesh, Zahra  and
      Han, Shasha  and
      Coulibaly, Paulin",
    journal = "Water, Volume 13, Issue 9",
    volume = "13",
    number = "9",
    year = "2021",
    publisher = "MDPI AG",
    url = "https://aclanthology.org/G21-149001",
    doi = "10.3390/w13091248",
    pages = "1248",
    abstract = "An integrated framework was employed to develop probabilistic floodplain maps, taking into account hydrologic and hydraulic uncertainties under climate change impacts. To develop the maps, several scenarios representing the individual and compounding effects of the models{'} input and parameters uncertainty were defined. Hydrologic model calibration and validation were performed using a Dynamically Dimensioned Search algorithm. A generalized likelihood uncertainty estimation method was used for quantifying uncertainty. To draw on the potential benefits of the proposed methodology, a flash-flood-prone urban watershed in the Greater Toronto Area, Canada, was selected. The developed floodplain maps were updated considering climate change impacts on the input uncertainty with rainfall Intensity{--}Duration{--}Frequency (IDF) projections of RCP8.5. The results indicated that the hydrologic model input poses the most uncertainty to floodplain delineation. Incorporating climate change impacts resulted in the expansion of the potential flood area and an increase in water depth. Comparison between stationary and non-stationary IDFs showed that the flood probability is higher when a non-stationary approach is used. The large inevitable uncertainty associated with floodplain mapping and increased future flood risk under climate change imply a great need for enhanced flood modeling techniques and tools. The probabilistic floodplain maps are beneficial for implementing risk management strategies and land-use planning.",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications


text:
// Fetch DHCP pool stats from a Mikrotik router
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"github.com/Netwurx/routeros-api-go"
	"os"
	"strconv"
	"strings"
)

type jsError struct {
	Error string
}

type PoolStat struct {
	Interface string
	Used      int
	Size      int
}

func jserror(msg string) {
	e := jsError{msg}
	m, err := json.Marshal(e)
	if err != nil {
		panic(err)
	}
	os.Stderr.Write(m)
	os.Exit(1)
}

type IPRange struct {
	Min string
	Max string
}

// Get addresses assigned to pool
func getPoolUsed(r *routeros.Client, pool string) ([]string, error) {
	var addrs []string

	var q routeros.Query
	q.Pairs = append(q.Pairs, routeros.Pair{Key: "pool", Value: pool, Op: "="})
	q.Proplist = []string{".id,address"}
	res, err := r.Query("/ip/pool/used/print", q)
	if err != nil {
		return addrs, err
	}

	for _, s := range res.SubPairs {
		addrs = append(addrs, s["address"])
	}

	return addrs, nil
}

// Get settings for named IP Pool
func getPoolRange(r *routeros.Client, pool string) ([]IPRange, error) {
	var ranges []IPRange

	var q routeros.Query
	q.Pairs = append(q.Pairs, routeros.Pair{Key: "name", Value: pool, Op: "="})
	q.Proplist = []string{".id,ranges"}
	res, err := r.Query("/ip/pool/print", q)
	if err != nil {
		return ranges, err
	}

	// no results so bail
	if len(res.SubPairs) == 0 {
		return ranges, nil
	}

	sp := res.SubPairs[0]

	// no ranges defined so bail
	if sp["ranges"] == "" {
		return ranges, nil
	}

	for _, p := range strings.Split(sp["ranges"], ",") {
		var ipr IPRange
		rng := strings.Split(p, "-")
		ipr.Min = rng[0]
		ipr.Max = rng[1]
		ranges = append(ranges, ipr)
	}

	return ranges, nil
}

func usage() {
	fmt.Fprintf(os.Stderr, "usage: %s [options] router-address\n", os.Args[0])
	fmt.Fprintln(os.Stderr, "Login credentials must be set as environment variables")
	fmt.Fprintln(os.Stderr, "Username in MT_USERNAME")
	fmt.Fprintln(os.Stderr, "Password in MT_PASSWORD")
	flag.PrintDefaults()
	os.Exit(2)
}

func main() {
	flag.Usage = usage
	js := false
	flag.BoolVar(&js, "json", false, "display output in json format")
	port := 8729
	flag.IntVar(&port, "port", 8728, "RouterOS API port number")
	flag.Parse()

	// check for host
	args := flag.Args()
	if len(args) != 1 {
		usage()
	}
	host := args[0]

	// check for login credentials
	username := os.Getenv("MT_USERNAME")
	if username == "" {
		if js {
			jserror("MT_USERNAME is empty or not set")
		}
		fmt.Fprintln(os.Stderr, "Error: MT_USERNAME is empty or not set")
		usage()
	}

	// don't check for password because missing password is valid (just not good)
	password := os.Getenv("MT_PASSWORD")

	// try to connect to router
	hp := host + ":" + strconv.Itoa(port)
	r, err := routeros.New(hp)
	if err != nil {
		if js {
			jserror("Invalid address for router")
		}
		fmt.Fprintf(os.Stderr, "Invalid address for router: %s\n", err)
		os.Exit(1)
	}
	err = r.Connect(username, password)
	if err != nil {
		if js {
			jserror("Error connecting to router")
		}
		fmt.Fprintf(os.Stderr, "Error connecting to router: %s\n", err)
		os.Exit(1)
	}

	// get all dhcp servers
	var dsQ routeros.Query
	dsQ.Pairs = append(dsQ.Pairs, routeros.Pair{Key: "disabled", Value: "no", Op: "="})
	dsQ.Proplist = []string{".id,address-pool,interface"}
	res, err := r.Query("/ip/dhcp-server/getall", dsQ)
	if err != nil {
		if js {
			jserror("Error fetching list of dhcp interfaces from router")
		}
		fmt.Fprintf(os.Stderr, "Error fetching list of dhcp interfaces: %s\n", err)
		os.Exit(1)
	}

	if !js {
		fmt.Println("Interface\tUsed\tFree")
	}
	var pools []PoolStat
	for _, pair := range res.SubPairs {
		var p PoolStat
		p.Interface = pair["interface"]

		// get pool range, find matching subnet
		poolName := pair["address-pool"]
		if poolName == "" {
			continue // no pool so we can't do any sizing
		}

		pool, err := getPoolRange(r, poolName)
		if err != nil {
			if js {
				jserror("Error fetching pool information for pool " + poolName)
			}
			fmt.Fprintf(os.Stderr, "Error fetching pool information: %s\n", err)
			os.Exit(1)
		}

		// calculate size of pool. we don't need cidr math because crossing .0 and .255 leads to
		// user issues so nobody uses those addrs
		size := 0
		for _, l := range pool {
			minparts := strings.Split(l.Min, ".")
			min, _ := strconv.Atoi(minparts[3])
			maxparts := strings.Split(l.Max, ".")
			max, _ := strconv.Atoi(maxparts[3])

			size += max - min
		}
		p.Size = size

		used, err := getPoolUsed(r, poolName)
		if err != nil {
			if js {
				jserror("Error fetching pool usage for pool " + poolName)
			}
			fmt.Fprintf(os.Stderr, "Error fetching pool usage for pool %s: %s\n", poolName, err)
			os.Exit(1)
		}
		p.Used = len(used)

		if !js {
			fmt.Printf("%s\t%12d\t%4d\n", p.Interface, p.Used, (p.Size - p.Used))
		}

		pools = append(pools, p)
	}

	if js {
		j, err := json.Marshal(pools)
		if err != nil {
			jserror("Error encoding json representation of pools")
		}
		fmt.Printf("%s", j)
	}
	/*
		what i was going to do before stopping for sleep:
		loop through pools, check usage, return info, append to PoolStats
		after that we format stuff for output to user
	*/
}

repository: jda/mt-dhcpstat

repo_name: jda/mt-dhcpstat


text:
SUMMARY = "IO App"
DESCRIPTION = "IO application for accessing memory-mapped IO regions on the BMC"

inherit cmake

LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM += "\
    file://io-app.c;beginline=2;endline=14;md5=639666a0bf40bb717b46b378297eeceb \
    "

SRC_URI = "\
    file://CMakeLists.txt;subdir=${BP} \
    file://io-app.c;subdir=${BP} \
    "


text:
package sgf

import (
	"testing"

	models "github.com/thewizardplusplus/go-atari-models"
)

func TestEncodeColor(test *testing.T) {
	type args struct {
		color models.Color
	}
	type data struct {
		args args
		want byte
	}

	for _, data := range []data{
		{
			args: args{models.Black},
			want: 'B',
		},
		{
			args: args{models.White},
			want: 'W',
		},
	} {
		got := EncodeColor(data.args.color)

		if got != data.want {
			test.Fail()
		}
	}
}

func TestEncodeAxis(test *testing.T) {
	type args struct {
		axis int
	}
	type data struct {
		args       args
		wantSymbol byte
		wantPanic  bool
	}

	for _, data := range []data{
		{
			args:       args{4},
			wantSymbol: 'e',
			wantPanic:  false,
		},
		{
			args:       args{30},
			wantSymbol: 'E',
			wantPanic:  false,
		},
		{
			args:       args{-1},
			wantSymbol: 0,
			wantPanic:  true,
		},
	} {
		var gotSymbol byte
		var hasPanic bool
		func() {
			defer func() {
				if err := recover(); err != nil {
					hasPanic = true
				}
			}()

			gotSymbol = EncodeAxis(data.args.axis)
		}()

		if gotSymbol != data.wantSymbol {
			test.Fail()
		}
		if hasPanic != data.wantPanic {
			test.Fail()
		}
	}
}

func TestEncodePoint(test *testing.T) {
	type args struct {
		point models.Point
	}
	type data struct {
		args      args
		wantText  string
		wantPanic bool
	}

	for _, data := range []data{
		{
			args: args{
				point: models.Point{
					Column: 4,
					Row:    30,
				},
			},
			wantText:  "eE",
			wantPanic: false,
		},
		{
			args: args{
				point: models.Point{
					Column: -1,
					Row:    4,
				},
			},
			wantText:  "",
			wantPanic: true,
		},
		{
			args: args{
				point: models.Point{
					Column: 4,
					Row:    -1,
				},
			},
			wantText:  "",
			wantPanic: true,
		},
	} {
		var gotText string
		var hasPanic bool
		func() {
			defer func() {
				if err := recover(); err != nil {
					hasPanic = true
				}
			}()

			gotText = EncodePoint(data.args.point)
		}()

		if gotText != data.wantText {
			test.Fail()
		}
		if hasPanic != data.wantPanic {
			test.Fail()
		}
	}
}

repository: thewizardplusplus/go-atari-models

repo_name: thewizardplusplus/go-atari-models


text:
@inproceedings{Guarese2023,
  author = {Renan Martins Guarese and Emma Jane Pretty and Haytham M. Fayek and Fabio Zambetta and Ron Van Schyndel},
  title = {Evoking Empathy with Visually Impaired People through an Augmented Reality Embodiment Experience},
  year = {2023},
  booktitle = {IEEE Virtual Reality (IEEEVR)},
}


text:
@Online{tableofvisions,
	author = {Table of Visions},
	title = {Corporate Crowdfunding Software – 100\%{} White Label},
	url = {https://tableofvisions.com/corporate-crowdfunding-software/},
	addendum = {(abgerufen am 08.07.2020)},
	keywords = {crowdfunding, corporate crowdfunding},
	year = {2020}
}

@Online{crowdfunding,
	author = {crowdfunding.de},
	title = {Wenn Firmen wie IBM und Audi ihre Mitarbeiter-Crowd einbinden - crowdfunding.de},
	url = {https://www.crowdfunding.de/magazin/corporate-crowdfunding-wie-ibm-und-audi-ihre-mitarbeiter-crowd-einbinden/},
	addendum = {(abgerufen am 08.07.2020)},
	keywords = {crowdfunding, corporate crowdfunding},
	year = {2020}
}

@Online{innosabi,
	author = {Innosabi},
	title = {Supplier Innovation und Internal Crowdfunding - innosabi},
	url = {https://innosabi.com/2017/09/28/neu-supplier-innovation-internal-crowdfunding/},
	addendum = {(abgerufen am 09.07.2020)},
	keywords = {internal crowdfunding, supplier innovation},
	year = {2020}
}

@Article{ordani,
	author = {Ordani, Andrea AND Miceli, Lucia AND Pizzetti, Marta AND Parasuraman, A Parsu},
	title = {Crowd-funding: Transforming customers into investors through innovative service platforms},
	journal = {Journal of Service Management},
	pages = {443--470},
	year = {2011},
	DOI = {http://dx.doi.org/10.1108/09564231111155079},
}

@Article{bouncken,
	author = {Bouncken, Ricarda B. AND Komorek, Malvine AND Kraus, Sascha},
	title = {Crowdfunding: The Current State Of Research},
	journal = {International Business \& Economics Research Journal (IBER)},
	pages = {407--416},
	year = {2015},
	DOI = {https://doi.org/10.19030/iber.v14i3.9206},
}

@phdthesis{moritz2015,
	author = {Alexandra Moritz},
	title = {Financing of Small and Medium-Sized Enterprises in Europe - Financing Patterns and 'Crowdfunding'},
	institution = {Universität Trier},
	year = {2015},
}

@article{Gierczak2016,
	author = {Kunz, Michael and Bretschneider, Ulrich and Haas, Philipp and Blohm, Ivo and Leimeister, Jan Marco},
	year = {2016},
	month = {01},
	pages = {7-23},
	title = {Crowdfunding: Outlining the new era of fundraising},
	journal = {Crowdfunding in Europe}
}

@Book{Danmayr2013,
  author    = {Danmayr, Florian},
  publisher = {Springer Science & Business Media},
  title     = {Archetypes of Crowdfunding Platforms - A Multidimensional Comparison},
  year      = {2013},
  address   = {Berlin Heidelberg},
  isbn      = {978-3-658-04559-3},
  groups    = {Crowdfunding},
}

@Book{Schramm2014,
  author    = {Schramm, Dana Melanie AND Carstens, Jakob},
  publisher = {Springer-Verlag},
  title     = {Startup-Crowdfunding und Crowdinvesting: Ein Guide für Gründer - Mit Kapital aus der Crowd junge Unternehmen online finanzieren},
  year      = {2014},
  address   = {Berlin Heidelberg New York},
  isbn      = {978-3-658-05926-2},
  groups    = {Crowdfunding},
}

@Book{Scholz2015,
  author    = {Scholz, Nadine},
  publisher = {Springer},
  title     = {The Relevance of Crowdfunding - The Impact on the Innovation Process of Small Entrepreneurial Firms},
  year      = {2015},
  address   = {Berlin, Heidelberg},
  isbn      = {978-3-658-09837-7},
  groups    = {Crowdfunding},
}

@Book{Bottiglia2016,
  author    = {Bottiglia, Roberto AND Pichler, Flavio},
  publisher = {Springer},
  title     = {Crowdfunding for SMEs - A European Perspective},
  year      = {2016},
  address   = {Berlin, Heidelberg},
  isbn      = {978-1-137-56021-6},
  groups    = {Crowdfunding},
}

@Book{Assenmacher2017,
  author    = {Assenmacher, Kai},
  publisher = {Springer-Verlag},
  title     = {Crowdfunding als kommunale Finanzierungsalternative -},
  year      = {2017},
  address   = {Berlin Heidelberg New York},
  isbn      = {978-3-658-17153-7},
  groups    = {Crowdfunding},
}

@Book{Himmer2019,
  author    = {Himmer, Klaus},
  publisher = {Springer-Verlag},
  title     = {Blockchain-basiertes Fundraising als innovative Alternative der Unternehmensfinanzierung - Eine steuer- und aufsichtsrechtliche Analyse},
  year      = {2019},
  address   = {Berlin Heidelberg New York},
  isbn      = {978-3-658-26816-9},
  groups    = {Crowdfunding},
}

@Book{Funk2019,
  author    = {Funk, Andrea S.},
  publisher = {Springer},
  title     = {Crowdfunding in China - A New Institutional Economics Approach},
  year      = {2019},
  address   = {Berlin, Heidelberg},
  isbn      = {978-3-319-97253-4},
  groups    = {Crowdfunding},
}

@Book{Moritz2019,
  author    = {Moritz, Alexandra AND Block, Joern H. AND Golla, Stephan AND Werner, Arndt},
  publisher = {Springer Nature},
  title     = {Contemporary Developments in Entrepreneurial Finance - An Academic and Policy Lens on the Status-Quo, Challenges and Trends},
  year      = {2019},
  address   = {Singapore},
  isbn      = {978-3-030-17612-9},
  groups    = {Crowdfunding},
}

@Book{Guenther2019,
  author    = {Günther, Elmar AND Riethmüller, Tobias},
  publisher = {Springer-Verlag},
  title     = {Einführung in das Crowdfunding - Formen, Anwendungsbereiche, Erfolgsfaktoren, rechtlicher Rahmen},
  year      = {2019},
  address   = {Berlin Heidelberg New York},
  isbn      = {978-3-658-14590-3},
  groups    = {Crowdfunding},
}

@Book{Bilgin2019,
  author    = {Bilgin, Mehmet Huseyin AND Danis, Hakan AND Demir, Ender AND Can, Ugur},
  publisher = {Springer},
  title     = {Eurasian Business Perspectives - Proceedings of the 22nd Eurasia Business and Economics Society Conference},
  year      = {2019},
  address   = {Berlin, Heidelberg},
  isbn      = {978-3-030-11872-3},
  groups    = {Crowdfunding},
}

@Book{Holst2019,
  author    = {Holst, Christian},
  publisher = {Springer-Verlag},
  title     = {Kultur in Interaktion - Co-Creation im Kultursektor},
  year      = {2019},
  address   = {Berlin Heidelberg New York},
  isbn      = {978-3-658-27260-9},
  groups    = {Crowdfunding},
}

@Book{Brüntje2015,
  author    = {Brüntje, Dennis AND Gajda, Oliver},
  publisher = {Springer},
  title     = {Crowdfunding in Europe - State of the Art in Theory and Practice},
  year      = {2015},
  address   = {Berlin, Heidelberg},
  isbn      = {978-3-319-18017-5},
  groups    = {Crowdfunding},
}

@Book{Zerfaß2009,
  author    = {Zerfaß, Ansgar AND Möslein, Kathrin M.},
  publisher = {Springer-Verlag},
  title     = {Kommunikation als Erfolgsfaktor im Innovationsmanagement - Strategien im Zeitalter der Open Innovation},
  year      = {2009},
  address   = {Berlin Heidelberg New York},
  isbn      = {978-3-834-91659-4},
  groups    = {Crowdfunding},
}

@BOOK{Sixt2014,
	AUTHOR = {Sixt, Elfriede},
	YEAR = {2014},
	TITLE = {Schwarmökonomie und Crowdfunding - Webbasierte Finanzierungssysteme im Rahmen realwirtschaftlicher Bedingungen},
	EDITION = {},
	ISBN = {978-3-658-02929-6},
	PUBLISHER = {Springer-Verlag},
	ADDRESS = {Berlin Heidelberg New York},
}

@article{Schwienbacher2010,
	author = {Schwienbacher, Armin AND Larralde, Benjamin},
	year = {2010},
	month = {09},
	pages = {},
	title = {Crowdfunding of Small Entrepreneurial Ventures},
	journal = {The Oxford Handbook of Entrepreneurial Finance},
	doi = {10.2139/ssrn.1699183}
}

@article{cumming_leboeuf_schwienbacher_2014,
	title={Crowdfunding Models: Keep-it-All vs. All-or-Nothing},
	DOI={10.2139/ssrn.2447567},
	journal={SSRN Electronic Journal},
	author={Cumming, Douglas J. and Leboeuf, Gaal and Schwienbacher, Armin},
	year={2014},
	month={Jun}
}

@inproceedings{Gerber2011Crowdfunding,
  title={Crowdfunding : Why People Are Motivated to Post and Fund Projects on Crowdfunding Platforms},
  author={Elizabeth M. Gerber and Julie S. Hui and Pei-Yi Kuo},
  year={2011}
}

@BOOK{Gebert2013,
	AUTHOR = {Gebert AND Ivo AND Marco, Jan AND Karsten AND Michael AND Blohm AND Leimeister AND Wenzlaff AND Michael},
	YEAR = {2013},
	TITLE = {Crowdfunding-Studie 2013/2013 - Analyse, Perspektiven und Erfolgsfaktoren innovativer Unternehmens- und Projektfinanzierungen},
	EDITION = {},
	ISBN = {978-3-844-27325-0},
	PUBLISHER = {epubli},
	ADDRESS = {Hamburg},
}

@BOOK{Looy2015,
	AUTHOR = {Looy, Amy Van},
	YEAR = {2015},
	TITLE = {Social Media Management - Technologies and Strategies for Creating Business Value},
	EDITION = {},
	ISBN = {978-3-319-21990-5},
	PUBLISHER = {Springer},
	ADDRESS = {Berlin, Heidelberg},
}

@misc{crowdlending_survey,
	AUTHOR = {Dietrich, Prof. Dr. Andreas AND Amrein, Simon AND Heyde, Falk von der AND Heuermann, Adrian AND Rüdisühli, Manuel},
	YEAR = {2019},
	TITLE = {Crowdlending Survey 2019},
	url = {https://de.statista.com/statistik/studie/id/68947/dokument/crowdlending-markt-in-der-schweiz-2019/}
}

@BOOK{Schrecker2012,
	AUTHOR = {Schrecker, Tilman},
	YEAR = {2012},
	TITLE = {Mezzanine-Kapital im Handels- und Steuerrecht - eine Untersuchung zur Abgrenzung zwischen Eigenkapital und Fremdkapital},
	EDITION = {},
	ISBN = {978-3-428-53692-4},
	PUBLISHER = {Duncker \& Humblot},
	ADDRESS = {Berlin},
}

@article{vissers_dankbaar2002,
	author = {Vissers, Geert and Dankbaar, Ben},
	year = {2002},
	month = {03},
	pages = {31 - 42},
	title = {Creativity in Multidisciplinary New Product Development Teams},
	volume = {11},
	journal = {Creativity and Innovation Management},
	doi = {10.1111/1467-8691.00234}
}

@BOOK{wheelwright1992,
	author = {Wheelwright, S. C. AND Clark, K. B.},
	year = {1992},
	title = {Revolutionizing Product Development: Quantum Leaps in Speed, Efficiency and Quality},
	publisher = {New York: Free Press},
	edition = {},
	isbn = {},
	address = {}
}

@BOOK{schumpeter1934,
	author = {Schumpeter, Joseph A.},
	year = {1934},
	title = {The Theory of Economic Development},
	publisher = {Harvard Economic Studies},
	edition = {},
	isbn = {9780674879904},
	address = {}
}

@book{Robinson:1486035,
      author        = "Robinson, Alan and Stern, Sam",
      title         = "{Corporate Creativity: How Innovation and Improvement
                       Actually Happen}",
      publisher     = "Berrett-Koehler Publishers, Inc",
      address       = "San Francisco",
      year          = "1998",
      url           = "http://cds.cern.ch/record/1486035",
}

@article{berger2005,
author = {Berger, Christoph and Möslein, Kathrin and Piller, Frank and Reichwald, Ralf},
title = {Co-designing modes of cooperation at the customer interface: learning from exploratory research},
journal = {European Management Review},
volume = {2},
number = {1},
pages = {70-87},
keywords = {customer-centric strategy, co-design, mass customization, modes of cooperation, absorptive capacity, action research},
doi = {10.1057/palgrave.emr.1500030},
url = {https://onlinelibrary.wiley.com/doi/abs/10.1057/palgrave.emr.1500030},
eprint = {https://onlinelibrary.wiley.com/doi/pdf/10.1057/palgrave.emr.1500030},
year = {2005}
}

@article{Huff2006,
author = {Huff, Anne and Fredberg, Tobias and Frank, Dr and Piller, Frank},
year = {2006},
month = {01},
pages = {},
title = {Leading open innovation: creating centripetal innovation capacity}
}

@article{moslein2010open,
  title={Open Innovation: Grundlagen, Akteure, Werkzeuge und Wirkungsweisen},
  author={M{\"o}slein, Kathrin M},
  year={2010}
}

@ARTICLE{Hippel1978,
title = {A customer-active paradigm for industrial product idea generation},
author = {Von Hippel, Eric},
year = {1978},
journal = {Research Policy},
volume = {7},
number = {3},
pages = {240-266},
url = {https://EconPapers.repec.org/RePEc:eee:respol:v:7:y:1978:i:3:p:240-266}
}

@ARTICLE{Hippel1986,
title = {Lead Users: A Source of Novel Product Concepts},
author = {von Hippel, Eric },
year = {1986},
journal = {Management Science},
volume = {32},
number = {7},
pages = {791-805},
url = {https://EconPapers.repec.org/RePEc:inm:ormnsc:v:32:y:1986:i:7:p:791-805}
}

@BOOK{Hippel2006,
	AUTHOR = {Hippel, Eric von},
	YEAR = {2006},
	TITLE = {Democratizing Innovation - },
	EDITION = {},
	ISBN = {978-0-262-72047-2},
	PUBLISHER = {MIT Press},
	ADDRESS = {Cambridge},
}

@article{reichwald2006open,
  	title={Open innovation, Individualisierung und neue Formen der Arbeitsteilung},
  	author={Reichwald, Ralf and Piller, Frank},
  	journal={Wiesbaden: Gabler},
  	year={2006}
}

@Online{leadership_experts,
	title = {Top 50 Leadership and Management Experts},
	url = {https://www.inc.com/jeff-haden/the-top-50-leadership-and-management-experts-mon.html},
	addendum = {(abgerufen am 22.07.2020)},
	keywords = {},
	year = {2020}
}

@Online{leadership_speakers,
	title = {100 Great Leadership Speakers for Your Next Conference},
	url = {https://www.inc.com/jeff-haden/100-great-leadership-speakers-for-your-next-conference.html},
	addendum = {(abgerufen am 22.07.2020)},
	keywords = {},
	year = {2020}
}

@Article{appelo2014medium,
	title = {Try Internal Crowdfunding},
	author = {Appelo, Jurgen},
	journal = {Medium},
	year = {2014}
}

@Online{management3_internal_crowdfunding,
	title = {Management 3.0 Practices: Internal Crowdfunding - Management 3.0},
	url = {https://management30.com/practice/internal-crowdfunding/},
	addendum = {(abgerufen am 22.07.2020)},
	keywords = {Management 3.0, Crowdfunding, Internal Crowdfunding},
	year = {2020}
}

@ONLINE{vanderkam2014,
	author = {Vanderkam, Laura},
	title = {Why Encouraging Employees To Be Entrepreneurs Can Create An Incredible Place To Work},
	url = {https://www.fastcompany.com/3024888/why-encouraging-employees-to-be-entrepreneurs-can-create-an-incredible-place-to-w},
	addendum = {(abgerufen am 23.07.2020)},
	keywords = {},
	year = {2014}
}

repository: gitter-badger/traffic-analysis

repo_name: gitter-badger/traffic-analysis


text:
SUMMARY = "XML bomb protection for Python stdlib modules"
DESCRIPTION = "Python package with modified subclasses of all stdlib XML \
parsers that prevent any potentially malicious operation."

LICENSE = "PSF-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=056fea6a4b395a24d0d278bf5c80249e"

SRC_URI[sha256sum] = "1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"

inherit pypi setuptools3

BBCLASSEXTEND = "native"

RDEPENDS:${PN} += "python3-xml"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

gha_language: BitBake


text:
PN = "tuxbox-links"
PV = "1.0"
PR = "r10"

do_install () {
	install -d ${D}/var
	install -d ${D}/var/spool
	install -d ${D}/usr/keys
	install -d ${D}/usr/bin
	install -d ${D}/etc/cron
	install -d ${D}/etc/tuxbox/scce
	ln -s /usr/keys ${D}/var/
	ln -s /usr/bin ${D}/var/
	ln -s /etc ${D}/var/
	ln -s /etc/cron ${D}/var/spool/
	ln -s /etc/tuxbox/scce ${D}/var/
}

FILES_${PN} = "/"

gha_language: C


text:
@phdthesis{Ren07,
 author = {Kui Ren},
 school = {Worcester Polytechnic Institute},
 title = {Communication Security in Wireless Sensor Networks},
 year = {2007}
}


text:
include xcb-util.inc
PR = "r0"

SRC_URI[md5sum] = "b09bdebad50638709de22d8eb2dc3bf5"
SRC_URI[sha256sum] = "a0d6a15ac4dcbcea832f2f9b2dbcf575b02cf69aa92f0ba90bd35b61cd75b01a"


text:
FILE(REMOVE_RECURSE
  "CMakeFiles/shawn_web_sample_testing12.dir/legacyapps/sample_testing12/sample_testing12_init.o"
  "CMakeFiles/shawn_web_sample_testing12.dir/legacyapps/sample_testing12/sample_testing12_processor_factory.o"
  "CMakeFiles/shawn_web_sample_testing12.dir/legacyapps/sample_testing12/sample_testing12_message.o"
  "CMakeFiles/shawn_web_sample_testing12.dir/legacyapps/sample_testing12/sample_testing12_processor.o"
  "CMakeFiles/shawn_web_sample_testing12.dir/legacyapps/legacyapps_init.o"
  "/var/www/prueba/shawn/src/legacyapps/sample_testing12/build_files/shawn_web_sample_testing12.pdb"
  "/var/www/prueba/shawn/src/legacyapps/sample_testing12/build_files/shawn_web_sample_testing12"
)

# Per-language clean rules from dependency scanning.
FOREACH(lang CXX)
  INCLUDE(CMakeFiles/shawn_web_sample_testing12.dir/cmake_clean_${lang}.cmake OPTIONAL)
ENDFOREACH(lang)

repository: lsfiege/shawnweb

repo_name: lsfiege/shawnweb


text:
DEPENDS = "libogg libvorbis libsdl-x11"

SRC_URI = "http://downloads.xiph.org/releases/theora/libtheora-${PV}.tar.bz2"

inherit autotools lib_package

do_configure_append() {
        find ${S} -name Makefile | xargs sed -i -e s:'-I/usr/include':-I${STAGING_INCDIR}:g
}

AUTOTOOLS_STAGE_PKGCONFIG = "1"
do_stage() {
         autotools_stage_all
}

repository: metalsky/SamyGO

repo_name: metalsky/SamyGO


text:
require xorg-lib-common.inc
DESCRIPTION = "Library for lowlevel pixel operations"
DEPENDS = "virtual/libx11"
PR = "${INC_PR}.0"

SRC_URI[archive.md5sum] = "c354ab5b0da10227226d3ef604254875"
SRC_URI[archive.sha256sum] = "261d239e9e3070a0a81e5b3eab92e6236c6295979bdae0a1ded05cbef93f67aa"

repository: trini/openembedded

repo_name: trini/openembedded


text:
@InProceedings{hazana16,
  supplementary = {Supplementary:hazana16-supp.pdf},
  title = {Variance-Reduced and Projection-Free Stochastic Optimization},
  author = {Elad Hazan and Haipeng Luo},
  pages = {1263-1271},
  abstract = {The Frank-Wolfe optimization algorithm has recently regained popularity for machine learning applications due to its projection-free property and its ability to handle structured constraints. However, in the stochastic learning setting, it is still relatively understudied compared to the gradient descent counterpart. In this work, leveraging a recent variance reduction technique, we propose two stochastic Frank-Wolfe variants which substantially improve previous results in terms of the number of stochastic gradient evaluations needed to achieve $1-\epsilon$ accuracy. For example, we improve from $O(\frac{1}{\epsilon})$ to $O(\ln\frac{1}{\epsilon})$ if the objective function is smooth and strongly convex, and from $O(\frac{1}{\epsilon^2})$ to $O(\frac{1}{\epsilon^{1.5}})$ if the objective function is smooth and Lipschitz. The theoretical improvement is also observed in experiments on real-world datasets for a multiclass classification application.},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
SUMMARY  = "Xilinx Runtime(XRT) libraries"
DESCRIPTION = "Xilinx Runtime User Space Libraries and headers"

LICENSE = "GPLv2 & Apache-2.0"
LIC_FILES_CHKSUM = "file://../LICENSE;md5=da5408f748bce8a9851dac18e66f4bcf \
                    file://runtime_src/core/edge/drm/zocl/LICENSE;md5=7d040f51aae6ac6208de74e88a3795f8 \
                    file://runtime_src/core/pcie/driver/linux/xocl/LICENSE;md5=b234ee4d69f5fce4486a80fdaf4a4263 \
                    file://runtime_src/core/pcie/linux/LICENSE;md5=3b83ef96387f14655fc854ddc3c6bd57 \
                    file://runtime_src/core/pcie/tools/xbutil/LICENSE;md5=d273d63619c9aeaf15cdaf76422c4f87 \
                    file://runtime_src/core/edge/tools/xbutil/LICENSE;md5=d273d63619c9aeaf15cdaf76422c4f87 "

BRANCH ?= "2020.1_PU1"
REPO ?= "git://github.com/Xilinx/XRT.git;protocol=https"
BRANCHARG = "${@['nobranch=1', 'branch=${BRANCH}'][d.getVar('BRANCH', True) != '']}"
SRC_URI = "${REPO};${BRANCHARG}"

PV = "202010.2.7.0"
SRCREV ?= "8a4c6eb5012c57423fba468e1af8df53a293dcd5"

S = "${WORKDIR}/git/src"

inherit cmake

BBCLASSEXTEND = "native nativesdk"

# util-linux is for libuuid-dev.
DEPENDS = "libdrm opencl-headers ocl-icd opencl-clhpp boost util-linux git-replacement-native protobuf-native protobuf"
RDEPENDS_${PN} = "bash ocl-icd boost-system boost-filesystem"

EXTRA_OECMAKE += " \
		-DCMAKE_BUILD_TYPE=Release \
		-DCMAKE_EXPORT_COMPILE_COMANDS=ON \
		"

PACKAGE_ARCH_versal-ai-core = "${SOC_VARIANT_ARCH}"
EXTRA_OECMAKE_append_versal-ai-core += "-DXRT_AIE_BUILD=true"
TARGET_CXXFLAGS_append_versal-ai-core += "-DXRT_ENABLE_AIE"
DEPENDS_append_versal-ai-core += " libmetal libxaiengine"
RDEPENDS_${PN}_append_versal-ai-core += " libxaiengine"

pkg_postinst_ontarget_${PN}() {
  #!/bin/sh
  if [ ! -e /etc/OpenCL/vendors/xilinx.icd ]; then
	echo "INFO: Creating ICD entry for Xilinx Platform"
	mkdir -p /etc/OpenCL/vendors
	echo "libxilinxopencl.so" > /etc/OpenCL/vendors/xilinx.icd
	chmod -R 755 /etc/OpenCL
  fi
}

repository: ampere-openbmc/openbmc

repo_name: ampere-openbmc/openbmc


text:
package main

// Autogenerated by Typical-Go. DO NOT EDIT.

import (
	"github.com/hotstone-seo/hotstone-seo/internal/analyt"
	"github.com/hotstone-seo/hotstone-seo/internal/api/repository"
	"github.com/hotstone-seo/hotstone-seo/internal/api/service"
	"github.com/hotstone-seo/hotstone-seo/internal/app/infra"
	"github.com/hotstone-seo/hotstone-seo/internal/provider"
	"github.com/hotstone-seo/hotstone-seo/internal/urlstore"
	"github.com/typical-go/typical-go/pkg/typgo"
)

func init() {
	typgo.Provide(
		&typgo.Constructor{Name: "", Fn: analyt.NewClientKeyAnalytRepo},
		&typgo.Constructor{Name: "", Fn: analyt.NewReportRepo},
		&typgo.Constructor{Name: "", Fn: analyt.NewRuleMatchingRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewAuditTrailRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewClientKeyRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewDataSourceRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewRuleRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewSettingRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewStructuredDataRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewTagRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewUserRepo},
		&typgo.Constructor{Name: "", Fn: repository.NewUserRoleRepo},
		&typgo.Constructor{Name: "", Fn: service.NewAuditTrailSvc},
		&typgo.Constructor{Name: "", Fn: service.NewService},
		&typgo.Constructor{Name: "", Fn: service.NewCenterService},
		&typgo.Constructor{Name: "", Fn: service.NewClientKeyService},
		&typgo.Constructor{Name: "", Fn: service.NewDataSourceService},
		&typgo.Constructor{Name: "", Fn: service.NewMetricService},
		&typgo.Constructor{Name: "", Fn: service.NewUserRoleSvc},
		&typgo.Constructor{Name: "", Fn: service.NewRuleService},
		&typgo.Constructor{Name: "", Fn: service.NewSettingSvc},
		&typgo.Constructor{Name: "", Fn: service.NewStructuredDataService},
		&typgo.Constructor{Name: "", Fn: service.NewTagService},
		&typgo.Constructor{Name: "", Fn: service.NewUserSvc},
		&typgo.Constructor{Name: "", Fn: infra.Connect},
		&typgo.Constructor{Name: "", Fn: provider.NewService},
		&typgo.Constructor{Name: "", Fn: urlstore.NewService},
		&typgo.Constructor{Name: "", Fn: urlstore.NewStore},
		&typgo.Constructor{Name: "", Fn: urlstore.NewSyncRepo},
		&typgo.Constructor{
			Name: "",
			Fn: func() (cfg *infra.App, err error) {
				cfg = new(infra.App)
				if err = typgo.ProcessConfig("APP", cfg); err != nil {
					return nil, err
				}
				return
			},
		},
		&typgo.Constructor{
			Name: "",
			Fn: func() (cfg *infra.Redis, err error) {
				cfg = new(infra.Redis)
				if err = typgo.ProcessConfig("REDIS", cfg); err != nil {
					return nil, err
				}
				return
			},
		},
		&typgo.Constructor{
			Name: "",
			Fn: func() (cfg *infra.Pg, err error) {
				cfg = new(infra.Pg)
				if err = typgo.ProcessConfig("PG", cfg); err != nil {
					return nil, err
				}
				return
			},
		},
		&typgo.Constructor{
			Name: "",
			Fn: func() (cfg *infra.Analyt, err error) {
				cfg = new(infra.Analyt)
				if err = typgo.ProcessConfig("ANALYT", cfg); err != nil {
					return nil, err
				}
				return
			},
		},
		&typgo.Constructor{
			Name: "",
			Fn: func() (cfg *infra.Auth, err error) {
				cfg = new(infra.Auth)
				if err = typgo.ProcessConfig("AUTH", cfg); err != nil {
					return nil, err
				}
				return
			},
		},
	)
	typgo.Destroy(
		&typgo.Destructor{Fn: infra.Disconnect},
	)
}

repository: hotstone-seo/hotstone-seo

repo_name: hotstone-seo/hotstone-seo