text:
package easygolang

import (
	"fmt"
	"regexp"
	"strings"
	"unicode/utf8"
)

func StringFormat(format string, args ...interface{}) string {
	return fmt.Sprintf(format, args...)
}

func StringLength(str string) int {
	runes := []rune(str)
	return len(runes)
}

//result from 1, end can be 0
func StringPart(str string, start int, end int) string {
	runes := []rune(str)
	rsize := len(runes)
	if rsize > 0 {
		start0 := MAXI(start, 1)
		if start0 <= rsize {
			end0 := MINI(MAXI(end, 1), rsize)
			if end > 0 {
				if end0 >= start0 {
					return string(runes[start0-1 : end0])
				} else {
					return ""
				}
			} else {
				return string(runes[start0-1:])
			}
		} else {
			return ""
		}
	} else {
		return ""
	}
}

func StringEnd(str string, count int) string {
	runes := []rune(str)
	rsize := len(runes)
	esize := MINI(MAXI(count, 0), rsize)
	if rsize == 0 || esize == 0 {
		return ""
	}
	if rsize == esize {
		return str
	}
	return string(runes[rsize-esize:])
}

func StringFill(str string, length int) string {
	return fmt.Sprintf("%"+I2S(length)+"s", str)
}

func StringClip(str string, maxlen int) string {
	if StringLength(str) > maxlen {
		return StringPart(str, 1, maxlen)
	} else {
		return str
	}
}

func StringJoin(target []string, separator string) string {
	return strings.Join(target, separator)
}

func StringSplit(target string, separator string) []string {
	return strings.Split(target, separator)
}

func StringSplitLines(target string) []string {
	return strings.Split(target, "\n")
}

func StringReplace(str string, from string, to string) string {
	return strings.Replace(str, from, to, -1)
}

//not found 0, start from 1
func StringFind(where string, what string) int {
	ind := strings.Index(where, what)
	if ind > -1 {
		return utf8.RuneCountInString(where[:ind]) + 1
	} else {
		return 0
	}
}

//not found 0, start from 1
func StringFindEnd(where string, what string) int {
	ind := strings.LastIndex(where, what)
	if ind > -1 {
		return utf8.RuneCountInString(where[:ind]) + 1
	} else {
		return 0
	}
}

func StringUp(str string) string {
	return strings.ToUpper(str)
}

func StringDown(str string) string {
	return strings.ToLower(str)
}

func StringTitle(str string) string {
	return strings.Title(str)
}

func StringTrim(str string) string {
	return strings.TrimSpace(str)
}

func StringRemoveDoubleChar(str string, one_char string) string {
	chars := one_char + one_char
	str2 := ""
	str3 := str
	for str3 != str2 {
		str2 = str3
		str3 = StringReplace(str2, chars, one_char)
	}
	return str3
}

func StringCommonPrefix(a string, b string) string {
	r1 := []rune(a)
	r2 := []rune(b)
	min_len := MINI(len(r1), len(r2))
	res := ""
	j := 0
	for j < min_len && r1[j] == r2[j] {
		res += string(r1[j])
		j++
	}
	return res
}

func StringCommonPrefixArr(a []string) string {
	lena := len(a)
	if lena == 0 {
		return ""
	}
	if lena == 1 {
		return a[0]
	}
	min_len := len(a[0])
	r := make([][]rune, lena)
	for j := 0; j < lena; j++ {
		r[j] = []rune(a[j])
		min_len = MINI(min_len, len(r[j]))
	}
	res := ""
	j := 0
	ok := true
	for j < min_len && ok {
		for k := 1; k < lena; k++ {
			if r[k-1][j] != r[k][j] {
				ok = false
			}
		}
		if ok {
			res += string(r[0][j])
			j++
		}
	}
	return res
}

func StringInArray(val string, array []string) int {
	for i := range array {
		if ok := array[i] == val; ok {
			return i
		}
	}
	return -1
}

var utf8_bom = string([]byte{239, 187, 191}) // UTF-8 specific

func StringFixUTF8(line string) string {
	return strings.TrimPrefix(line, utf8_bom)
}

// ======

type RegExp struct {
	r *regexp.Regexp
}

func StringFilterCompile(pattern string) RegExp {
	return RegExp{regexp.MustCompile(pattern)}
}

func StringFilter(str string, reg RegExp) string {
	return reg.r.ReplaceAllString(str, "")
}

repository: SilentGopherLnx/easygolang

repo_name: SilentGopherLnx/easygolang


text:
DESCRIPTION = "Connection tracking userspace tools for Linux"
LICENSE = "GPL"
DEPENDS = "libnfnetlink libnetfilter-conntrack"

PR = "r2"

SRC_URI = " \
	http://www.netfilter.org/projects/conntrack-tools/files/conntrack-tools-${PV}.tar.bz2;name=tar \
	file://conntrack-failover \
	file://init \
	"
SRC_URI[tar.md5sum] = "7e9344fe85bb68bcf65c35034add6655"
SRC_URI[tar.sha256sum] = "2e36744da83eb2e6e54a5769aa1abf044d53089470d646898222936e7e8da6ac"

inherit autotools
inherit update-rc.d

INITSCRIPT_NAME = "conntrackd"

do_install_append() {
	install -d ${D}/${sysconfdir}/conntrackd
	install -d ${D}/${sysconfdir}/init.d
	install -m 0644 doc/sync/ftfw/conntrackd.conf ${D}/${sysconfdir}/conntrackd/conntrackd.conf.sample
	install -m 0755 ${WORKDIR}/conntrack-failover ${D}/${sysconfdir}/init.d/conntrack-failover
	install -m 0755 ${WORKDIR}/init ${D}/${sysconfdir}/init.d/conntrackd
}

license: MIT

repository: overo/overo-oe-natty

license_type: permissive

repo_name: overo/overo-oe-natty

branch_name: HEAD

extension: bb


text:
include(ghex_compile_options)

# ---------------------------------------------------------------------
# interface library
# ---------------------------------------------------------------------
add_library(ghex_common INTERFACE)
add_library(GHEX::ghex ALIAS ghex_common)

# ---------------------------------------------------------------------
# shared library
# ---------------------------------------------------------------------
add_library(ghex SHARED)
add_library(GHEX::lib ALIAS ghex)
target_link_libraries(ghex PUBLIC ghex_common)
ghex_target_compile_options(ghex)

# ---------------------------------------------------------------------
# device setup
# ---------------------------------------------------------------------
include(ghex_device)
if (ghex_gpu_mode STREQUAL "hip")
    target_link_libraries(ghex PUBLIC hip::device)
endif()

# ---------------------------------------------------------------------
# MPI setup
# ---------------------------------------------------------------------
find_package(MPI REQUIRED)
target_link_libraries(ghex_common INTERFACE MPI::MPI_CXX)
target_link_libraries(ghex PRIVATE MPI::MPI_CXX)

# ---------------------------------------------------------------------
# Boost setup
# ---------------------------------------------------------------------
find_package(Boost REQUIRED)
target_link_libraries(ghex_common INTERFACE Boost::boost)

# ---------------------------------------------------------------------
# LibRt setup
# ---------------------------------------------------------------------
find_library(LIBRT rt REQUIRED)
target_link_libraries(ghex PUBLIC ${LIBRT})

# ---------------------------------------------------------------------
# GridTools setup
# ---------------------------------------------------------------------
include(ghex_gridtools)
target_link_libraries(ghex_common INTERFACE GridTools::gridtools)

# ---------------------------------------------------------------------
# oomph setup
# ---------------------------------------------------------------------
include(ghex_oomph)
target_link_libraries(ghex_common INTERFACE oomph::oomph)

# ---------------------------------------------------------------------
# general RMA setup
# ---------------------------------------------------------------------
set(GHEX_NO_RMA OFF CACHE BOOL "Disable in-node RMA completely")

# ---------------------------------------------------------------------
# xpmem setup
# ---------------------------------------------------------------------
set(GHEX_USE_XPMEM OFF CACHE BOOL "Set to true to use xpmem shared memory")
if (GHEX_USE_XPMEM)
    find_package(XPMEM REQUIRED)
    target_link_libraries(ghex_common INTERFACE XPMEM::libxpmem)
    target_link_libraries(ghex PRIVATE XPMEM::libxpmem)
endif()
set(GHEX_USE_XPMEM_ACCESS_GUARD OFF CACHE BOOL "Use xpmem to synchronize rma access")
mark_as_advanced(GHEX_USE_XPMEM_ACCESS_GUARD)

# ---------------------------------------------------------------------
# parmetis setup
# ---------------------------------------------------------------------
set(GHEX_ENABLE_PARMETIS_BINDINGS OFF CACHE BOOL "Set to true to build with ParMETIS bindings")
if (GHEX_ENABLE_PARMETIS_BINDINGS)
    set(METIS_INCLUDE_DIR "" CACHE STRING "METIS include directory")
    set(METIS_LIB_DIR "" CACHE STRING "METIS library directory")
    set(PARMETIS_INCLUDE_DIR "" CACHE STRING "ParMETIS include directory")
    set(PARMETIS_LIB_DIR "" CACHE STRING "ParMETIS library directory")
endif()

# ---------------------------------------------------------------------
# atlas setup
# ---------------------------------------------------------------------
set(GHEX_ENABLE_ATLAS_BINDINGS OFF CACHE BOOL "Set to true to build with Atlas bindings")
if (GHEX_ENABLE_ATLAS_BINDINGS)
    find_package(eckit REQUIRED HINTS ${eckit_DIR})
    find_package(Atlas REQUIRED HINTS ${Atlas_DIR})
    set(GHEX_ATLAS_GT_STORAGE_CPU_BACKEND "KFIRST" CACHE STRING "GridTools CPU storage traits: KFIRST | IFIRST.")
    set_property(CACHE GHEX_ATLAS_GT_STORAGE_CPU_BACKEND PROPERTY STRINGS "KFIRST" "IFIRST")
    # Temporary workaround to fix missing dependency in Atlas target: eckit
    target_link_libraries(atlas INTERFACE eckit)
    target_link_libraries(ghex_common INTERFACE atlas)

    if (GHEX_ATLAS_GT_STORAGE_CPU_BACKEND STREQUAL "KFIRST")
        set(GHEX_ATLAS_GT_STORAGE_CPU_BACKEND_KFIRST ON)
        set(GHEX_ATLAS_GT_STORAGE_CPU_BACKEND_IFIRST OFF)
    elseif(GHEX_ATLAS_GT_STORAGE_CPU_BACKEND STREQUAL "IFIRST")
        set(GHEX_ATLAS_GT_STORAGE_CPU_BACKEND_KFIRST OFF)
        set(GHEX_ATLAS_GT_STORAGE_CPU_BACKEND_IFIRST ON)
    else()
        set(GHEX_ATLAS_GT_STORAGE_CPU_BACKEND_KFIRST OFF)
        set(GHEX_ATLAS_GT_STORAGE_CPU_BACKEND_IFIRST OFF)
    endif()
endif()

# ---------------------------------------------------------------------
# install rules
# ---------------------------------------------------------------------
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)

install(TARGETS ghex_common ghex
    EXPORT ghex-targets
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})

install(DIRECTORY include/
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

repository: bettiolm/GHEX

repo_name: bettiolm/GHEX

branch_name: refs/heads/master

gha_license_id: NOASSERTION

extension: cmake


text:
@proceedings{ws-2012-naacl-hlt-2012,
    title = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    editor = "Elson, David  and
      Kazantseva, Anna  and
      Mihalcea, Rada  and
      Szpakowicz, Stan",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2500",
}
@inproceedings{lee-etal-2012-computational,
    title = "Computational Analysis of Referring Expressions in Narratives of Picture Books",
    author = "Lee, Choonkyu  and
      Muresan, Smaranda  and
      Stromswold, Karin",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2501",
    pages = "1--7",
}
@inproceedings{kao-jurafsky-2012-computational,
    title = "A Computational Analysis of Style, Affect, and Imagery in Contemporary Poetry",
    author = "Kao, Justine  and
      Jurafsky, Dan",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2502",
    pages = "8--17",
}
@inproceedings{voigt-jurafsky-2012-towards,
    title = "Towards a Literary Machine Translation: The Role of Referential Cohesion",
    author = "Voigt, Rob  and
      Jurafsky, Dan",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2503",
    pages = "18--25",
}
@inproceedings{brooke-etal-2012-unsupervised,
    title = "Unsupervised Stylistic Segmentation of Poetry with Change Curves and Extrinsic Features",
    author = "Brooke, Julian  and
      Hammond, Adam  and
      Hirst, Graeme",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2504",
    pages = "26--35",
}
@inproceedings{yu-etal-2012-aligning,
    title = "Aligning Bilingual Literary Works: a Pilot Study",
    author = "Yu, Qian  and
      Max, Aur{\'e}lien  and
      Yvon, Fran{\c{c}}ois",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2505",
    pages = "36--44",
}
@inproceedings{yu-2012-function,
    title = "Function Words for {C}hinese Authorship Attribution",
    author = "Yu, Bei",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2506",
    pages = "45--53",
}
@inproceedings{sogaard-2012-mining,
    title = "Mining wisdom",
    author = "S{\o}gaard, Anders",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2507",
    pages = "54--58",
}
@inproceedings{van-cranenburgh-2012-literary,
    title = "Literary authorship attribution with phrase-structure fragments",
    author = "van Cranenburgh, Andreas",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2508",
    pages = "59--63",
}
@inproceedings{irvine-etal-2012-digitizing,
    title = "Digitizing 18th-Century {F}rench Literature: Comparing transcription methods for a critical edition text",
    author = "Irvine, Ann  and
      Marcellesi, Laure  and
      Zomorodian, Afra",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2509",
    pages = "64--68",
}
@inproceedings{bendersky-smith-2012-dictionary,
    title = "A Dictionary of Wisdom and Wit: Learning to Extract Quotable Phrases",
    author = "Bendersky, Michael  and
      Smith, David",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2510",
    pages = "69--77",
}
@inproceedings{zaghouani-etal-2012-pilot,
    title = "A Pilot {P}rop{B}ank Annotation for Quranic {A}rabic",
    author = "Zaghouani, Wajdi  and
      Hawwari, Abdelati  and
      Diab, Mona",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2511",
    pages = "78--83",
}
@inproceedings{kushkuley-2012-trend,
    title = "Trend Analysis in Harper{'}s Bazaar",
    author = "Kushkuley, Sophie",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2512",
    pages = "84--87",
}
@inproceedings{agarwal-etal-2012-social,
    title = "Social Network Analysis of Alice in Wonderland",
    author = "Agarwal, Apoorv  and
      Corvalan, Augusto  and
      Jensen, Jacob  and
      Rambow, Owen",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2513",
    pages = "88--96",
}
@inproceedings{roque-2012-towards,
    title = "Towards a computational approach to literary text analysis",
    author = "Roque, Antonio",
    booktitle = "Proceedings of the {NAACL}-{HLT} 2012 Workshop on Computational Linguistics for Literature",
    month = jun,
    year = "2012",
    address = "Montr{\'e}al, Canada",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-2514",
    pages = "97--104",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings

gha_language: TeX

extension: bib


text:
package main

import (
	"os/exec"
	"syscall"
)

func getExitCodeFromError(err error) (int, bool) {
	if exiterr, ok := err.(*exec.ExitError); ok {
		if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
			return status.ExitStatus(), true
		}
	}
	return 0, false
}

repository: golang-devops/exec-logger

repo_name: golang-devops/exec-logger

extension: go


text:
# Only search for clang-tidy if user has not supplied it through CMAKE_CXX_CLANG_TIDY
if(NOT DEFINED CMAKE_CXX_CLANG_TIDY)
    find_program(PTL_CLANG_TIDY_COMMAND NAMES
        clang-tidy
        clang-tidy-12
        clang-tidy-11
        clang-tidy-10
        clang-tidy-9
        clang-tidy-8
        clang-tidy-7)
    mark_as_advanced(PTL_CLANG_TIDY_COMMAND)
    if(NOT PTL_CLANG_TIDY_COMMAND)
       message(FATAL_ERROR "PTL_USE_CLANG_TIDY is ON, but no clang-tidy program could be found")
    endif()
    set(CMAKE_CXX_CLANG_TIDY "${PTL_CLANG_TIDY_COMMAND}")
endif()

# Create a preprocessor definition that depends on .clang-tidy content so
# the compile command will change when .clang-tidy changes. Nothing actually uses this
# definition, it is simply added to trigger a rebuild when *only* .clang-tidy changes.
file(SHA1 ${PROJECT_SOURCE_DIR}/.clang-tidy __ptl_clang_tidy_sha1)
add_compile_definitions("PTL_CLANG_TIDY_SHA1=${__ptl_clang_tidy_sha1}")
unset(__ptl_clang_tidy_sha1)
configure_file(${PROJECT_SOURCE_DIR}/.clang-tidy ${PROJECT_SOURCE_DIR}/.clang-tidy COPYONLY)

repository: bingyingL/PTL

repo_name: bingyingL/PTL


text:
@article{Sun-2021-Hydrological,
    title = "Hydrological evaluation of high-resolution precipitation estimates from the WRF model in the Third Pole river basins",
    author = "Sun, He  and
      Su, Fengge  and
      He, Zhihua  and
      Ou, Tinghai  and
      Chen, Deliang  and
      Li, Zhenhua  and
      Li, Yanping",
    journal = "Journal of Hydrometeorology",
    year = "2021",
    publisher = "American Meteorological Society",
    url = "https://aclanthology.org/G21-29003",
    doi = "10.1175/jhm-d-20-0272.1",
    abstract = "Abstract In this study, two sets of precipitation estimates based on the regional Weather Research and Forecasting model (WRF) {--}the high Asia refined analysis (HAR) and outputs with a 9 km resolution from WRF (WRF-9km) are evaluated at both basin and point scales, and their potential hydrological utilities are investigated by driving the Variable Infiltration Capacity (VIC) large-scale land surface hydrological model in seven Third Pole (TP) basins. The regional climate model (RCM) tends to overestimate the gauge-based estimates by 20{--}95{\%} in annual means among the selected basins. Relative to the gauge observations, the RCM precipitation estimates can accurately detect daily precipitation events of varying intensities (with absolute bias {\textless} 3 mm). The WRF-9km exhibits a high potential for hydrological application in the monsoon-dominated basins in the southeastern TP (with NSE of 0.7{--}0.9 and bias of -11{\%} to 3{\%}), while the HAR performs well in the upper Indus (UI) and upper Brahmaputra (UB) basins (with NSE of 0.6 and bias of -15{\%} to -9{\%}). Both the RCM precipitation estimates can accurately capture the magnitudes of low and moderate daily streamflow, but show limited capabilities in flood prediction in most of the TP basins. This study provides a comprehensive evaluation of the strength and limitation of RCMs precipitation in hydrological modeling in the TP with complex terrains and sparse gauge observations.",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

branch_name: refs/heads/main

gha_language: Python


text:
SECTION = "devel/chicken"
DESCRIPTION = "A library for writing wmii configuration scripts"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://wmiirc.meta;md5=1432366e6f5b037b936ee7b072d1f3cb"
DEPENDS_append_class-cross = " chicken-egg-9p-cross chicken-egg-unix-sockets-cross"
DEPENDS_append_class-crosssdk = " chicken-egg-9p-crosssdk chicken-egg-unix-sockets-crosssdk"
DEPENDS_append_class-nativesdk = " nativesdk-chicken-egg-9p nativesdk-chicken-egg-unix-sockets chicken-egg-9p-crosssdk chicken-egg-unix-sockets-crosssdk"
DEPENDS = " chicken-egg-9p chicken-egg-unix-sockets chicken-egg-9p-cross chicken-egg-unix-sockets-cross"
RDEPENDS_${PN} = " chicken-egg-9p chicken-egg-unix-sockets"

SRC_URI = "http://code.call-cc.org/egg-tarballs/4/wmiirc/wmiirc-${PV}.tar.gz"

SRC_URI[md5sum] = "0f3016b3e3c00a1f4f08246ebfca11e2"
SRC_URI[sha256sum] = "976ce74bf6859a4ba2edd253f5558655a3d7a9fe1a3f0b911726aad97d32f062"

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

inherit chicken_install

BBCLASSEXTEND = "cross crosssdk nativesdk"

repository: OSSystems/meta-chicken

repo_name: OSSystems/meta-chicken


text:
KBRANCH ?= "dev-6.1"
LINUX_VERSION ?= "6.1.12"

SRCREV="c6467d4259005a180dedc4ca9a1e789b46309da6"

require linux-aspeed.inc

repository: dphadke-msft/openbmc

repo_name: dphadke-msft/openbmc


text:
package cogol

import (
	"testing"
)

func TestStorage(t *testing.T) {
	cgl := Init(t)

	g := cgl.Group("Storage")
	{
		propname := "test1property"
		bepropname := "bepropname"

		// Overriding before each
		g.BeforeEach(func(c *Context) {
			c.Storage().Set(bepropname, 727)
		})

		g.T("'propname' should not be accessible from other tests", func(c *Context) {
			c.Storage().Set(propname, 42)
		})

		g.T("'propname' should not be accessible from here", func(c *Context) {
			c.Expect(c.Storage().Get(propname)).ToBeNil()
		})

		g.T("should be accessible because of beforeeach", func(c *Context) {
			c.Expect(c.Storage().Get(bepropname)).ToBe(727)
			c.Log().Info("should be accessible because of beforeeach")
		})

		g.T("here as well", func(c *Context) {
			c.Expect(c.Storage().Get(bepropname)).ToBe(727)
			c.Log().Info("here as well")
		})

		g.T("propname should be overridden", func(c *Context) {
			c.Storage().Set(propname, 4444)

			c.Expect(c.Storage().Get(propname)).ToBe(4444)
		})
	}

	cgl.Process()
}

repository: kyeeego/cogol

repo_name: kyeeego/cogol


text:
@inproceedings{abadi2006integrating,
  title={Integrating compression and execution in column-oriented database systems},
  author={Abadi, Daniel and Madden, Samuel and Ferreira, Miguel},
  booktitle={Proceedings of the 2006 ACM SIGMOD international conference on Management of data},
  pages={671--682},
  year={2006},
  organization={ACM}
}

@inproceedings{goldstein1998compressing,
  title={Compressing relations and indexes},
  author={Goldstein, Jonathan and Ramakrishnan, Raghu and Shaft, Uri},
  booktitle={Proceedings 14th International Conference on Data Engineering},
  pages={370--379},
  year={1998},
  organization={IEEE}
}

@article{lemire2015decoding,
  title={Decoding billions of integers per second through vectorization},
  author={Lemire, Daniel and Boytsov, Leonid},
  journal={Software: Practice and Experience},
  volume={45},
  number={1},
  pages={1--29},
  year={2015},
  publisher={Wiley Online Library}
}

@article{roth1993database,
  title={Database compression},
  author={Roth, Mark A and Van Horn, Scott J},
  journal={ACM Sigmod Record},
  volume={22},
  number={3},
  pages={31--39},
  year={1993},
  publisher={ACM}
}

@book{zukowski2006super,
  title={Super-scalar RAM-CPU cache compression},
  author={Zukowski, Marcin and Heman, Sandor and Nes, Niels and Boncz, Peter},
  year={2006},
  publisher={IEEE}
}

@inproceedings{boncz2013tpc,
  title={TPC-H analyzed: Hidden messages and lessons learned from an influential benchmark},
  author={Boncz, Peter and Neumann, Thomas and Erling, Orri},
  booktitle={Technology Conference on Performance Evaluation and Benchmarking},
  pages={61--76},
  year={2013},
  organization={Springer}
}

@inproceedings{nambiar2006making,
  title={The making of TPC-DS},
  author={Nambiar, Raghunath Othayoth and Poess, Meikel},
  booktitle={Proceedings of the 32nd international conference on Very large data bases},
  pages={1049--1058},
  year={2006},
  organization={VLDB Endowment}
}

@article{lee2014joins,
  title={Joins on encoded and partitioned data},
  author={Lee, Jae-Gil and Attaluri, Gopi and Barber, Ronald and Chainani, Naresh and Draese, Oliver and Ho, Frederick and Idreos, Stratos and Kim, Min-Soo and Lightstone, Sam and Lohman, Guy and others},
  journal={Proceedings of the VLDB Endowment},
  volume={7},
  number={13},
  pages={1355--1366},
  year={2014},
  publisher={VLDB Endowment}
}

@inproceedings{damme2017lightweight,
  title={Lightweight Data Compression Algorithms: An Experimental Survey (Experiments and Analyses).},
  author={Damme, Patrick and Habich, Dirk and Hildebrandt, Juliana and Lehner, Wolfgang},
  booktitle={EDBT},
  pages={72--83},
  year={2017}
}

@inproceedings{lang2016data,
  title={Data blocks: hybrid OLTP and OLAP on compressed storage using both vectorization and compilation},
  author={Lang, Harald and M{\"u}hlbauer, Tobias and Funke, Florian and Boncz, Peter A and Neumann, Thomas and Kemper, Alfons},
  booktitle={Proceedings of the 2016 International Conference on Management of Data},
  pages={311--326},
  year={2016},
  organization={ACM}
}

@article{raman2013db2,
  title={DB2 with BLU acceleration: So much more than just a column store},
  author={Raman, Vijayshankar and Attaluri, Gopi and Barber, Ronald and Chainani, Naresh and Kalmuk, David and KulandaiSamy, Vincent and Leenstra, Jens and Lightstone, Sam and Liu, Shaorong and Lohman, Guy M and others},
  journal={Proceedings of the VLDB Endowment},
  volume={6},
  number={11},
  pages={1080--1091},
  year={2013},
  publisher={VLDB Endowment}
}

@inproceedings{kemper2011hyper,
  title={HyPer: A hybrid OLTP\&OLAP main memory database system based on virtual memory snapshots},
  author={Kemper, Alfons and Neumann, Thomas},
  booktitle={2011 IEEE 27th International Conference on Data Engineering},
  pages={195--206},
  year={2011},
  organization={IEEE}
}

@inproceedings{zukowski2012vectorwise,
  title={Vectorwise: A vectorized analytical DBMS},
  author={Zukowski, Marcin and Van de Wiel, Mark and Boncz, Peter},
  booktitle={2012 IEEE 28th International Conference on Data Engineering},
  pages={1349--1350},
  year={2012},
  organization={IEEE}
}

@inproceedings{polychroniou2015efficient,
  title={Efficient lightweight compression alongside fast scans},
  author={Polychroniou, Orestis and Ross, Kenneth A},
  booktitle={Proceedings of the 11th International Workshop on Data Management on New Hardware},
  pages={9},
  year={2015},
  organization={ACM}
}

@inproceedings{graefe1991data,
  title={Data compression and database performance},
  author={Graefe, Goetz and Shapiro, Leonard D},
  booktitle={[Proceedings] 1991 Symposium on Applied Computing},
  pages={22--27},
  year={1991},
  organization={IEEE}
}

@inproceedings{vogelsgesang2018get,
  title={Get real: How benchmarks fail to represent the real world},
  author={Vogelsgesang, Adrian and Haubenschild, Michael and Finis, Jan and Kemper, Alfons and Leis, Viktor and Muehlbauer, Tobias and Neumann, Thomas and Then, Manuel},
  booktitle={Proceedings of the Workshop on Testing Database Systems},
  pages={1},
  year={2018},
  organization={ACM}
}

@inproceedings{raman2006wring,
  title={How to wring a table dry: Entropy compression of relations and querying of compressed relations},
  author={Raman, Vijayshankar and Swart, Garret},
  booktitle={Proceedings of the 32nd international conference on Very large data bases},
  pages={858--869},
  year={2006},
  organization={VLDB Endowment}
}

@article{cramir1946mathematical,
  title={Mathematical methods of statistics},
  author={Cramir, Harald},
  journal={Princeton U. Press, Princeton},
  pages={282},
  year={1946}
}

@article{press1992theilsu,
  title={Numerical Recipes: the Art of Scientific Computing (3rd ed.)},
  author={Press, William and Flannery, Brian and Teukolsky, Saul and Vetterling, William},
  journal={Cambridge U. Press, Cambridge},
  pages={761},
  year={1992}
}

@inproceedings{sidirourgos2013column,
  title={Column imprints: a secondary index structure},
  author={Sidirourgos, Lefteris and Kersten, Martin},
  booktitle={Proceedings of the 2013 ACM SIGMOD International Conference on Management of Data},
  pages={893--904},
  year={2013},
  organization={ACM}
}

@inproceedings{levenshtein1966binary,
  title={Binary codes capable of correcting deletions, insertions, and reversals},
  author={Levenshtein, Vladimir I},
  booktitle={Soviet physics doklady},
  volume={10},
  number={8},
  pages={707--710},
  year={1966}
}

@inproceedings{boncz2005monetdb,
  title={MonetDB/X100: Hyper-Pipelining Query Execution.},
  author={Boncz, Peter A and Zukowski, Marcin and Nes, Niels},
  booktitle={Cidr},
  volume={5},
  pages={225--237},
  year={2005}
}

@article{kersten2018everything,
  title={Everything you always wanted to know about compiled and vectorized queries but were afraid to ask},
  author={Kersten, Timo and Leis, Viktor and Kemper, Alfons and Neumann, Thomas and Pavlo, Andrew and Boncz, Peter},
  journal={Proceedings of the VLDB Endowment},
  volume={11},
  number={13},
  pages={2209--2222},
  year={2018},
  publisher={VLDB Endowment}
}

@inproceedings{kraska2018case,
  title={The case for learned index structures},
  author={Kraska, Tim and Beutel, Alex and Chi, Ed H and Dean, Jeffrey and Polyzotis, Neoklis},
  booktitle={Proceedings of the 2018 International Conference on Management of Data},
  pages={489--504},
  year={2018},
  organization={ACM}
}

@inproceedings{idreos2019auto,
  title={From auto-tuning one size fits all to self-designed and learned data-intensive systems},
  author={Idreos, Stratos and Kraska, Tim},
  booktitle={ACM SIGMOD},
  year={2019}
}

@article{kraska2019sagedb,
  title={Sagedb: A learned database system},
  author={Kraska, Tim and Alizadeh, Mohammad and Beutel, Alex and Chi, Ed H and Ding, Jialin and Kristo, Ani and Leclerc, Guillaume and Madden, Samuel and Mao, Hongzi and Nathan, Vikram},
  year={2019}
}

% ---------- misc ---------- %

@misc{pbib,
  key={pbib},
  title={Public BI Benchmark},
  howpublished={\url{https://github.com/cwida/public_bi_benchmark}},
  note={Accessed: 2019-03-13}
}

@misc{tableaupublic,
  key={tableaupublic},
  title={Tableau Public},
  howpublished={\url{https://public.tableau.com}},
  note={Accessed: 2019-03-14}
}

@misc{actianingres,
  key={actianingres},
  title={Ingres 10.2. OpenAPI User Guide},
  howpublished={\url{https://supportactian.secure.force.com/help/servlet/fileField?id=0BEf3000000PLPU}},
  note={Accessed: 2019-07-02}
}

@misc{monetdbdatatypes,
  key={monetdbdatatypes},
  title={MonetDB data types},
  howpublished={\url{https://www.monetdb.org/book/export/html/187}},
  note={Accessed: 2019-07-05}
}

@misc{vectorwisedecimal,
  key={vectorwisedatatypes},
  title={VectorWise decimal data type},
  howpublished={\url{https://docs.actian.com/ingres/10s/index.html\#page/SQLRef/Decimal_Data_Type.htm}},
  note={Accessed: 2019-07-05}
}

@misc{vwvwload,
  key={vwvwload},
  title={vwload Command--Load Data into a Table},
  howpublished={\url{https://docs.actian.com/ingres/11.0/index.html\#page/CommandRef\%2Fvwload_Command--Load_Data_into_a_Table.htm}},
  note={Accessed: 2019-07-18}
}

@misc{vwperfguide,
  key={vwperfguide},
  title={Performance Tips},
  howpublished={\url{https://docs.actian.com/vector/4.2/index.html\#page/User/Performance_Tips.htm}},
  note={Accessed: 2019-07-18}
}

@misc{pypiregex,
  key={pypiregex},
  title={regex 2019.06.08},
  howpublished={\url{https://pypi.org/project/regex}},
  note={Accessed: 2019-07-18}
}

@misc{linuxstructstat,
  key={linuxstructstat},
  title={Linux Programmer's Manual. STAT(2)},
  howpublished={\url{http://man7.org/linux/man-pages/man2/stat.2.html}},
  note={Accessed: 2019-07-18}
}

@misc{vwstatdump,
  key={vwstatdump},
  title={statdump Command--Print Statistics in iistats and iihistogram Catalogs},
  howpublished={\url{https://docs.actian.com/vector/5.0/index.html\#page/User/statdump_Command--Print_Statistics_in_iistats_an.htm}},
  note={Accessed: 2019-07-18}
}

@misc{sqlcoalesce,
  key={sqlcoalesce},
  title={Database SQL Language Reference. COALESCE},
  howpublished={\url{https://docs.oracle.com/cd/B28359_01/server.111/b28286/functions023.htm}},
  note={Accessed: 2019-07-29}
}

repository: bogdanghita/master-thesis

repo_name: bogdanghita/master-thesis


text:
DESCRIPTION = "The YAML.pm module implements a YAML Loader and Dumper based on the YAML \
1.0 specification. <http://www.yaml.org/spec/>"

SECTION = "libs"
LICENSE = "Artisticv1 | GPLv1+"
PR = "r0"

MAINTAINER=	"Poky <poky@yoctoproject.org>"
HOMEPAGE=	"https://metacpan.org/release/YAML"

LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Artistic-1.0;md5=cda03bbdc3c1951996392b872397b798 \
file://${COMMON_LICENSE_DIR}/GPL-1.0;md5=e9e36a9de734199567a4d769498f743d"

SRC_URI = "https://cpan.metacpan.org/authors/id/T/TI/TINITA/YAML-1.27.tar.gz"

SRC_URI[md5sum] = "25ea8d2fb09a2c753b07b1c4e2011ac1"
SRC_URI[sha256sum] = "c992a1e820de0721b62b22521de92cdbf49edc306ab804c485b4b1ec25f682f9"
DEPENDS += "test-deep-perl-native"
DEPENDS += "test-yaml-perl-native"

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

inherit cpan allarch

BBCLASSEXTEND = "native"

repository: CELLINKAB/meta-cpan

repo_name: CELLINKAB/meta-cpan

gha_license_id: MIT


text:
require ncnn.inc

SRCREV = "${AUTOREV}"
SRC_URI = "git://github.com/ElegantGod/ncnn.git;protocol=https;branch=master"

SRC_URI += " file://fa0.patch \
 file://mt0.patch \
 file://sq0.patch \
 file://ss0.patch \
"

do_install_append() {
 install -d ${D}${bindir}/
 install -m 0755 ${B}/mtcnn/mtcnn ${D}${bindir}/mtcnn
}

LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=8c8b5b19ef89ee9cfa47e768aa904935;rev={SRCREV}"


text:
package main

import (
	"flag"
	"fmt"
	"os"
	"strings"
	"sync"

	"github.com/lhz/sidpicker/config"
	"github.com/lhz/sidpicker/hvsc"
	"github.com/lhz/sidpicker/player"
	"github.com/lhz/sidpicker/ui"
)

var workerGroup sync.WaitGroup

func main() {
	reindexFlag := flag.Bool("i", false, "Rebuild tune index.")
	versionFlag := flag.Bool("v", false, "Output version string then exit.")
	flag.Parse()

	config.ReadConfig()

	// Output version string and exit
	if *versionFlag {
		fmt.Printf("sidpicker v%s\n", config.Version)
		os.Exit(0)
	}

	// Rebuild tunes index and exit
	if *reindexFlag {
		hvsc.BuildTunesIndex()
		fmt.Printf("Indexed %d tunes.\n", hvsc.NumTunes)
		os.Exit(0)
	}

	hvsc.ReadTunesIndex()

	workerGroup.Add(1)
	go func() {
		defer workerGroup.Done()
		player.Run()
	}()

	searchTerm := strings.Join(os.Args[1:], " ")
	ui.Setup(searchTerm)

	ui.Run()

	player.Quit()

	workerGroup.Wait()
}

repository: NeedfulThings/sidpicker

repo_name: NeedfulThings/sidpicker


text:
SUMMARY = "Solidsense provisioning"
DESCRIPTION = "Solidsense provisioning"
LICENSE = "EPL-2.0"
LIC_FILES_CHKSUM = " \
    file://../SolidSense-V1/LICENSE;md5=c7cc8aa73fb5717f8291fcec5ce9ed6c \
"
SRC_URI = " \
    git://git@github.com/SolidRun/SolidSense-V1.git;protocol=ssh;branch=V1.1;destsuffix=SolidSense-V1;name=SolidSense-V1 \
"

SRCREV_SolidSense-V1 = "a31f0edd32d684403e924480f851e5380b6a59e2"
S-V1 = "${WORKDIR}/SolidSense-V1"

do_install () {
    # Install factory configuration files
    install -d ${D}/opt/SolidSense/config
    install -m 0644 ${S-V1}/config/SolidSense-HW-configurations.yml ${D}/opt/SolidSense/config/SolidSense-HW-configurations.yml
    install -m 0644 ${S-V1}/config/SolidSense-conf-base.yml ${D}/opt/SolidSense/config/SolidSense-conf-base.yml

    # Install template directory
    cp -a ${S-V1}/template ${D}/opt/SolidSense/template
    chown -R root:root ${D}/opt/SolidSense/template

    # Install common directory
    cp -a ${S-V1}/common ${D}/opt/SolidSense/common
    chown -R root:root ${D}/opt/SolidSense/common

    # Install provisioning
    cp -a ${S-V1}/provisioning ${D}/opt/SolidSense/provisioning
    chown -R root:root ${D}/opt/SolidSense/provisioning
}

FILES_${PN} = " \
  /opt \
  /opt/SolidSense \
  /opt/SolidSense/template \
  /opt/SolidSense/config \
  /opt/SolidSense/provisioning \
  /opt/SolidSense/common \
  /opt/SolidSense/template/hostapd.conf.tmpl \
  /opt/SolidSense/template/kura \
  /opt/SolidSense/template/ppp \
  /opt/SolidSense/template/kura/snapshot_0.xml \
  /opt/SolidSense/template/kura/kura_custom.properties.tmpl \
  /opt/SolidSense/template/kura/snapshot_0-full.xml \
  /opt/SolidSense/template/ppp/disconnect.tmpl \
  /opt/SolidSense/template/ppp/chat.tmpl \
  /opt/SolidSense/template/ppp/disconnect_EC25_2-1.2 \
  /opt/SolidSense/template/ppp/EC25_2-1.2 \
  /opt/SolidSense/template/ppp/peer.tmpl \
  /opt/SolidSense/template/ppp/chat_EC25_2-1.2 \
  /opt/SolidSense/config/SolidSense-HW-configurations.yml \
  /opt/SolidSense/config/SolidSense-conf-base.yml \
  /opt/SolidSense/provisioning/cpconfig \
  /opt/SolidSense/provisioning/rsn0 \
  /opt/SolidSense/provisioning/ModemPppService.py \
  /opt/SolidSense/provisioning/SnapshotXML.py \
  /opt/SolidSense/provisioning/SolidSenseService.py \
  /opt/SolidSense/provisioning/SolidSenseProvisionning.py \
  /opt/SolidSense/provisioning/ElementTreeLoc.py \
  /opt/SolidSense/provisioning/provisioning_utils.py \
  /opt/SolidSense/common/solidsense_led.py \
  /opt/SolidSense/common/solidsense_parameters.py \
"

COMPATIBLE_MACHINE = "solidsense|n6gq|n6gsdl"

repository: axilera/meta-cip-sr-common

repo_name: axilera/meta-cip-sr-common


text:
@article{Raykar2010,
	Abstract = {For many supervised learning tasks it may be infeasible (or very expensive) to obtain objective and reliable labels. Instead, we can collect subjective (possibly noisy) labels from multiple experts or annotators. In practice, there is a substantial amount of disagreement among the annotators, and hence it is of great practical interest to address conventional supervised learning problems in this scenario. In this paper we describe a probabilistic approach for supervised learning when we have multiple annotators providing (possibly noisy) labels but no absolute gold standard. The proposed algorithm evaluates the different experts and also gives an estimate of the actual hidden labels. Experimental results indicate that the proposed method is superior to the commonly used majority voting baseline.},
	Author = {Raykar, Vikas C and Yu, Shipeng and Zhao, Linda H and Valadez, Gerardo Hermosillo and Florin, Charles and Bogoni, Luca and Moy, Linda},
	Date-Modified = {2017-01-19 00:02:16 +0000},
	Doi = {10.2139/ssrn.936771},
	Isbn = {1532-4435},
	Issn = {1532-4435},
	Journal = {Journal of Machine Learning Research},
	Keywords = {annotators,crowdsourcing,experts,multiple annotators,multiple experts,multiple teachers,supervised learning from multiple},
	Pages = {1297--1322},
	Title = {{Learning From Crowds}},
	Url = {http://dl.acm.org/citation.cfm?id=1756006.1859894},
	Volume = {11},
	Year = {2010},
	Bdsk-Url-1 = {http://dl.acm.org/citation.cfm?id=1756006.1859894},
	Bdsk-Url-2 = {http://dx.doi.org/10.2139/ssrn.936771}}

@article{Mariooryad2015,
	Abstract = {An appealing scheme to characterize expressive behaviors is the use of emotional dimensions such as activation (calm versus active) and valence (negative versus positive). These descriptors offer many advantages to describe the wide spectrum of emotions. Due to the continuous nature of fast-changing expressive vocal and gestural behaviors, it is desirable to continuously track these emotional traces, capturing subtle and localized events (e.g., with FEELTRACE). However, time-continuous annotations introduce challenges that affect the reliability of the labels. In particular, an important issue is the evaluators' reaction lag caused by observing, appraising, and responding to the expressive behaviors. An empirical analysis demonstrates that this delay varies from 1 to 6 seconds, depending on the annotator, expressive dimension, and actual behaviors. Our experiments show accuracy improvements even with fixed delays (1-3 seconds). This paper proposes to compensate for this reaction lag by finding the time-shift that maximizes the mutual information between the expressive behaviors and the time-continuous annotations. The approach is implemented by making different assumptions about the evaluators' reaction lag. The benefits of compensating for the delay is demonstrated with emotion classification experiments. On average, the classifiers trained with facial and speech features show more than 7 percent relative improvements over baseline classifiers trained and tested without shifting the time-continuous annotations.},
	Author = {Mariooryad, Soroosh and Busso, Carlos},
	Date-Modified = {2017-01-19 00:01:40 +0000},
	Journal = {IEEE Transactions on Affective Computing},
	Number = {2},
	Pages = {97--108},
	Title = {{Correcting Time-Continuous Emotional Labels by Modeling the Reaction Lag of Evaluators}},
	Volume = {6},
	Year = {2015}}

@article{Lakshminarayanan2013,
	Abstract = {A popular approach for large scale data annotation tasks is crowdsourcing, wherein each data point is labeled by multiple noisy annotators. We consider the problem of inferring ground truth from noisy ordinal labels obtained from multiple annotators of varying and unknown expertise levels. Annotation models for ordinal data have been proposed mostly as extensions of their binary/categorical counterparts and have received little attention in the crowdsourcing literature. We propose a new model for crowdsourced ordinal data that accounts for instance difficulty as well as annotator expertise, and derive a variational Bayesian inference algorithm for parameter estimation. We analyze the ordinal extensions of several state-of-the-art annotator models for binary/categorical labels and evaluate the performance of all the models on two real world datasets containing ordinal query-URL relevance scores, collected through Amazon's Mechanical Turk. Our results indicate that the proposed model performs better or as well as existing state-of-the-art methods and is more resistant to `spammy' annotators (i.e., annotators who assign labels randomly without actually looking at the instance) than popular baselines such as mean, median, and majority vote which do not account for annotator expertise.},
	Archiveprefix = {arXiv},
	Arxivid = {1305.0015},
	Author = {Lakshminarayanan, Balaji and Teh, Yee Whye},
	Date-Modified = {2017-01-19 00:00:51 +0000},
	Eprint = {1305.0015},
	Journal = {arXiv preprint},
	Pages = {1--19},
	Title = {{Inferring ground truth from multi-annotator ordinal data: a probabilistic approach}},
	Url = {http://arxiv.org/abs/1305.0015},
	Year = {2013},
	Bdsk-Url-1 = {http://arxiv.org/abs/1305.0015}}

@ARTICLE{Gupta2016,
    author={R. Gupta and K. Audhkhasi and Z. Jacokes and A. Rozga and S. Narayanan},
    journal={IEEE Transactions on Affective Computing},
    title={Modeling multiple time series annotations based on ground truth inference and distortion},
    year={2016},
    volume={PP},
    number={99},
    pages={1-1},
    keywords={Analytical models;Computational modeling;Data models;Delays;Distortion;Time series analysis;Behavioral signal processing;Expectation Maximization (EM) algorithm;Multiple annotators;Time series modeling}
}

@article{zhu2015fusing,
  title={Fusing continuous-valued medical labels using a Bayesian model},
  author={Zhu, Tingting and Dunkley, Nic and Behar, Joachim and Clifton, David A and Clifford, Gari D},
  journal={Annals of biomedical engineering},
  volume={43},
  number={12},
  pages={2892--2902},
  year={2015},
  publisher={Springer}
}

@article{nicolaou2014dynamic,
  title={Dynamic probabilistic CCA for analysis of affective behavior and fusion of continuous annotations},
  author={Nicolaou, Mihalis A and Pavlovic, Vladimir and Pantic, Maja},
  journal={IEEE transactions on pattern analysis and machine intelligence},
  volume={36},
  number={7},
  pages={1299--1311},
  year={2014},
  publisher={IEEE}
}

@inproceedings{metallinou2013annotation,
  title={Annotation and processing of continuous emotional attributes: Challenges and opportunities},
  author={Metallinou, Angeliki and Narayanan, Shrikanth},
  booktitle={Automatic Face and Gesture Recognition (FG), 2013 10th IEEE International Conference and Workshops on},
  pages={1--8},
  year={2013},
  organization={IEEE}
}

@inproceedings{nicolaou2013correlated,
  title={Correlated-spaces regression for learning continuous emotion dimensions},
  author={Nicolaou, Mihalis A and Zafeiriou, Stefanos and Pantic, Maja},
  booktitle={Proceedings of the 21st ACM international conference on Multimedia},
  pages={773--776},
  year={2013},
  organization={ACM}
}

@inproceedings{CTW2009,
  title={Canonical time warping for alignment of human behavior},
  author={Zhou, Feng and Torre, Fernando},
  booktitle={Advances in neural information processing systems},
  pages={2286--2294},
  year={2009}
}

@article{CCA1936,
  title={Relations between two sets of variates},
  author={Hotelling, Harold},
  journal={Biometrika},
  volume={28},
  number={3/4},
  pages={321--377},
  year={1936},
  publisher={JSTOR}
}

@article{DTW2007,
  title={Dynamic time warping},
  author={M{\"u}ller, Meinard},
  journal={Information retrieval for music and motion},
  pages={69--84},
  year={2007},
  publisher={Springer}
}

@article{PCCA2005,
  title={A probabilistic interpretation of canonical correlation analysis},
  author={Bach, Francis R and Jordan, Michael I},
  year={2005},
  publisher={Citeseer}
}

@article{yannakakis2015ratings,
  title={Ratings are overrated!},
  author={Yannakakis, Georgios N and Mart{\'\i}nez, H{\'e}ctor P},
  journal={Frontiers in ICT},
  volume={2},
  pages={13},
  year={2015},
  publisher={Frontiers}
}

@article{Ringeval2015,
	Author = {Fabien Ringeval and Florian Eyben and Eleni Kroupi and Anil Yuce and Jean-Philippe Thiran and Touradj Ebrahimi and Denis Lalanne, and Bj{\"o}rn Schuller},
	Date-Added = {2017-01-24 22:10:56 +0000},
	Date-Modified = {2017-01-24 22:12:56 +0000},
	Journal = {Pattern Recognition Letters},
	Pages = {22--30},
	Title = {{Prediction of ashynchronous dimensional emotion ratings from audiovisual and physiological data}},
	Volume = {66},
	Year = {2015}}

@Inbook{Yannakakis2011,
    author="Yannakakis, Georgios N.
    and Hallam, John",
    editor="D'Mello, Sidney
    and Graesser, Arthur
    and Schuller, Bj{\"o}rn
    and Martin, Jean-Claude",
    title="Ranking vs. Preference: A Comparative Study of Self-reporting",
    bookTitle="Affective Computing and Intelligent Interaction: 4th International Conference, ACII 2011, Memphis, TN, USA, October 9--12, 2011, Proceedings, Part I",
    year="2011",
    publisher="Springer Berlin Heidelberg",
    pages="437--446"
}

@inproceedings{jain2016finite,
  title={Finite Sample Prediction and Recovery Bounds for Ordinal Embedding},
  author={Jain, Lalit and Jamieson, Kevin G and Nowak, Rob},
  booktitle={Advances In Neural Information Processing Systems},
  pages={2703--2711},
  year={2016}
}

@inproceedings{agarwal2007generalized,
  title={Generalized Non-metric Multidimensional Scaling.},
  author={Agarwal, Sameer and Wills, Josh and Cayton, Lawrence and Lanckriet, Gert RG and Kriegman, David J and Belongie, Serge J},
  booktitle={AISTATS},
  pages={11--18},
  year={2007}
}

@inproceedings{tamuz2011adaptively,
    Publisher = {ACM},
    Title = {Adaptively Learning the Crowd Kernel },
    Booktitle = {Proceedings of the 28th International Conference on Machine Learning (ICML-11)},
    Author = {Omer Tamuz and Ce Liu and Ohad Shamir and Adam Kalai and Serge J. Belongie},
    Year = {2011},
    Pages = {673--680}
   }

@inproceedings{van2012stochastic,
  title={Stochastic triplet embedding},
  author={Van Der Maaten, Laurens and Weinberger, Kilian},
  booktitle={Machine Learning for Signal Processing (MLSP), 2012 IEEE International Workshop on},
  pages={1--6},
  year={2012},
  organization={IEEE}
}

@inproceedings{amid2015multiview,
  title={Multiview Triplet Embedding: Learning Attributes in Multiple Maps.},
  author={Amid, Ehsan and Ukkonen, Antti},
  booktitle={ICML},
  pages={1472--1480},
  year={2015}
}

@inproceedings{valstar2016avec,
  title={AVEC 2016: Depression, Mood, and Emotion Recognition Workshop and Challenge},
  author={Valstar, Michel and Gratch, Jonathan and Schuller, Bj{\"o}rn and Ringeval, Fabien and Lalanne, Dennis and Torres Torres, Mercedes and Scherer, Stefan and Stratou, Giota and Cowie, Roddy and Pantic, Maja},
  booktitle={Proceedings of the 6th International Workshop on Audio/Visual Emotion Challenge},
  pages={3--10},
  year={2016},
  organization={ACM}
}

@article{rudin1992nonlinear,
  title={Nonlinear total variation based noise removal algorithms},
  author={Rudin, Leonid I and Osher, Stanley and Fatemi, Emad},
  journal={Physica D: Nonlinear Phenomena},
  volume={60},
  number={1-4},
  pages={259--268},
  year={1992},
  publisher={Elsevier}
}

@article{becker2011templates,
  title={Templates for convex cone problems with applications to sparse signal recovery},
  author={Becker, Stephen R and Cand{\`e}s, Emmanuel J and Grant, Michael C},
  journal={Mathematical programming computation},
  volume={3},
  number={3},
  pages={165},
  year={2011},
  publisher={Springer}
}

@article{mckeown2012semaine,
  title={The semaine database: Annotated multimodal records of emotionally colored conversations between a person and a limited agent},
  author={McKeown, Gary and Valstar, Michel and Cowie, Roddy and Pantic, Maja and Schroder, Marc},
  journal={IEEE Transactions on Affective Computing},
  volume={3},
  number={1},
  pages={5--17},
  year={2012},
  publisher={IEEE}
}

@inproceedings{ringeval2013introducing,
  title={Introducing the RECOLA multimodal corpus of remote collaborative and affective interactions},
  author={Ringeval, Fabien and Sonderegger, Andreas and Sauer, Juergen and Lalanne, Denis},
  booktitle={Automatic Face and Gesture Recognition (FG), 2013 10th IEEE International Conference and Workshops on},
  pages={1--8},
  year={2013},
  organization={IEEE}
}

@article{Zhou2016,
  title={Generalized canonical time warping},
  author={Zhou, Feng and De la Torre, Fernando},
  journal={IEEE transactions on pattern analysis and machine intelligence},
  volume={38},
  number={2},
  pages={279--294},
  year={2016},
  publisher={IEEE}
}

@inproceedings{trigeorgis2016deep,
  title={Deep Canonical Time Warping},
  author={Trigeorgis, George and Nicolaou, Mihalis A and Zafeiriou, Stefanos and Schuller, Bjorn W},
  booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition},
  pages={5110--5118},
  year={2016}
}

@inproceedings{andrew2013deep,
  title={Deep canonical correlation analysis.},
  author={Andrew, Galen and Arora, Raman and Bilmes, Jeff A and Livescu, Karen},
  booktitle={ICML (3)},
  pages={1247--1255},
  year={2013}
}


text:
// errorcheck

package main

func main() {
	switch interface{}(0).(type) {
		case 1: // ERROR `1 (type untyped number) is not a type`
	}
}


text:
@article{Milek_2006,
  doi = {10.1159/000093278},
  url = {https://doi.org/10.1159\%2F000093278},
  year = 2006,
  publisher = {S. Karger {AG}},
  volume = {77},
  number = {3},
  pages = {105--114},
  author = {M. Milek and J. Murn and Z. Jaksic and J. Lukac Bajalo and J. Jazbec and I. Mlinaric Rascan},
  title = {Thiopurine S-Methyltransferase Pharmacogenetics: Genotype to Phenotype Correlation in the Slovenian Population},
  journal = {Pharmacology}
}

repository: larmcr/px

repo_name: larmcr/px


text:
@Misc{www-apache-spark,
title = {Spark Programming Guide - Spark 2.1.0 Documentation},
key = {apachesparkdoc},
note ={Accessed: 02-22-2017},
howpublished ={Article},
author = {Apache Software Foundation},
url ={http://spark.apache.org/docs/latest/programming-guide.html}
}

@Misc{wiki-DAG,
title = {Directed Acyclic Graph - Wikipedia},
key = {apachesparkwiki},
note ={Accessed: 02-26-2017},
howpublished ={Article},
publisher = {wikipedia},
url ={https://en.wikipedia.org/wiki/Directed_acyclic_graph}
}

@Misc{www-spark-cluster,
title = {Cluster Mode Overview - Spark 2.1.0 Documentation},
key = {sparkclusterdoc},
note ={Accessed: 02-22-2017},
howpublished ={Article},
author = {Apache Software Foundation},
url ={http://spark.apache.org/docs/latest/cluster-overview.html},
}

@Article{article-spark-1,
  author  = {Amol Bansod},
  title   = {Efficient Big Data Analysis with Apache Spark in HDFS},
  journal = {International Journal of Engineering and Advanced Technology (IJEAT)},
  year    = {2015},
  volume  = {4},
  number  = {6},
  pages   = {313--316},
  month   = {aug},
  issn    = {2249 – 8958},
}

@Book{book-spark,
  title     = {Learning Spark: Lightning-Fast Big Data Analytics},
  publisher = {O'Reilly Media, Inc.},
  year      = {2015},
  author    = {Holden Karau and Andy Konwinski and Patrick Wendell and Matei Zaharia},
  edition   = {1st},
  month     = {feb},
  isbn      = {1449358624, 9781449358624},
  url       = {https://www.safaribooksonline.com/library/view/learning-spark/9781449359034/},
}

@article{article-spark-2,
 author    = {Matei Zaharia and
               Reynold S. Xin and
               Patrick Wendell and
               Tathagata Das and
               Michael Armbrust and
               Ankur Dave and
               Xiangrui Meng and
               Josh Rosen and
               Shivaram Venkataraman and
               Michael J. Franklin and
               Ali Ghodsi and
               Joseph Gonzalez and
               Scott Shenker and
               Ion Stoica},
 title = {Apache Spark: A Unified Engine for Big Data Processing},
 journal = {Commun. ACM},
 issue_date = {November 2016},
 volume = {59},
 number = {11},
 month = oct,
 year = {2016},
 issn = {0001-0782},
 pages = {56--65},
 numpages = {10},
 url = {http://doi.acm.org/10.1145/2934664},
 doi = {10.1145/2934664},
 publisher = {ACM},
 address = {New York, NY, USA},
}

@inproceedings{paper-RDD,
  author    = {Matei Zaharia and
               Mosharaf Chowdhury and
               Tathagata Das and
               Ankur Dave and
               Justin Ma and
               Murphy McCauly and
               Michael J. Franklin and
               Scott Shenker and
               Ion Stoica},
  title     = {Resilient Distributed Datasets: {A} Fault-Tolerant Abstraction for
               In-Memory Cluster Computing},
  booktitle = {Proceedings of the 9th {USENIX} Symposium on Networked Systems Design
               and Implementation, {NSDI} 2012, San Jose, CA, USA, April 25-27, 2012},
  pages     = {15--28},
  year      = {2012},
  publisher = {USENIX Association},
  address = {Berkeley, CA, USA},
  url       = {https://www.usenix.org/conference/nsdi12/technical-sessions/presentation/zaharia},

}

@Misc{www-spark-2,
title = {Apache Spark Ecosystem and Spark Components},
url = {https://www.dezyre.com/article/apache-spark-ecosystem-and-spark-components/219},
note = {Apache Spark Ecosystem and Spark Components},
key = {sparkecopage},
month = feb,
year= {2016},
publisher ={DeZyre}
}


text:
DESCRIPTION = "Interface to use Pushetta API with Python. Pushetta is a service made to make it simple send push notifications from/to (almost) any device. It can be used to send a notifications from Arduino to iPhone, from Raspberry Pi to Android, from web page to Beaglebone and many others."
HOMEPAGE = "https://github.com/guglielmino/pushetta-py"
SECTION = "devel/python"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://PKG-INFO;beginline=8;endline=8;md5=8227180126797a0148f94f483f3e1489"
SRCNAME = "pushetta"

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

# This patch avoid the inclusion of the mqtt and future package
# Therefore subscription is not working with this recipe
# We would need to depend on meta-oe
# --> http://cgit.openembedded.org/cgit.cgi/meta-openembedded/tree/meta-python/recipes-devtools/python/python-paho-mqtt_1.1.bb?h=master
SRC_URI = "http://pypi.python.org/packages/source/p/pushetta/${SRCNAME}-${PV}.tar.gz \
	   file://avoid_packages.patch"

inherit setuptools

# need uuid urllib & json
RDEPENDS_${PN} += "python-netclient python-json"

SRC_URI[md5sum] = "fa7a741800b88b89bcb4fbeee3b03f61"
SRC_URI[sha256sum] = "75d69d672f3cea8453a36f0ee638c64079d93c27f52f3b96d2bf7752ec034cf6"

repository: urnenfeld/meta-widde

repo_name: urnenfeld/meta-widde

gha_language: BitBake


text:
package test

import (
	"testing"

	"github.com/mgechev/revive/lint"
	"github.com/mgechev/revive/rule"
)

func TestImportsBlacklist(t *testing.T) {
	args := []interface{}{"crypto/md5", "crypto/sha1"}

	testRule(t, "imports-blacklist", &rule.ImportsBlacklistRule{}, &lint.RuleConfig{
		Arguments: args,
	})
}

repository: markelog/revive

repo_name: markelog/revive


text:
@book{matsimbook,
  title={{The multi-agent transport simulation MATSim}},
  author={Horni, Andreas and Nagel, Kai and Axhausen, Kay W},
  year={2016},
  publisher={Ubiquity Press, London}
}

@article{axhausen2008income,
  title={Income and distance elasticities of values of travel time savings: New Swiss results},
  author={Axhausen, Kay W and Hess, Stephane and K{\"o}nig, Arnd and Abay, Georg and Bates, John J and Bierlaire, Michel},
  journal={Transport Policy},
  volume={15},
  number={3},
  pages={173--185},
  year={2008},
  publisher={Elsevier}
}

@inproceedings{Bierlaire2003,
    address = {Ascona, Switzerland},
    author = {Bierlaire, Michel},
    booktitle = {3rd Swiss Transportation Research Conference},
    title = {{BIOGEME: A free package for the estimation of discrete choice models.}},
    url = {http://biogeme.epfl.ch/},
    year = {2003}
}
@book{Bierlaire2008,
    author = {Bierlaire, Michel},
    title = {{An Introduction to BIOGEME Version 1.6}},
    year = {2008}
}

repository: evanjt/latextemplates

repo_name: evanjt/latextemplates


text:
@article{cuturi_16,
 author = {Luigi F. Cuturi and Elena Aggius-Vella and Claudio Campus and Alberto Parmiggiani and Monica Gori},
 doi = {https://doi.org/10.1016/j.neubiorev.2016.08.019},
 file = {:papers_and_patents\u̧turi_16.pdf:PDF},
 issn = {0149-7634},
 journal = {Neuroscience & Biobehavioral Reviews},
 pages = {240 - 251},
 title = {From science to technology: Orientation and mobility in blind children and adults},
 url = {http://www.sciencedirect.com/science/article/pii/S014976341630210X},
 volume = {71},
 year = {2016}
}

repository: miggia/academic-kickstart

repo_name: miggia/academic-kickstart


text:
@article{GmErRte1,
      author={Malen, Greg and Rold{\'a}n, {\'E}rika and Toal{\'a}-Enr{\'i}quez, Rosemberg},
      title={Extremal {p,q}-animals},
      journal={Annals of Combinatorics},
      volume={41 pages, 2023},
}

repository: gmalen/academic-kickstart

repo_name: gmalen/academic-kickstart


text:
SUMMARY = "Periodic Table of Elements"
LICENSE = "BSD-2-Clause & BSD-3-Clause & CC0-1.0 & GFDL-1.2 & GPL-2.0-or-later & LGPL-2.0-or-later & LGPL-2.1-or-later"
LIC_FILES_CHKSUM = " \
    file://LICENSES/BSD-2-Clause.txt;md5=534956ece1a160a65f088a8f82672ef9 \
    file://LICENSES/BSD-3-Clause.txt;md5=954f4d71a37096249f837652a7f586c0 \
    file://LICENSES/CC0-1.0.txt;md5=65d3616852dbf7b1a6d4b53b00626032 \
    file://LICENSES/GFDL-1.2-or-later.txt;md5=9f58808219e9a42ff1228309d6f83dc6 \
    file://LICENSES/GPL-2.0-or-later.txt;md5=9e2385fe012386d34dcc5c9863070881 \
    file://LICENSES/LGPL-2.0-or-later.txt;md5=da48810c4ddf8e49efa031294a26b98c \
    file://LICENSES/LGPL-2.1-or-later.txt;md5=147a320ed8b16b036829a0c71d424153 \
"

# avogadrolibs -> glew
REQUIRED_DISTRO_FEATURES = "opengl"

inherit kde-apps gettext pkgconfig gtk-icon-cache mime-xdg features_check

DEPENDS += " \
    qtsvg \
    libeigen \
    openbabel \
    avogadrolibs \
    \
    kcoreaddons-native \
    kconfig-native \
    kdoctools-native \
    kauth-native \
    karchive \
    kconfig \
    kcoreaddons \
    kdoctools \
    ki18n \
    kdelibs4support \
    khtml \
    knewstuff \
    kparts \
    kplotting \
    solid \
    kunitconversion \
    kwidgetsaddons \
"

PV = "${KDE_APP_VERSION}"
SRC_URI[sha256sum] = "0c743f7cef68ffca68605763ca740ed3a7fd26d0f085a80ad6b5f3b777ea5c50"

FILES:${PN} += " \
    ${datadir}/config.kcfg \
    ${datadir}/kxmlgui5 \
    ${datadir}/knsrcfiles \
    ${datadir}/libkdeedu \
"


text:
SECTION = "kernel"
DESCRIPTION = "Linux kernel for MNCI device"
LICENSE = "GPL"
DEPENDS = "modutils-cross virtual/${TARGET_PREFIX}gcc${KERNEL_CCSUFFIX}"
COMPATIBLE_MACHINE = "mnci"
KV = "2.4.21"
RMKV = "2"
PXAV = "1"
PR = "r5"

SRC_URI = "${KERNELORG_MIRROR}/pub/linux/kernel/v2.4/linux-${KV}.tar.bz2 \
	   http://ftp.linux.org.uk/pub/linux/arm/kernel/v2.4/patch-${KV}-rmk${RMKV}.bz2;patch=1 \
	   file://diff-${KV}-rmk${RMKV}-pxa${PXAV}.gz;patch=1 \
	   file://mnci-combined.patch;patch=1"

S = "${WORKDIR}/linux-${KV}"

inherit kernel

KERNEL_CCSUFFIX = "-3.3.4"

# Put the zImage into kernel-image
ALLOW_EMPTY_kernel = "1"
FILES_kernel = ""
FILES_kernel-image += "/tmp/zImage"

do_configure_prepend() {
	install -m 0644 ${S}/arch/arm/def-configs/${MACHINE} ${S}/.config || die "No default configuration for ${MACHINE} available."
}

kernel_do_install() {
	unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS
	if (grep -q -i -e '^CONFIG_MODULES=y$' .config); then
		oe_runmake DEPMOD=echo INSTALL_MOD_PATH="${D}" modules_install
	else
		oenote "no modules to install"
	fi
	install -d ${D}/tmp
	install -m 0644 ${KERNEL_OUTPUT} ${D}/tmp
	install -d ${D}/boot
	install -m 0644 .config ${D}/boot/config-${PV}
	bzip2 -9 ${D}/boot/*
	install -d ${D}${sysconfdir}/modutils
}

pkg_postinst_kernel-image () {
test -f /tmp/zImage || exit 0
cp /tmp/zImage /dev/mtdblock/1
rm /tmp/zImage
sync
cat /dev/mtdblock/1 >/dev/null
}

pkg_postinst_kernel () {
}

pkg_postinst_modules () {
if [ -n "$D" ]; then
	${HOST_PREFIX}depmod-${KERNEL_MAJOR_VERSION} -A -b $D -F $D/boot/System.map-${PV} ${KERNEL_VERSION}
else
	depmod -A
fi
}

pkg_postrm_modules () {
}

pkg_postrm_kernel () {
}


text:
package v1

import (
	"fmt"
	"net/http"
	"time"

	"github.com/NYTimes/gziphandler"
	"github.com/go-kit/kit/log"
	qapi "github.com/improbable-eng/thanos/pkg/query/api"
	thanosrule "github.com/improbable-eng/thanos/pkg/rule"
	"github.com/improbable-eng/thanos/pkg/store/storepb"
	"github.com/improbable-eng/thanos/pkg/tracing"
	opentracing "github.com/opentracing/opentracing-go"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/common/route"
	"github.com/prometheus/prometheus/pkg/labels"
	"github.com/prometheus/prometheus/rules"
)

type API struct {
	logger        log.Logger
	now           func() time.Time
	ruleRetriever RulesRetriever
}

func NewAPI(
	logger log.Logger,
	ruleRetriever RulesRetriever,
) *API {
	return &API{
		logger:        logger,
		now:           time.Now,
		ruleRetriever: ruleRetriever,
	}
}

func (api *API) Register(r *route.Router, tracer opentracing.Tracer, logger log.Logger) {
	instr := func(name string, f qapi.ApiFunc) http.HandlerFunc {
		hf := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			qapi.SetCORS(w)
			if data, warnings, err := f(r); err != nil {
				qapi.RespondError(w, err, data)
			} else if data != nil {
				qapi.Respond(w, data, warnings)
			} else {
				w.WriteHeader(http.StatusNoContent)
			}
		})
		return prometheus.InstrumentHandler(name, tracing.HTTPMiddleware(tracer, name, logger, gziphandler.GzipHandler(hf)))
	}

	r.Get("/alerts", instr("alerts", api.alerts))
	r.Get("/rules", instr("rules", api.rules))

}

type RulesRetriever interface {
	RuleGroups() []thanosrule.Group
	AlertingRules() []thanosrule.AlertingRule
}

func (api *API) rules(r *http.Request) (interface{}, []error, *qapi.ApiError) {
	res := &RuleDiscovery{}
	for _, grp := range api.ruleRetriever.RuleGroups() {
		apiRuleGroup := &RuleGroup{
			Name:                    grp.Name(),
			File:                    grp.File(),
			Interval:                grp.Interval().Seconds(),
			Rules:                   []rule{},
			PartialResponseStrategy: grp.PartialResponseStrategy.String(),
		}

		for _, r := range grp.Rules() {
			var enrichedRule rule

			lastError := ""
			if r.LastError() != nil {
				lastError = r.LastError().Error()
			}

			switch rule := r.(type) {
			case thanosrule.AlertingRule:
				enrichedRule = alertingRule{
					Name:                    rule.Name(),
					Query:                   rule.Query().String(),
					Duration:                rule.Duration().Seconds(),
					Labels:                  rule.Labels(),
					Annotations:             rule.Annotations(),
					Alerts:                  rulesAlertsToAPIAlerts(grp.PartialResponseStrategy, rule.ActiveAlerts()),
					Health:                  rule.Health(),
					LastError:               lastError,
					Type:                    "alerting",
					PartialResponseStrategy: rule.PartialResponseStrategy.String(),
				}
			case *rules.RecordingRule:
				enrichedRule = recordingRule{
					Name:      rule.Name(),
					Query:     rule.Query().String(),
					Labels:    rule.Labels(),
					Health:    rule.Health(),
					LastError: lastError,
					Type:      "recording",
				}
			default:
				err := fmt.Errorf("failed to assert type of rule '%v'", rule.Name())
				return nil, nil, &qapi.ApiError{qapi.ErrorInternal, err}
			}

			apiRuleGroup.Rules = append(apiRuleGroup.Rules, enrichedRule)
		}
		res.RuleGroups = append(res.RuleGroups, apiRuleGroup)
	}

	return res, nil, nil
}

func (api *API) alerts(r *http.Request) (interface{}, []error, *qapi.ApiError) {
	var alerts []*Alert
	for _, alertingRule := range api.ruleRetriever.AlertingRules() {
		alerts = append(
			alerts,
			rulesAlertsToAPIAlerts(alertingRule.PartialResponseStrategy, alertingRule.ActiveAlerts())...,
		)
	}
	res := &AlertDiscovery{Alerts: alerts}

	return res, nil, nil
}

type AlertDiscovery struct {
	Alerts []*Alert `json:"alerts"`
}

type Alert struct {
	Labels                  labels.Labels `json:"labels"`
	Annotations             labels.Labels `json:"annotations"`
	State                   string        `json:"state"`
	ActiveAt                *time.Time    `json:"activeAt,omitempty"`
	Value                   float64       `json:"value"`
	PartialResponseStrategy string        `json:"partial_response_strategy"`
}

func rulesAlertsToAPIAlerts(s storepb.PartialResponseStrategy, rulesAlerts []*rules.Alert) []*Alert {
	apiAlerts := make([]*Alert, len(rulesAlerts))
	for i, ruleAlert := range rulesAlerts {
		apiAlerts[i] = &Alert{
			PartialResponseStrategy: s.String(),
			Labels:                  ruleAlert.Labels,
			Annotations:             ruleAlert.Annotations,
			State:                   ruleAlert.State.String(),
			ActiveAt:                &ruleAlert.ActiveAt,
			Value:                   ruleAlert.Value,
		}
	}

	return apiAlerts
}

type RuleDiscovery struct {
	RuleGroups []*RuleGroup `json:"groups"`
}

type RuleGroup struct {
	Name string `json:"name"`
	File string `json:"file"`
	// In order to preserve rule ordering, while exposing type (alerting or recording)
	// specific properties, both alerting and recording rules are exposed in the
	// same array.
	Rules                   []rule  `json:"rules"`
	Interval                float64 `json:"interval"`
	PartialResponseStrategy string  `json:"partial_response_strategy"`
}

type rule interface{}

type alertingRule struct {
	Name                    string           `json:"name"`
	Query                   string           `json:"query"`
	Duration                float64          `json:"duration"`
	Labels                  labels.Labels    `json:"labels"`
	Annotations             labels.Labels    `json:"annotations"`
	Alerts                  []*Alert         `json:"alerts"`
	Health                  rules.RuleHealth `json:"health"`
	LastError               string           `json:"lastError,omitempty"`
	Type                    string           `json:"type"`
	PartialResponseStrategy string           `json:"partial_response_strategy"`
}

type recordingRule struct {
	Name      string           `json:"name"`
	Query     string           `json:"query"`
	Labels    labels.Labels    `json:"labels,omitempty"`
	Health    rules.RuleHealth `json:"health"`
	LastError string           `json:"lastError,omitempty"`
	// Type of a recordingRule is always "recording".
	Type string `json:"type"`
}

repository: adobe/thanos

repo_name: adobe/thanos

gha_language: Go


text:
package httputil

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

// JSONEncode encodes the given object to json format and writes it to given ResponseWriter
func JSONEncode(rw http.ResponseWriter, v interface{}) error {
	rw.Header().Set("Content-Type", "application/json")
	return json.NewEncoder(rw).Encode(v)
}

// JSONEncodeWithCode encodes the given object to json format and writes it to given ResponseWriter
// with custom status code
func JSONEncodeWithCode(rw http.ResponseWriter, v interface{}, statusCode int) error {
	rw.Header().Set("Content-Type", "application/json")
	rw.WriteHeader(statusCode)
	return json.NewEncoder(rw).Encode(v)
}

repository: shorim/control-plane

repo_name: shorim/control-plane


text:
@Article{GKNK93,
	author = "Emden R. Gasner and Eleftherios Koutsofios and Stephen C. North and Kiem-Phong Vo",
	Title="A Technique for Drawing Directed Graphs",
	Journal=ieeese,
	Pages="124--230",
	Volume="19",
	Number="3",
	Month=may,
	Year="1993"
	}

@Article{Spi03e,
	Title="On the Declarative Specification of Models",
	Author="Diomidis Spinellis",
	Journal="IEEE Software",
	Month="March/April",
	Year=2003,
	Volume=20,
	Pages="94--96",
	Number=2,
	URL="http://www.dmst.aueb.gr/dds/pubs/jrnl/2003-IEEESW-umlgraph/html/article.html"
	}

@Book	{Spi03i,
	Author="Diomidis Spinellis",
	Title="Code Reading: The Open Source Perspective",
	Publisher="Addison-Wesley",
	Address="Boston, MA",
	URL="http://www.spinellis.gr/codereading",
	Year=2003
	}

@TechReport	{TRPIC,
	Author="Brian W. Kernighan",
	Title="{PIC}---A Graphics Language for typesetting: Revised User Manual",
	Type="Computer Science Technical Report",
	Note="Available online at \url{http://cm.bell-labs.com/cm/cs/cstr}",
	Number="116",
	Month=dec,
	Year="1984",
	Institution="Bell Laboratories",
	Address="Murray Hill, NJ"
	}

@Book	{FS00,
	Author="Martin Fowler and Kendall Scott",
	Title="{UML} Distilled: Applying the Standard Object Modeling Language",
	Publisher="Addison-Wesley",
	ISBN="0-201-65783-X",
	Address="Boston, MA",
	Edition="second",
	Year=2000
	}

@Book{BRJ99,
	Title="The Unified Modeling Language User Guide",
	Author="Grady Booch and James Rumbaugh and Ivar Jacobson",
	Publisher="Addison-Wesley",
	Address="Reading, MA",
	Year="1999",
	ISBN="0-201-57168-4"
	}

@Book{RJB99,
	Title="The Unified Modeling Language Reference Manual",
	Author="James Rumbaugh and Ivar Jacobson and Grady Booch",
	Publisher="Addison-Wesley",
	Address="Reading, MA",
	Year="1999",
	ISBN="0-201-30998-X",
	Where="dds-CD1"
	}

@Book	{Spi06,
	Author="Diomidis Spinellis",
	Title="Code Quality: The Open Source Perspective",
	Publisher="Addison-Wesley",
	Address="Boston, MA",
	URL="http://www.spinellis.gr/codequality",
	XISBN="0-321-16607-8",
	Year=2006
	}

@Misc{Shoe06,
	Title="{UML} Diagrams Using {G}raphviz {D}ot",
	Month=apr,
	Year=2006,
	URL="http://www.ffnn.nl/pages/articles/media/uml-diagrams-using-graphviz-dot.php",
	Note="Available online \url{http://www.ffnn.nl/pages/articles/media/uml-diagrams-using-graphviz-dot.php}",
	Author="Frank Schoep"
}

@TechReport{OMG02,
	Author="{Object Management Group}",
	Title="Human-Usable Textual Notation ({HUTN}) Specification",
	Note="Available online \url{http://www.omg.org/docs/ptc/02-12-01.pdf}",
	URL="http://www.omg.org/docs/ptc/02-12-01.pdf",
	Number="ptc/02-12-01",
	Month=dec,
	Year=2002,
	Institution="OMG Inc.",
	Address="Needham, MA"
	}

@Misc{Mir08,
	Title="Reverse-engineer Source Code into UML Diagrams",
	Month=aug,
	Year=2008,
	URL="http://java.dzone.com/articles/reverse-engineer-source-code-u",
	Note="Available online \url{http://java.dzone.com/articles/reverse-engineer-source-code-u}",
	Author="Meera Subbarao"
}

@CONFERENCE{SG16,
	author={Seifermann, S. and Groenda, H.},
	title={Survey on textual notations for the Unified Modeling Language},
	journal={MODELSWARD 2016 - Proceedings of the 4th International Conference on Model-Driven Engineering and Software Development},
	year={2016},
	pages={28--39},
	note={cited By 0},
	url={https://www.cooperate-project.de/images/publications/MODELSWARD2016.pdf},
	document_type={Conference Paper},
}

repository: dspinellis/UMLGraph

repo_name: dspinellis/UMLGraph

gha_language: Java


text:
// childrenJsonHandler.go contains the handler for returning JSON with children pages.

package site

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

	"zanaduu3/src/core"
	"zanaduu3/src/pages"
)

// childrenJsonData contains parameters passed in to create a page.
type childrenJSONData struct {
	ParentID string
}

var childrenHandler = siteHandler{
	URI:         "/json/children/",
	HandlerFunc: childrenJSONHandler,
}

// childrenJsonHandler handles requests to create a new page.
func childrenJSONHandler(params *pages.HandlerParams) *pages.Result {
	db := params.DB

	// Decode data
	var data childrenJSONData
	err := json.NewDecoder(params.R.Body).Decode(&data)
	if err != nil {
		return pages.Fail("Couldn't decode request", err).Status(http.StatusBadRequest)
	}
	if !core.IsIDValid(data.ParentID) {
		return pages.Fail("Need a valid parentId", nil).Status(http.StatusBadRequest)
	}

	returnData := core.NewHandlerData(params.U)

	// Load the children.
	loadOptions := (&core.PageLoadOptions{
		Children:                true,
		HasGrandChildren:        true,
		RedLinkCountForChildren: true,
	}).Add(core.TitlePlusLoadOptions)
	core.AddPageToMap(data.ParentID, returnData.PageMap, loadOptions)
	err = core.ExecuteLoadPipeline(db, returnData)
	if err != nil {
		return pages.Fail("Pipeline error", err)
	}
	// Remove parent, since we only want to return children.
	delete(returnData.PageMap, data.ParentID)

	return pages.Success(returnData)
}


text:
package database

import (
    "github.com/huangyt39/cloud-disk-backend/models"
    "github.com/huangyt39/cloud-disk-backend/utils"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
    "github.com/sirupsen/logrus"
)

var DB *gorm.DB

func InitMysql(){
    var err error
    DB, err = gorm.Open("mysql", "root:19971128hyt@/cloud_disk?charset=utf8&parseTime=True&loc=Local")
    if err != nil{
        logrus.Errorf("error on initmysql %s", err)
    }
    createIfTableNotExit()
    getLoginStatusFromDB()
}

func createIfTableNotExit(){
    if !DB.HasTable(&models.Folder{}){
        DB.CreateTable(&models.Folder{})
    }
    if err := DB.Error; err != nil{
        logrus.Errorf("error on create table folders, %s", err)
    }
    if !DB.HasTable(&models.File{}){
        DB.CreateTable(&models.File{})
    }
    if err := DB.Error; err != nil{
        logrus.Errorf("error on create table files, %s", err)
    }
    if !DB.HasTable(&models.User{}){
        DB.CreateTable(&models.User{})
    }
    if err := DB.Error; err != nil{
        logrus.Errorf("error on create table users, %s", err)
    }
}

func CreateFolder(name string, username string) error{
    newFolder := models.Folder{Name:name, UserName:username}
    err := DB.Create(&newFolder).Error
    if err != nil{
        return err
    }
    return nil
}

func CreateFile(folder_id int, filename string) error{
    newFile := models.File{
        FolderId:               folder_id,
        Filename:               filename,
        PublicShareUrl:         utils.GenerateUrl(1024),
        PrivateShareUrl:        utils.GenerateUrl(2048),
        PrivateSharePassword:   utils.GeneratePassword(),
        OpenPublicShare:        false,
        OpenPrivateShare:       false,
    }
    err := DB.Create(&newFile).Error
    if err != nil{
        return err
    }
    return nil
}

func GetFolderIDbyName(folder_name string, username string) (int , error){
    var folder models.Folder
    db := DB.Where("name = ? AND user_name = ?", folder_name, username).Find(&folder)
    if err := db.Error; err != nil{
        return 0, err
    }else{
        return folder.ID, nil
    }
}


text:
@article{Casson-2019-Hydrological,
    title = "Hydrological and Seasonal Controls of Phosphorus in Northern Great Plains Agricultural Streams",
    author = "Casson, Nora J.  and
      Wilson, Henry F.  and
      Higgins, Stephanie M.",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36001",
    doi = "10.2134/jeq2018.07.0281",
    pages = "978--987",
}
@article{Costa-2019-Temporal,
    title = "Temporal Dynamics of Snowmelt Nutrient Release from Snow{--}Plant Residue Mixtures: An Experimental Analysis and Mathematical Model Development",
    author = "Costa, Diogo  and
      Liu, Jian  and
      Roste, Jennifer  and
      Elliott, Jane",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36002",
    doi = "10.2134/jeq2018.12.0440",
    pages = "869--879",
}
@article{Kokulan-2019-Contribution,
    title = "Contribution of Overland and Tile Flow to Runoff and Nutrient Losses from Vertisols in Manitoba, Canada",
    author = "Kokulan, Vivekananthan  and
      Macrae, M. L.  and
      Lobb, D. A.  and
      Ali, G. A.",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36003",
    doi = "10.2134/jeq2019.03.0103",
    pages = "959--965",
}
@article{Liu-2019-Agricultural,
    title = "Agricultural Water Quality in Cold Climates: Processes, Drivers, Management Options, and Research Needs",
    author = {Liu, Jian  and
      Baulch, Helen M.  and
      Macrae, Merrin L.  and
      Wilson, Henry F.  and
      Elliott, Jane A.  and
      Bergstr{\"o}m, Lars  and
      Glenn, Aaron J.  and
      Vadas, Peter A.},
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36004",
    doi = "10.2134/jeq2019.05.0220",
    pages = "792--802",
}
@article{Liu-2019-Impacts,
    title = "Impacts of Soil Phosphorus Drawdown on Snowmelt and Rainfall Runoff Water Quality",
    author = "Liu, Jian  and
      Elliott, Jane A.  and
      Wilson, Henry F.  and
      Baulch, Helen M.",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36005",
    doi = "10.2134/jeq2018.12.0437",
    pages = "803--812",
}
@article{Liu-Macrae-2019-Impacts-of,
    title = "Impacts of Cover Crops and Crop Residues on Phosphorus Losses in Cold Climates: A Review",
    author = "Liu, Jian  and
      Macrae, Merrin L.  and
      Elliott, Jane A.  and
      Baulch, Helen M.  and
      Wilson, Henry F.  and
      Kleinman, Peter J.A.",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36006",
    doi = "10.2134/jeq2019.03.0119",
    pages = "850--868",
}
@article{Plach-2019-Agricultural,
    title = "Agricultural Edge‐of‐Field Phosphorus Losses in Ontario, Canada: Importance of the Nongrowing Season in Cold Regions",
    author = "Plach, Janina  and
      Pluer, Will  and
      Macrae, Merrin  and
      Kompanizare, Mazda  and
      McKague, Kevin  and
      Carlow, Ryan  and
      Brunke, Richard",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36007",
    doi = "10.2134/jeq2018.11.0418",
    pages = "813--821",
}
@article{Satchithanantham-2019-Seasonality,
    title = "Seasonality of Phosphorus and Nitrate Retention in Riparian Buffers",
    author = "Satchithanantham, Sanjayan  and
      English, Blair  and
      Wilson, Henry",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36008",
    doi = "10.2134/jeq2018.07.0280",
    pages = "915--921",
}
@article{Schneider-2019-Nutrient,
    title = "Nutrient Loss in Snowmelt Runoff: Results from a Long‐term Study in a Dryland Cropping System",
    author = "Schneider, Kimberley D.  and
      McConkey, Brian G.  and
      Thiagarajan, Arumugam  and
      Elliott, Jane A.  and
      Reid, D. Keith",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36009",
    doi = "10.2134/jeq2018.12.0448",
    pages = "831--840",
}
@article{Wilson-2019-Landscape,
    title = "Landscape Controls on Nutrient Export during Snowmelt and an Extreme Rainfall Runoff Event in Northern Agricultural Watersheds",
    author = "Wilson, Henry F.  and
      Casson, Nora J.  and
      Glenn, Aaron J.  and
      Badiou, Pascal  and
      Boychuk, Lyle",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36010",
    doi = "10.2134/jeq2018.07.0278",
    pages = "841--849",
}
@article{Wilson-2019-Near‐Surface,
    title = "Near‐Surface Soils as a Source of Phosphorus in Snowmelt Runoff from Cropland",
    author = "Wilson, Henry  and
      Elliott, Jane  and
      Macrae, Merrin  and
      Glenn, Aaron",
    journal = "Journal of Environmental Quality, Volume 48, Issue 4",
    volume = "48",
    number = "4",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-36011",
    doi = "10.2134/jeq2019.04.0155",
    pages = "921--930",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications


text:
package cache

import "time"

func WithTTL(ttl time.Duration) Option {
	return func(o *Options) {
		o.TTL = ttl
	}
}


text:
SUMMARY = "Client library to execute notebooks"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=438c1b61bd5f6170c2203d10749c99d2"

SRC_URI[sha256sum] = "0df76a7961d99a681b4796c74a1f2553b9f998851acc01896dce064ad19a9027"
PYPI_PACKAGE = "nbclient"

inherit pypi setuptools3

repository: Xilinx/meta-jupyter

repo_name: Xilinx/meta-jupyter


text:
// Copyright © 2012 Popog
package coroutine

import "testing"

func foo(test *testing.T, t *Thread, a int) []interface{} {
	test.Log("foo", a)
	return t.Yield(2 * a)
}

func TestLua(test *testing.T) {
	test.Log()
	co := CreateFromFunc(func(t *Thread, a, b int) (interface{}, interface{}) {
		test.Log("co-body", a, b)
		r1 := foo(test, t, a+1)
		test.Log("co-body", r1)
		r2 := t.Yield(a+b, a-b)
		test.Log("co-body", r2)
		return b, "end"
	})

	test.Log("main", co.MustResume(1, 10))
	test.Log("main", co.MustResume("r"))
	test.Log("main", co.MustResume("x", "y"))
	if _, err := co.Resume("x", "y"); err != nil {
		test.Log("main", err)
	}
}

func TestWrap(test *testing.T) {
	test.Log()
	co := WrapFromFunc(func(t *Thread, a, b int) (interface{}, interface{}) {
		test.Log("co-body", a, b)
		r1 := foo(test, t, a+1)
		test.Log("co-body", r1)
		r2 := t.Yield(a+b, a-b)
		test.Log("co-body", r2)
		return b, "end"
	})

	test.Log("main", co(1, 10))
	test.Log("main", co("r"))
	test.Log("main", co("x", "y"))
}

func TestStop1(test *testing.T) {
	test.Log()
	co := CreateFromFunc(func(t *Thread, a, b int) (interface{}, interface{}) {
		test.Log("co-body", a, b)
		r1 := foo(test, t, a+1)
		test.Log("co-body", r1)
		r2 := t.Yield(a+b, a-b)
		test.Log("co-body", r2)
		return b, "end"
	})

	test.Log("main", co.MustResume(1, 10))
	co.Stop()
	if _, err := co.Resume("x", "y"); err != nil {
		test.Log("main", err)
	}
}

func TestStop2(test *testing.T) {
	test.Log()
	co := CreateFromFunc(func(t *Thread, a, b int) (interface{}, interface{}) {
		test.Log("co-body", a, b)
		r1 := foo(test, t, a+1)
		test.Log("co-body", r1)
		r2 := t.Yield(a+b, a-b)
		test.Log("co-body", r2)
		return b, "end"
	})

	co.Stop()
	if _, err := co.Resume("x", "y"); err != nil {
		test.Log("main", err)
	}
}

license: Zlib

repository: Popog/coroutine

repo_name: Popog/coroutine