text:
DESCRIPTION = "Protected Storage PSA certification tests (psa-arch-test) for Trusted Services"

TS_ENV = "arm-linux"

require ts-psa-api-test-common_${PV}.inc

OECMAKE_SOURCEPATH = "${S}/deployments/psa-api-test/protected_storage/${TS_ENV}"

PSA_TEST = "psa-ps-api-test"

license: MIT

repository: openbmc/openbmc

license_type: permissive

repo_name: openbmc/openbmc

branch_name: refs/heads/master

gha_license_id: NOASSERTION

gha_language: Python

extension: bb


text:
# Install script for directory: /Users/oak/go/src/github.com/cpprestsdk/Release

# Set the install prefix
if(NOT DEFINED CMAKE_INSTALL_PREFIX)
  set(CMAKE_INSTALL_PREFIX "/usr/local")
endif()
string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")

# Set the install configuration name.
if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
  if(BUILD_TYPE)
    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
  else()
    set(CMAKE_INSTALL_CONFIG_NAME "Debug")
  endif()
  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
endif()

# Set the component getting installed.
if(NOT CMAKE_INSTALL_COMPONENT)
  if(COMPONENT)
    message(STATUS "Install component: \"${COMPONENT}\"")
    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
  else()
    set(CMAKE_INSTALL_COMPONENT)
  endif()
endif()

# Is this installation the result of a crosscompile?
if(NOT DEFINED CMAKE_CROSSCOMPILING)
  set(CMAKE_CROSSCOMPILING "FALSE")
endif()

if("x${CMAKE_INSTALL_COMPONENT}x" STREQUAL "xUnspecifiedx" OR NOT CMAKE_INSTALL_COMPONENT)
  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/include/cpprest" TYPE FILE FILES
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/astreambuf.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/asyncrt_utils.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/base_uri.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/containerstream.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/filestream.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/http_client.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/http_headers.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/http_listener.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/http_msg.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/interopstream.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/json.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/oauth1.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/oauth2.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/producerconsumerstream.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/rawptrstream.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/streams.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/uri.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/uri_builder.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/version.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/ws_client.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/ws_msg.h"
    )
endif()

if("x${CMAKE_INSTALL_COMPONENT}x" STREQUAL "xUnspecifiedx" OR NOT CMAKE_INSTALL_COMPONENT)
  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/include/pplx" TYPE FILE FILES
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/pplx/pplx.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/pplx/pplxcancellation_token.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/pplx/pplxconv.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/pplx/pplxinterface.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/pplx/pplxlinux.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/pplx/pplxtasks.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/pplx/pplxwin.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/pplx/threadpool.h"
    )
endif()

if("x${CMAKE_INSTALL_COMPONENT}x" STREQUAL "xUnspecifiedx" OR NOT CMAKE_INSTALL_COMPONENT)
  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/include/cpprest/details" TYPE FILE FILES
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/SafeInt3.hpp"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/basic_types.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/cpprest_compat.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/fileio.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/http_helpers.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/http_server.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/http_server_api.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/http_server_asio.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/http_server_httpsys.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/nosal.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/resource.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/uri_parser.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/web_utilities.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/x509_cert_utilities.h"
    "/Users/oak/go/src/github.com/cpprestsdk/Release/include/cpprest/details/http_constants.dat"
    )
endif()

if(NOT CMAKE_INSTALL_LOCAL_ONLY)
  # Include the install script for each subdirectory.
  include("/Users/oak/go/src/github.com/cpprestsdk/Release/cmake-build-debug/src/cmake_install.cmake")
  include("/Users/oak/go/src/github.com/cpprestsdk/Release/cmake-build-debug/tests/cmake_install.cmake")
  include("/Users/oak/go/src/github.com/cpprestsdk/Release/cmake-build-debug/samples/cmake_install.cmake")

endif()

if(CMAKE_INSTALL_COMPONENT)
  set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
else()
  set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
endif()

string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
       "${CMAKE_INSTALL_MANIFEST_FILES}")
file(WRITE "/Users/oak/go/src/github.com/cpprestsdk/Release/cmake-build-debug/${CMAKE_INSTALL_MANIFEST}"
     "${CMAKE_INSTALL_MANIFEST_CONTENT}")

extension: cmake


text:
@article{mars2022microbiomes,
 author = {Mars Brisbin, Margaret and Mitarai, Satoshi and Saito, Mak A and Alexander, Harriet},
 journal = {The ISME Journal},
 number = {9},
 pages = {2255--2264},
 publisher = {Nature Publishing Group},
 title = {Microbiomes of bloom-forming Phaeocystis algae are stable and consistently recruited, with both symbiotic and opportunistic modes},
 volume = {16},
 year = {2022}
}

repository: AlexanderLabWHOI/academic-kickstart

repo_name: AlexanderLabWHOI/academic-kickstart

gha_license_id: MIT

gha_language: TeX

extension: bib


text:
/*
 * Copyright 2018-2019 Zedge, Inc.
 * Copyright 2019-2020 Stig Sæther Nordahl Bakken
 *
 * 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 helm

import (
	"crypto/sha1"
	"fmt"
	"io/ioutil"
	"os"
	"os/user"
	"path"
	"path/filepath"
	"regexp"
	"strings"

	"github.com/ghodss/yaml"

	"github.com/kubecd/kubecd/pkg/image"

	"github.com/kubecd/kubecd/pkg/exec"
	"github.com/kubecd/kubecd/pkg/model"
)

var runner exec.Runner = exec.RealRunner{}

func inspectCacheDir() string {
	dir := os.Getenv("KUBECD_CACHE")
	if dir == "" {
		me, _ := user.Current()
		dir = me.HomeDir
	}
	return filepath.Join(dir, ".kubecd", "cache", "inspect")
}

func pathExists(path string) bool {
	if _, err := os.Stat(path); err != nil {
		return false
	}
	return true
}

// InspectChart :
func InspectChart(chartReference, chartVersion string) ([]byte, error) {
	h := sha1.New()
	_, _ = h.Write([]byte(chartReference))
	_, _ = h.Write([]byte(chartVersion))
	chartHash := fmt.Sprintf("%x", h.Sum(nil))
	cacheDir := inspectCacheDir()
	cacheFile := filepath.Join(cacheDir, chartHash)
	if pathExists(cacheFile) {
		data, err := ioutil.ReadFile(cacheFile)
		if err != nil {
			return nil, fmt.Errorf(`could not read %q: %v`, cacheFile, err)
		}
		return data, nil
	}
	out, err := runner.Run("helm", "inspect", chartReference, "--version", chartVersion)
	if err != nil {
		return nil, fmt.Errorf(`error while running "helm inspect": %v`, err)
	}
	err = ioutil.WriteFile(cacheFile, out, 0644)
	if err != nil {
		return nil, fmt.Errorf(`error while writing cache file: %v`, err)
	}
	return out, nil
}

// RepoSetupCommands :
func RepoSetupCommands(repos []model.HelmRepo) [][]string {
	var cmds [][]string
	for _, repo := range repos {
		addCmd := []string{"helm", "repo", "add", repo.Name, repo.URL}
		if caFile := repo.GetCAFile(); caFile != "" {
			addCmd = append(addCmd, "--ca-file", caFile)
		}
		if certFile := repo.GetCertFile(); certFile != "" {
			addCmd = append(addCmd, "--cert-file", certFile)
		}
		if keyFile := repo.GetKeyFile(); keyFile != "" {
			addCmd = append(addCmd, "--key-file", keyFile)
		}
		cmds = append(cmds, addCmd)
	}
	cmds = append(cmds, []string{"helm", "repo", "update"})
	return cmds
}

func UseContextCommand(envName string) []string {
	return []string{"kubectl", "config", "use-context", model.KubeContextName(envName)}
}

func KubectlApplyCommand(resourceFiles []string, dryRun bool, envName string) []string {
	cmd := []string{"kubectl", "--context", model.KubeContextName(envName), "apply"}
	if dryRun {
		cmd = append(cmd, "--dry-run")
	}
	for _, file := range resourceFiles {
		cmd = append(cmd, "-f", file)
	}
	return cmd
}

const (
	DryRun   = true
	NoDryRun = false
	Debug    = true
	NoDebug  = false
)

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

func DeployCommands(env *model.Environment, dryRun, debug bool, limitToReleases []string) ([][]string, error) {
	var commands [][]string
	for _, releaseName := range limitToReleases {
		if env.GetRelease(releaseName) == nil {
			return nil, fmt.Errorf(`env %q: release not found: %q`, env.Name, releaseName)
		}
	}
	for _, release := range env.AllReleases() {
		if len(limitToReleases) == 0 || stringInSlice(release.Name, limitToReleases) {
			relFile := release.FromFile
			if release.Chart != nil {
				tmp, err := GenerateHelmApplyArgv(release, env, dryRun, debug)
				if err != nil {
					return nil, err
				}
				commands = append(commands, tmp)
			} else if release.ResourceFiles != nil {
				absFiles := make([]string, len(release.ResourceFiles))
				for i, path := range release.ResourceFiles {
					absFiles[i] = model.ResolvePathFromFile(path, relFile)
				}
				commands = append(commands, KubectlApplyCommand(absFiles, dryRun, env.Name))
			}
		}
	}
	return commands, nil
}

func TemplateCommands(env *model.Environment, limitToReleases []string) ([][]string, error) {
	var commands [][]string
	for _, releaseName := range limitToReleases {
		if env.GetRelease(releaseName) == nil {
			return nil, fmt.Errorf(`env %q: release not found: %q`, env.Name, releaseName)
		}
	}
	for _, release := range env.AllReleases() {
		if len(limitToReleases) == 0 || stringInSlice(release.Name, limitToReleases) {
			relFile := release.FromFile
			if release.Chart != nil {
				tmp, err := GenerateTemplateCommands(release, env)
				if err != nil {
					return nil, err
				}
				commands = append(commands, tmp...)
			} else if release.ResourceFiles != nil {
				for _, resourceFile := range release.ResourceFiles {
					commands = append(commands,
						[]string{"echo", "---"},
						[]string{"echo", "#", "Source:", model.ResolvePathFromFile(resourceFile, relFile)},
						[]string{"cat", model.ResolvePathFromFile(resourceFile, relFile)},
						[]string{"echo", "---"})
				}
			}
		}
	}
	return commands, nil
}

func GenerateHelmBaseArgv(env *model.Environment) []string {
	return []string{"helm", "--kube-context", model.KubeContextName(env.Name)}
}

func formatSetValuesString(values []model.ChartValue, env *model.Environment, skipValuesFrom bool) (string, error) {
	tmp := make([]string, len(values))
	for i, val := range values {
		rv, err := ResolveValue(val, env)
		if err != nil {
			return "", err
		}
		tmp[i] = rv.Key + "=" + rv.Value
	}
	return strings.Join(tmp, ","), nil
}

func GenerateHelmValuesArgv(rel *model.Release, env *model.Environment) ([]string, error) {
	var argv []string
	if !rel.SkipDefaultValues {
		if env.DefaultValuesFile != "" {
			argv = append(argv, "--values", rel.AbsPath(env.DefaultValuesFile))
		}
		if env.DefaultValues != nil {
			setArg, err := formatSetValuesString(env.DefaultValues, env, false)
			if err != nil {
				return []string{}, err
			}
			argv = append(argv, "--set-string", setArg)
		}
	}
	if rel.ValuesFile != nil {
		argv = append(argv, "--values", rel.AbsPath(*rel.ValuesFile))
	}
	if rel.Values != nil {
		setArg, err := formatSetValuesString(rel.Values, env, false)
		if err != nil {
			return []string{}, err
		}
		argv = append(argv, "--set-string", setArg)
	}
	return argv, nil
}

func GenerateHelmChartArgs(rel *model.Release) ([]string, error) {
	if rel.Chart.Reference == nil {
		chartDir := rel.AbsPath(*rel.Chart.Dir)
		if !pathExists(chartDir) && !strings.Contains(chartDir, fmt.Sprintf("kcd-template.%d", os.Getpid())) {
			return []string{}, fmt.Errorf(`%s: release %q chart.dir %q does not exist`, rel.FromFile, rel.Name, chartDir)
		}
		return []string{chartDir}, nil
	}
	return []string{*rel.Chart.Reference, "--version", *rel.Chart.Version}, nil
}

func GenerateHelmDiffArgv(rel *model.Release, env *model.Environment) ([]string, error) {
	argv := GenerateHelmBaseArgv(env)
	argv = append(argv, "diff", "upgrade", rel.Name)
	chartArgs, err := GenerateHelmChartArgs(rel)
	if err != nil {
		return []string{}, err
	}
	argv = append(argv, chartArgs...)
	valueArgs, err := GenerateHelmValuesArgv(rel, env)
	if err != nil {
		return []string{}, err
	}
	argv = append(argv, valueArgs...)
	return argv, nil
}

func GenerateTemplateCommands(rel *model.Release, env *model.Environment) ([][]string, error) {
	var commands [][]string
	var tmpDir string
	if rel.Chart.Reference != nil {
		reference := *rel.Chart.Reference
		version := *rel.Chart.Version
		tmpDir = path.Join(os.TempDir(), fmt.Sprintf("kcd-template.%d", os.Getpid()))
		// Make a copy of Release.Chart so we can modify it
		var relCopy = *rel
		var chartCopy = *rel.Chart
		chartCopy.Reference = nil
		chartCopy.Version = nil
		// Assumes that "helm fetch --untar" always uses the chart/reference name as the directory
		newDir := path.Join(tmpDir, path.Base(reference))
		chartCopy.Dir = &newDir
		relCopy.Chart = &chartCopy
		rel = &relCopy
		commands = append(commands,
			[]string{"mkdir", "-m", "700", "-p", tmpDir},
			[]string{"helm", "fetch", reference, "--version", version, "--untar", "--untardir", tmpDir})
	}
	chartArgs, err := GenerateHelmChartArgs(rel)
	var valueArgs []string
	if err == nil {
		valueArgs, err = GenerateHelmValuesArgv(rel, env)
	}
	if err != nil {
		return [][]string{}, err
	}

	templateArgv := GenerateHelmBaseArgv(env)
	templateArgv = append(templateArgv, "template")
	templateArgv = append(templateArgv, chartArgs...)
	templateArgv = append(templateArgv, "-n", rel.Name, "--namespace", env.KubeNamespace)
	templateArgv = append(templateArgv, valueArgs...)
	commands = append(commands, templateArgv)

	if tmpDir != "" {
		commands = append(commands, []string{"rm", "-rf", tmpDir})
	}

	return commands, nil
}

func GenerateHelmApplyArgv(rel *model.Release, env *model.Environment, dryRun, debug bool) ([]string, error) {
	chartArgs, err := GenerateHelmChartArgs(rel)
	if err != nil {
		return []string{}, err
	}
	valueArgs, err := GenerateHelmValuesArgv(rel, env)
	if err != nil {
		return []string{}, err
	}
	argv := GenerateHelmBaseArgv(env)
	argv = append(argv, "upgrade", rel.Name)
	argv = append(argv, chartArgs...)
	argv = append(argv, "-i", "--namespace", env.KubeNamespace)
	argv = append(argv, valueArgs...)
	if dryRun {
		argv = append(argv, "--dry-run")
	}
	if debug {
		argv = append(argv, "--debug")
	}
	return argv, nil
}

func ResolveValue(value model.ChartValue, env *model.Environment) (*model.ChartValue, error) {
	retVal := &model.ChartValue{Key: value.Key, Value: value.Value}
	if env == nil || value.ValueFrom == nil {
		return retVal, nil
	}
	if gceRes := value.ValueFrom.GceResource; gceRes != nil {
		if gceRes.Address != nil {
			addr, err := ResolveGceAddressValue(value.ValueFrom.GceResource.Address, env)
			if err != nil {
				return nil, err
			}
			retVal.Value = addr
		}
	}
	return retVal, nil
}

var zoneToRegionRegexp = regexp.MustCompile(`-[a-z]$`)

func ResolveGceAddressValue(address *model.GceAddressValueRef, env *model.Environment) (string, error) {
	gke := env.GetCluster().Provider.GKE
	argv := []string{"compute", "addresses", "describe", address.Name, "--format", "value(address)", "--project", gke.Project}
	if address.IsGlobal {
		argv = append(argv, "--global")
	} else {
		argv = append(argv, "--region")
		if gke.Zone != nil {
			argv = append(argv, zoneToRegionRegexp.ReplaceAllString(*gke.Zone, ""))
		} else {
			argv = append(argv, *gke.Region)
		}
	}
	out, err := runner.Run("gcloud", argv...)
	if err != nil {
		return "", err
	}
	return strings.TrimSpace(string(out)), nil
}

func MergeValues(from, onto map[string]interface{}) map[string]interface{} {
	result := onto
	for key, value := range from {
		_, newValueIsMap := value.(map[string]interface{})
		_, keyExists := result[key]
		oldValueIsMap := false
		if keyExists {
			_, oldValueIsMap = result[key].(map[string]interface{})
		}
		if newValueIsMap {
			if oldValueIsMap {
				result[key] = MergeValues(from[key].(map[string]interface{}), result[key].(map[string]interface{}))
			} else {
				result[key] = value
			}
		} else {
			result[key] = value
		}
	}
	return result
}

func LoadValuesFile(fileName string) (map[string]interface{}, error) {
	var values map[string]interface{}
	r, err := os.Open(fileName)
	if err != nil {
		return nil, fmt.Errorf("error while opening %s: %v", fileName, err)
	}
	data, err := ioutil.ReadAll(r)
	if err != nil {
		return nil, fmt.Errorf("error while reading %s: %v", fileName, err)
	}
	err = yaml.Unmarshal(data, &values)
	if err != nil {
		return nil, fmt.Errorf("error while unmarshaling %s: %v", fileName, err)
	}
	return values, nil
}

func valToMap(key []string, value interface{}) map[string]interface{} {
	if len(key) == 1 {
		return map[string]interface{}{key[0]: value}
	}
	return map[string]interface{}{key[0]: valToMap(key[1:], value)}
}

func ValuesListToMap(values []model.ChartValue, env *model.Environment) (map[string]interface{}, error) {
	var result = make(map[string]interface{})
	for _, value := range values {
		value, err := ResolveValue(value, env)
		if err != nil {
			return nil, err
		}
		result = MergeValues(valToMap(strings.Split(value.Key, "."), value.Value), result)
	}
	return result, nil
}

func LookupValueByString(key string, values map[string]interface{}) interface{} {
	return LookupValueByPath(strings.Split(key, "."), values)
}

func LookupValueByPath(key []string, values map[string]interface{}) *string {
	if len(key) > 0 && values != nil {
		if val := values[key[0]]; val != nil {
			if len(key) == 1 {
				tmp, isStr := val.(string)
				if !isStr {
					return nil
				}
				return &tmp
			}
			nextVal, isMap := val.(map[string]interface{})
			if !isMap {
				return nil
			}
			return LookupValueByPath(key[1:], nextVal)
		}
	}
	return nil
}

func KeyIsInValues(key string, values map[string]interface{}) bool {
	return LookupValueByString(key, values) != nil
}

func GetResolvedValues(release *model.Release) (map[string]interface{}, error) {
	values := make(map[string]interface{})
	forEnv := release.Environment
	if release.Chart != nil && release.Chart.Dir != nil {
		valuesFile := release.AbsPath(model.ResolvePathFromDir("values.yaml", *release.Chart.Dir))
		if pathExists(valuesFile) {
			chartValues, err := LoadValuesFile(valuesFile)
			if err != nil {
				return nil, fmt.Errorf(`failed to load values file %q for chart dir %q: %v`, valuesFile, *release.Chart.Dir, err)
			}
			values = MergeValues(chartValues, values)
		}
	} else if release.Chart != nil && release.Chart.Reference != nil {
		output, err := InspectChart(*release.Chart.Reference, *release.Chart.Version)
		if err != nil {
			return nil, fmt.Errorf(`failed to spect Helm chart %q version %q: %v`, *release.Chart.Reference, *release.Chart.Version, err)
		}
		var chartDefaultValues map[string]interface{}
		if err = yaml.Unmarshal(output, &chartDefaultValues); err != nil {
			return nil, fmt.Errorf(`failed to unmarshal inspected values for chart %q version %q: %v`, *release.Chart.Reference, *release.Chart.Version, err)
		}
	}
	if forEnv != nil && forEnv.DefaultValues != nil {
		envDefaultValues, err := ValuesListToMap(forEnv.DefaultValues, forEnv)
		if err != nil {
			return nil, fmt.Errorf(`failed to resolve defaultValues for env %q and release %q: %v`, forEnv.Name, release.Name, err)
		}
		values = MergeValues(envDefaultValues, values)
	}
	if release.ValuesFile != nil {
		absPath := release.AbsPath(*release.ValuesFile)
		releaseFileValues, err := LoadValuesFile(absPath)
		if err != nil {
			return nil, fmt.Errorf(`failed to load release values file %q for release %q: %v`, absPath, release.Name, err)
		}
		values = MergeValues(releaseFileValues, values)
	}
	if release.Values != nil {
		releaseValues, err := ValuesListToMap(release.Values, forEnv)
		if err != nil {
			return nil, fmt.Errorf(`failed to resolve inline values for release %q: %v`, release.Name, err)
		}
		values = MergeValues(releaseValues, values)
	}
	return values, nil
}

func GetImageRefFromImageTrigger(trigger *model.ImageTrigger, values map[string]interface{}) *image.DockerImageRef {
	repoValue := trigger.RepoValueString()
	repo := LookupValueByString(repoValue, values).(*string)
	if repo == nil {
		return nil
	}
	prefix := LookupValueByString(trigger.RepoPrefixValueString(), values).(*string)
	if prefix != nil {
		*repo = *prefix + *repo
	}
	tag := LookupValueByString(trigger.TagValueString(), values).(*string)
	if tag != nil {
		*repo = *repo + ":" + *tag
	}
	return image.NewDockerImageRef(*repo)
}

func GetImageRefsFromRelease(release *model.Release, values map[string]interface{}) []*image.DockerImageRef {
	result := make([]*image.DockerImageRef, 0)
	for _, trigger := range release.Triggers {
		if trigger.Image == nil {
			continue
		}
		result = append(result, GetImageRefFromImageTrigger(trigger.Image, values))
	}
	return result
}

repository: kubecd/kubecd

repo_name: kubecd/kubecd

gha_language: Go

extension: go


text:
require yum-metadata-parser_${PV}.bb
inherit native
DEPENDS = "python-native sqlite3-native glib-2.0-native libxml2-native"
RDEPENDS_${PN} = ""
PR = "r1"

do_stage() {
	distutils_stage_all
}


text:
Automatically generated by Mendeley Desktop 1.19.4
Any changes to this file will be lost if it is regenerated by Mendeley.

BibTeX export options can be customized via Preferences -> BibTeX in Mendeley Desktop

@article{Peng2002,
abstract = {The purpose of this article is to provide researchers, editors, and readers with a set of guidelines for what to expect in an article using logistic regression techniques. Tables, figures, and charts that should be included to comprehensively assess the results and assumptions to be verified are discussed. This article demonstrates the preferred pattern for the application of logistic methods with an illustration of logistic regression applied to a data set in testing a research hypothesis. Recommendations are also offered for appropriate reporting formats of logistic regression results and the minimum observation-to-predictor ratio. The authors evaluated the use and interpretation of logistic regression presented in 8 articles published in The Journal of Educational Research between 1990 and 2000. They found that all 8 studies met or exceeded recommended criteria. {\textcopyright} 2002 Taylor {\&} Francis Group, LLC.},
author = {Peng, Chao Ying Joanne and Lee, Kuk Lida and Ingersoll, Gary M.},
doi = {10.1080/00220670209598786},
file = {:Users/sepmein/Qsync/Papers/Peng, Lee, Ingersoll{\_}2002{\_}An introduction to logistic regression analysis and reporting.pdf:pdf},
issn = {19400675},
journal = {Journal of Educational Research},
keywords = {Binary data analysis,Categorical variables,Dichotomous outcome,Logistic modeling,Logistic regression},
number = {1},
pages = {3--14},
title = {{An introduction to logistic regression analysis and reporting}},
volume = {96},
year = {2002}
}

license: Unlicense

repository: sepmein/references

repo_name: sepmein/references


text:
SUMMARY = "Pattern matching and various utilities for file systems paths."
SECTION = "devel/python"

HOMEPAGE = "https://pypi.python.org/pypi/pkginfo/"

LICENSE = "Python"
LIC_FILES_CHKSUM = "file://PKG-INFO;beginline=8;endline=8;md5=0e0bd0f50b1af56ec94bf7ead808c804"

SRC_URI = "https://pypi.python.org/packages/source/p/pkginfo/pkginfo-${PV}.tar.gz"

SRC_URI[md5sum] = "4489be0244c003744ca18758fa12e468"
SRC_URI[sha256sum] = "ad3f6dfe8a831f96a7b56a588ca874137ca102cc6b79fc9b0a1c3b7ab7320f3c"

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

inherit setuptools

export BUILD_SYS
export HOST_SYS
export STAGING_INCDIR
export STAGING_LIBDIR

BBCLASSEXTEND = "native"

repository: koenkooi/meta-maker

repo_name: koenkooi/meta-maker

gha_language: BitBake


text:
import gulp from 'gulp';
import path from 'path';
import uglify from 'gulp-uglify';
import config from '../config';

gulp.task('uglify', () => {
  return gulp.src(path.normalize(config.dest.path + '/assets/scripts/main.js'))
    .pipe(uglify())
    .pipe(gulp.dest(path.normalize(config.dest.path + '/assets/scripts')));
});

repository: brunocarneiro/io-extended-init

repo_name: brunocarneiro/io-extended-init

extension: js


text:
package ovh

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"

	"github.com/qdm12/ddns-updater/internal/provider/errors"
)

func extractAPIError(response *http.Response) (err error) {
	decoder := json.NewDecoder(response.Body)
	var apiError struct {
		Message string `json:"Message"`
	}
	err = decoder.Decode(&apiError)
	if err != nil {
		b, err := io.ReadAll(response.Body)
		if err != nil {
			_ = response.Body.Close()
			return fmt.Errorf("reading response body: %w", err)
		}
		apiError.Message = string(b)
	}
	queryID := response.Header.Get("X-Ovh-QueryID")

	_ = response.Body.Close()

	return fmt.Errorf("%w: %s: %s: for query ID: %s",
		errors.ErrHTTPStatusNotValid, response.Status, apiError.Message, queryID)
}


text:
@INPROCEEDINGS{Liu_STGRU_ICDM_2019,
  author={H. {Liu} and H. {Wu} and W. {Sun} and I. {Lee}},
  booktitle={2019 IEEE International Conference on Data Mining (ICDM)},
 title={Spatio-Temporal GRU for Trajectory Classification},
  year={2019},
  volume={},
  number={},
  pages={1228-1233},
  abstract={Spatio-temporal trajectory classification is a fundamental problem for location-based services with many real-world applications such as travel mode classification, animal mobility detection, and location recommendation. In the literature, many approaches have been proposed to solve this classification task including deep learning models like LSTM recently for sequence classification. However, these approaches fail to consider both spatial and temporal interval information simultaneously, but share some common drawbacks: omitting either the spatial information or the temporal interval information out. Some models like Time-LSTM, have been proposed to handle the temporal interval information for spatio-temporal trajectories, but they do not take into account the spatial information. Note that, considering both spatial and temporal interval information is crucial for spatio-temporal data mining in order not to miss any spatio-temporal pattern. In this study, we propose a trajectory classifier called Spatio-Temporal GRU to better model the spatio-temporal correlations and irregular temporal intervals prevalently present in spatio-temporal trajectories. We introduce a novel segmented convolutional weight mechanism to capture short-term local spatial correlations in trajectories and propose an additional temporal gate to control the information flow related to the temporal interval information. Performance evaluation demonstrates that our proposed model outperforms popular deep learning approaches for the travel model classification problem.},
  keywords={data mining;feature extraction;image classification;image motion analysis;learning (artificial intelligence);location based services;recurrent neural nets;spatiotemporal phenomena;spatial information;spatiotemporal data mining;spatiotemporal pattern;spatiotemporal correlations;travel model classification problem;spatiotemporal trajectory classification;spatiotemporal GRU;deep learning;convolutional weight mechanism;LSTM;location based services;sequence classification;trajectory classification;spatio-temporal trajectory;GRU;travel model classification;deep learning},
  doi={10.1109/ICDM.2019.00152},
  ISSN={2374-8486},
  month={Nov},}


text:
package streaming

import (
	"context"
	"time"

	"github.com/pkg/errors"

	"github.com/cube2222/octosql"
	"github.com/cube2222/octosql/execution"
	"github.com/cube2222/octosql/storage"
)

var outputRecordsPrefix = []byte("$output_records$")
var errorPrefix = []byte("$error$")
var endOfStreamPrefix = []byte("$end_of_stream$")

type InstantStreamOutput struct {
	StreamID *execution.StreamID
}

func NewInstantStreamOutput(streamID *execution.StreamID) *InstantStreamOutput {
	return &InstantStreamOutput{
		StreamID: streamID,
	}
}

func (o *InstantStreamOutput) ReadyForMore(ctx context.Context, tx storage.StateTransaction) error {
	return nil
}

func (o *InstantStreamOutput) AddRecord(ctx context.Context, tx storage.StateTransaction, inputIndex int, record *execution.Record) error {
	tx = tx.WithPrefix(o.StreamID.AsPrefix())
	if inputIndex != 0 {
		return errors.Errorf("only one input stream allowed for output, got input index %d", inputIndex)
	}

	outputRecords := execution.NewOutputQueue(tx.WithPrefix(outputRecordsPrefix))
	if err := outputRecords.Push(ctx, record); err != nil {
		return errors.Wrap(err, "couldn't push current record to output queue")
	}

	return nil
}

func (o *InstantStreamOutput) Next(ctx context.Context, tx storage.StateTransaction) (*execution.Record, error) {
	tx = tx.WithPrefix(o.StreamID.AsPrefix())
	// If no element to get and end of stream then end of stream else wait. Also check error.
	records := execution.NewOutputQueue(tx.WithPrefix(outputRecordsPrefix))

	var record execution.Record
	err := records.Pop(ctx, &record)
	if execution.GetErrWaitForChanges(err) != nil {
		errWaitForChanges := err

		var value octosql.Value

		endOfStreamState := storage.NewValueState(tx.WithPrefix(endOfStreamPrefix))
		err := endOfStreamState.Get(&value)
		if err == nil {
			return nil, execution.ErrEndOfStream
		} else if err == storage.ErrNotFound {
		} else if err != nil {
			return nil, errors.Wrap(err, "couldn't check end of stream state")
		}

		errorState := storage.NewValueState(tx.WithPrefix(errorPrefix))
		err = errorState.Get(&value)
		if err == nil {
			return nil, errors.New(value.AsString())
		} else if err == storage.ErrNotFound {
		} else if err != nil {
			return nil, errors.Wrap(err, "couldn't check end of stream state")
		}

		return nil, errWaitForChanges
	} else if err != nil {
		return nil, errors.Wrap(err, "couldn't get record from records queue")
	}

	return &record, nil
}

func (o *InstantStreamOutput) UpdateWatermark(ctx context.Context, tx storage.StateTransaction, watermark time.Time) error {
	return nil
}

func (o *InstantStreamOutput) TriggerKeys(ctx context.Context, tx storage.StateTransaction, batchSize int) (int, error) {
	return 0, nil
}

func (o *InstantStreamOutput) GetWatermark(ctx context.Context, tx storage.StateTransaction) (time.Time, error) {
	panic("stream output shouldn't ever be asked about watermark")
}

func (o *InstantStreamOutput) MarkEndOfStream(ctx context.Context, tx storage.StateTransaction) error {
	tx = tx.WithPrefix(o.StreamID.AsPrefix())
	endOfStreamState := storage.NewValueState(tx.WithPrefix(endOfStreamPrefix))

	phantom := octosql.MakePhantom()
	if err := endOfStreamState.Set(&phantom); err != nil {
		return errors.Wrap(err, "couldn't mark end of stream")
	}

	return nil
}

func (o *InstantStreamOutput) GetEndOfStream(ctx context.Context, tx storage.StateTransaction) (bool, error) {
	tx = tx.WithPrefix(o.StreamID.AsPrefix())
	endOfStreamState := storage.NewValueState(tx.WithPrefix(endOfStreamPrefix))

	var octoEndOfStream octosql.Value
	err := endOfStreamState.Get(&octoEndOfStream)
	if err == storage.ErrNotFound {
		return false, nil
	} else if err != nil {
		return false, errors.Wrap(err, "couldn't get end of stream value")
	}

	return true, nil
}

func (o *InstantStreamOutput) MarkError(ctx context.Context, tx storage.StateTransaction, err error) error {
	tx = tx.WithPrefix(o.StreamID.AsPrefix())
	errorState := storage.NewValueState(tx.WithPrefix(errorPrefix))

	octoError := octosql.MakeString(err.Error())
	if err := errorState.Set(&octoError); err != nil {
		return errors.Wrap(err, "couldn't mark error")
	}

	return nil
}

func (o *InstantStreamOutput) GetErrorMessage(ctx context.Context, tx storage.StateTransaction) (string, error) {
	tx = tx.WithPrefix(o.StreamID.AsPrefix())
	errorState := storage.NewValueState(tx.WithPrefix(errorPrefix))

	var octoError octosql.Value
	err := errorState.Get(&octoError)
	if err == storage.ErrNotFound {
		return "", nil
	} else if err != nil {
		return "", errors.Wrap(err, "couldn't get error message")
	}

	return octoError.AsString(), nil
}

func (o *InstantStreamOutput) Close(ctx context.Context, storage storage.Storage) error {
	if err := storage.DropAll(o.StreamID.AsPrefix()); err != nil {
		return errors.Wrap(err, "couldn't clear storage with streamID prefix")
	}

	return nil
}

repository: fossabot/octosql

repo_name: fossabot/octosql


text:
DESCRIPTION = "rootkit detector"
SUMMARY = "locally checks for signs of a rootkit"
HOMEPAGE = "http://www.chkrootkit.org/"
SECTION = "security"
LICENSE = "GPLv2.0"
LIC_FILES_CHKSUM = "file://COPYRIGHT;md5=fdbe53788f7081c63387d8087273f5ff"

SRC_URI = "https://fossies.org/linux/misc/${BP}.tar.gz"
SRC_URI[md5sum] = "f021156de4ad6dff0eda3399228f6cb9"
SRC_URI[sha256sum] = "8301782051f0b8cd213c323624d42fbecd101a583646caef126166dc2852fc25"

inherit autotools-brokensep

TARGET_CC_ARCH += "${LDFLAGS}"

do_configure () {
    sed -i 's/@strip.*$//' ${S}/Makefile
}

do_compile () {
    make CC="${CC}" LDFLAGS="${LDFLAGS}" sense
    gzip -9vkf ACKNOWLEDGMENTS
    gzip -9vkf README
}

do_install () {
    install -d ${D}/${libdir}/${PN}
    install -d ${D}/${sbindir}
    install -d ${D}/${docdir}/${PN}

    install -m 644 ${B}/chkdirs ${D}/${libdir}/${PN}
    install -m 644 ${B}/chklastlog ${D}/${libdir}/${PN}
    install -m 644 ${B}/chkproc ${D}/${libdir}/${PN}
    install -m 644 ${B}/chkutmp ${D}/${libdir}/${PN}
    install -m 644 ${B}/chkwtmp ${D}/${libdir}/${PN}
    install -m 644 ${B}/ifpromisc ${D}/${libdir}/${PN}
    install -m 644 ${B}/strings-static ${D}/${libdir}/${PN}

    install -m 755 ${B}/chklastlog ${D}/${sbindir}
    install -m 755 ${B}/chkrootkit ${D}/${sbindir}
    install -m 755 ${B}/chkwtmp ${D}/${sbindir}

    install -m 644 ${B}/ACKNOWLEDGMENTS.gz ${D}/${docdir}/${PN}
    install -m 644 ${B}/README.chklastlog ${D}/${docdir}/${PN}
    install -m 644 ${B}/README.chkwtmp ${D}/${docdir}/${PN}
    install -m 644 ${B}/README.gz ${D}/${docdir}/${PN}
    install -m 644 ${B}/COPYRIGHT ${D}/${docdir}/${PN}
}

repository: akuster/meta-kali

repo_name: akuster/meta-kali


text:
SUMMARY = "AGL SOTA Package Group"
DESCRIPTION = "A set of packages belong to GENIVI SOTA Project and OSTree"

LICENSE = "MIT"

inherit packagegroup

PACKAGES = " packagegroup-agl-sota "

ALLOW_EMPTY_${PN} = "1"

RDEPENDS_${PN} += "\
    ota-plus-client \
    ota-plus-demo-provision \
    ostree \
    ostree-basic-pkg \
"

repository: leon-anavi/meta-ota-plus

repo_name: leon-anavi/meta-ota-plus


text:
require libgpg-error.inc

PR = "${INC_PR}.1"

SRC_URI[md5sum] = "aae34a35b00c547f2e41c747cf87f8b7"
SRC_URI[sha256sum] = "d815a1a5445fc26de5c7b10192acb77cf4277a100124842b616f85a5a4fbfe3b"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
SUMMARY = "Backend for WPE with specific support for embedded devices used on the RDK"
HOMEPAGE = "https://github.com/WebPlatformForEmbedded/WPEBackend-rdk"
BUGTRACKER = "https://github.com/WebPlatformForEmbedded/WPEBackend-rdk/issues"

LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://src/wayland/display.h;;beginline=5;endline=24;md5=b1c8cb6b0857048a21b33611f01c575a"

DEPENDS = "libwpe glib-2.0 libinput"
PROVIDES += "virtual/wpebackend"
RPROVIDES_${PN} += "virtual/wpebackend"

PV = "1.20180925"
SRCREV = "8ea61fbdee554a7cb2d1c1cbc53ce0868aaca304"

SRC_URI = "git://github.com/WebPlatformForEmbedded/WPEBackend-rdk.git;protocol=https;branch=master"

S = "${WORKDIR}/git"

inherit cmake pkgconfig

PACKAGECONFIG ?= "wayland"

# device specific backends
PACKAGECONFIG[intelce] = "-DUSE_BACKEND_INTEL_CE=ON -DUSE_KEY_INPUT_HANDLING_LINUX_INPUT=ON,,intelce-display"
PACKAGECONFIG[nexus] = "-DUSE_BACKEND_BCM_NEXUS=ON -DUSE_KEY_INPUT_HANDLING_LINUX_INPUT=ON,,broadcom-refsw"
PACKAGECONFIG[rpi] = "-DUSE_BACKEND_BCM_RPI=ON -DUSE_KEY_INPUT_HANDLING_LINUX_INPUT=ON,,userland"
PACKAGECONFIG[stm] = "-DUSE_BACKEND_STM=ON -DUSE_KEY_INPUT_HANDLING_LINUX_INPUT=OFF,,libxkbcommon"
PACKAGECONFIG[imx6] =  "-DUSE_BACKEND_VIV_IMX6_EGL=ON -DUSE_KEY_INPUT_HANDLING_LINUX_INPUT=ON,,imx-gpu-viv"

# Wayland selectors
PACKAGECONFIG[wayland] = "-DUSE_BACKEND_WAYLAND_EGL=ON -DUSE_KEY_INPUT_HANDLING_LINUX_INPUT=OFF,,wayland libxkbcommon"
PACKAGECONFIG[realtek] = "-DUSE_BACKEND_REALTEK=ON -DUSE_KEY_INPUT_HANDLING_LINUX_INPUT=OFF,,wayland libxkbcommon"
PACKAGECONFIG[westeros] = "-DUSE_BACKEND_WESTEROS=ON -DUSE_BACKEND_BCM_RPI=OFF -DUSE_KEY_INPUT_HANDLING_LINUX_INPUT=OFF -DUSE_WESTEROS_SINK=ON,,wayland westeros libxkbcommon"
PACKAGECONFIG[bcm-weston] = "-DUSE_BACKEND_BCM_NEXUS_WAYLAND=ON,-DUSE_BACKEND_BCM_NEXUS_WAYLAND=OFF,,"
PACKAGECONFIG[westeros-mesa] = "-DUSE_BACKEND_WESTEROS_MESA=ON,,"

do_install() {
	install -d ${D}${libdir}
	install -m 0755 ${B}/libWPEBackend-*.so ${D}${libdir}/
}

FILES_SOLIBSDEV = ""
FILES_${PN} += "${libdir}/libWPEBackend-default.so ${libdir}/libWPEBackend-rdk.so"
INSANE_SKIP ="dev-so"

repository: estobbart/meta-webkit

repo_name: estobbart/meta-webkit


text:
DESCRIPTION = "Marvell kernel module for Wifi"
HOMEPAGE = "http://marvell.com/"
MAINTAINER = "Dvorkin Dmitry <dvorkin@tibbo.com>"
SECTION = "kernel/modules"
PRIORITY = "optional"
LICENSE = "GPL-2.0"
PR = "r1"

# if src in /files/marvell-wlan-module/*
#S = "${WORKDIR}/${PN}"
S = "${WORKDIR}/"
# if src in /files/marvell-wlan-module-${PV}/*
#S = "${WORKDIR}/${PN}-${PV}"

SRC_URI = "file://*"

do_install() {
 install -m 0755 -d ${D}${base_libdir}/firmware
 install -m 0644 ${S}/sd8787_uapsta.bin ${D}${base_libdir}/firmware/
}

#INITSCRIPT_NAME = "${PN}"
#INITSCRIPT_PARAMS = "defaults 05"

FILES_${PN} += "/lib/firmware/sd8787_uapsta.bin"

# add this (but not used?)
#RDEPENDS_${PN} += "linux-firmware-sd8787"

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


text:
@article{McKenzie-2021-Invited,
    title = "Invited perspective: What lies beneath a changing Arctic?",
    author = "McKenzie, Jeffrey M.  and
      Kurylyk, Barret L.  and
      Walvoord, Michelle A.  and
      Bense, Victor F.  and
      Fortier, Daniel  and
      Spence, Christopher  and
      Grenier, Christophe",
    journal = "The Cryosphere, Volume 15, Issue 1",
    volume = "15",
    number = "1",
    year = "2021",
    publisher = "Copernicus GmbH",
    url = "https://aclanthology.org/G21-93001",
    doi = "10.5194/tc-15-479-2021",
    pages = "479--484",
    abstract = "Abstract. As permafrost thaws in the Arctic, new subsurface pathways open for the transport of groundwater, energy, and solutes. We identify different ways that these subsurface changes are driving observed surface consequences, including the potential for increased contaminant transport, modification to water resources, and enhanced rates of infrastructure (e.g. buildings and roads) damage. Further, as permafrost thaws it allows groundwater to transport carbon, nutrients, and other dissolved constituents from terrestrial to aquatic environments via progressively deeper subsurface flow paths. Cryohydrogeology, the study of groundwater in cold regions, should be included in northern research initiatives to account for this hidden catalyst of environmental and societal change.",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

branch_name: refs/heads/main


text:
@article{ross2016comparative,
 author = {Ross, Daniel E and Marshall, Christopher W and May, Harold D and Norman, R Sean},
 journal = {PLoS One},
 number = {3},
 pages = {e0151214},
 publisher = {Public Library of Science San Francisco, CA USA},
 title = {Comparative genomic analysis of Sulfurospirillum cavolei MES reconstructed from the metagenome of an electrosynthetic microbiome},
 volume = {11},
 year = {2016}
}

repository: sirmicrobe/labofmarshall

repo_name: sirmicrobe/labofmarshall


text:
var Model = class {
	constructor(code) {
		var rs;
		var code = new String(code);
		if(code.length < 5) {
			var fill = 6 - code.length;
			code = new Array(fill).join('0') + code;
		}
		if(Model.CODE[code]) {
			rs = new Error(Model.CODE[code]);
			rs.code = code;
		}
		else {
			code = '00000';
			rs = new Error(Model.CODE[code]);
			rs.code = code;
		}
		return rs
	}
};
Model.CODE = {
	'00000': 'unknown exception',
	'00001': 'timeout',
	'00002': 'command not found',
	'01001': 'DB write error',
	'01002': 'DB read error',
	'01003': 'DB update error',
	'01004': 'DB delete error',
	'10101': 'invalid hashcash',
	'10201': 'invalid token',
	'10301': 'invalid verify code',
	'12001': 'invalid email',
	'19101': 'incorrect account/password',
	'19102': 'invalid user data',
	'19103': 'incorrect old password',
	'19104': 'incorrect reset code',
	'22001': 'occupied email',
	'29101': 'duplicate user data',
	'39101': 'register data not found',
	'39102': 'user not found',
	'42001': 'email quota exceeded',
	'40301': 'verification failed too many times',
	'49101': 'login failed too many times',
	'49102': 'reset failed too many times',
	'70201': 'Overdue token'
};

module.exports = Model;

repository: Luphia/SIMPLE

repo_name: Luphia/SIMPLE


text:
@phdthesis{giudici2019diss,
author = {Giudici, Anja},
keywords = {literature,mio},
mendeley-tags = {literature,mio},
school = {University of Zurich},
title = {{Explaining Swiss language education policy}},
type = {Dissertation},
url = {https://www.zora.uzh.ch/id/eprint/166199/},
year = {2019}
}

repository: anjagiudici/academic-kickstart

repo_name: anjagiudici/academic-kickstart


text:
// Code generated by genny. DO NOT EDIT.
// This file was automatically generated by genny.
// Any changes will be lost if this file is regenerated.
// see https://github.com/mauricelam/genny

package bugreports

func ContainsString(slice []string, element string) bool {
	return false
}

// ContainsAllString targets github issue 36
func ContainsAllString(slice []string, other []string) bool {
	for _, e := range other {
		if !ContainsString(slice, e) {
			return false
		}
	}
	return true
}

repository: mauricelam/genny

repo_name: mauricelam/genny


text:
* {
  font-family: "Roboto", "Microsoft YaHei", "Lucida Grande", "DejaVu Sans", "Bitstream Vera Sans", Verdana, Arial, sans-serif;
}

body {
  margin: 0;
  padding: 0;
  width: 100%;
}

.flex-center {
  display: flex;
  align-items: center;
  justify-content: center;
}

#navbar {
  position: relative;
}

.nav-title a {
  color: #fff;
  text-decoration: none;
}

extension: css


text:
module.exports = {
  env: {
    development: {
      plugins: [
        'react-hot-loader/babel',
      ],
      presets: [
        ['@babel/env', { targets: { browsers: 'last 2 years' } }],
        '@babel/react',
        '@babel/typescript',
      ],
    },
    test: {
      plugins: [
        'dynamic-import-node',
        'transform-es2015-modules-commonjs',
      ],
      presets: [
        ['@babel/env', { targets: { node: 'current' } }],
        '@babel/react',
        '@babel/typescript',
      ],
    },
  },
  plugins: [
    '@babel/proposal-class-properties',
    '@babel/proposal-object-rest-spread',
    '@babel/proposal-unicode-property-regex',
    '@babel/syntax-dynamic-import',
  ]
}

repository: hubgit/manuscripts-manuscript-editor

repo_name: hubgit/manuscripts-manuscript-editor

gha_language: TypeScript


text:
@InProceedings{Johnson_2015_CVPR,
    author = {Johnson, Justin and Krishna, Ranjay and Stark, Michael and Li, Li-Jia and Shamma, David and Bernstein, Michael and Fei-Fei, Li},
    title = {Image Retrieval Using Scene Graphs},
    booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
    month = {June},
    year = {2015}
}

@inproceedings{krahenbuhl2014geodesic,
  title={Geodesic object proposals},
  author={Kr{\"a}henb{\"u}hl, Philipp and Koltun, Vladlen},
  booktitle={European conference on computer vision},
  pages={725--739},
  year={2014},
  organization={Springer}
}

@article{lowe2004distinctive,
  title={Distinctive image features from scale-invariant keypoints},
  author={Lowe, David G},
  journal={International journal of computer vision},
  volume={60},
  number={2},
  pages={91--110},
  year={2004},
  publisher={Springer}
}

@article{oliva2001modeling,
  title={Modeling the shape of the scene: A holistic representation of the spatial envelope},
  author={Oliva, Aude and Torralba, Antonio},
  journal={International journal of computer vision},
  volume={42},
  number={3},
  pages={145--175},
  year={2001},
  publisher={Springer}
}

url: https://raw.githubusercontent.com/GangaMegha/Computer_Vision_Papers/e11f02d7c68b0be6d91db79dd5266a01b215e8a8/Image Retrieval using Scene Graphs/Latex files/ref.bib