text:
@InProceedings{sabato16,
  author = {Sabato, Sivan and Hess, Tom},
  title = {Interactive Algorithms: from Pool to Stream},
  pages = {1419-1439},
  abstract = {We consider interactive algorithms in the pool-based setting, and in the stream-based setting. Interactive algorithms observe suggested elements (representing actions or queries), and interactively select some of them and receive responses. Pool-based algorithms can select elements at any order, while stream-based algorithms observe elements in sequence, and can only select elements immediately after observing them. We assume that the suggested elements are generated independently from some source distribution, and ask what is the stream size required for emulating a pool algorithm with a given pool size. We provide algorithms and matching lower bounds for general pool algorithms, and for utility-based pool algorithms. We further show that a maximal gap between the two settings exists also in the special case of active learning for binary classification.},
}


text:
LICENSE = "LGPL"

SRCREV = "a80d7d5c25e88adea7b8e843cdb57143e6cfb46b"
SRC_URI = "git://git.0pointer.de/libatasmart.git;protocol=git"

S = "${WORKDIR}/git"
PR = "r1"

inherit autotools lib_package

do_compile_prepend() {
	rm strpool -f
	${BUILD_CC} -o strpool strpool.c
	chmod +x strpool
}

do_install_append() {
	sed -i -e s://:/:g -e s:${base_libdir}/libudev.la:-ludev:g ${D}${libdir}/libatasmart.la
}

license: MIT

repository: libo/openembedded

license_type: permissive

repo_name: libo/openembedded

branch_name: HEAD

extension: bb


text:
SUMMARY = "OP-TEE sanity testsuite"
HOMEPAGE = "https://github.com/OP-TEE/optee_test"

LICENSE = "BSD & GPLv2"
LIC_FILES_CHKSUM = "file://${S}/LICENSE.md;md5=daa2bcccc666345ab8940aab1315a4fa"

inherit python3native

DEPENDS = "optee-client optee-os python3-pycrypto-native"

PV = "3.7.0+git${SRCPV}"

SRC_URI = "git://github.com/OP-TEE/optee_test.git \
          "
S = "${WORKDIR}/git"

SRCREV = "227d6f4c40eaa6f84fe049b9e48c7b27ad7fab08"

OPTEE_CLIENT_EXPORT = "${STAGING_DIR_HOST}${prefix}"
TEEC_EXPORT         = "${STAGING_DIR_HOST}${prefix}"
TA_DEV_KIT_DIR      = "${STAGING_INCDIR}/optee/export-user_ta"

EXTRA_OEMAKE = " TA_DEV_KIT_DIR=${TA_DEV_KIT_DIR} \
                 OPTEE_CLIENT_EXPORT=${OPTEE_CLIENT_EXPORT} \
                 TEEC_EXPORT=${TEEC_EXPORT} \
                 CROSS_COMPILE_HOST=${TARGET_PREFIX} \
                 CROSS_COMPILE_TA=${TARGET_PREFIX} \
                 V=1 \
               "

do_compile() {
    # Top level makefile doesn't seem to handle parallel make gracefully
    oe_runmake xtest
    oe_runmake ta
}

do_install () {
    install -D -p -m0755 ${S}/out/xtest/xtest ${D}${bindir}/xtest

    # install path should match the value set in optee-client/tee-supplicant
    # default TEEC_LOAD_PATH is /lib
    mkdir -p ${D}${nonarch_base_libdir}/optee_armtz/
    install -D -p -m0444 ${S}/out/ta/*/*.ta ${D}${nonarch_base_libdir}/optee_armtz/
}

FILES_${PN} += "${nonarch_base_libdir}/optee_armtz/"

# Imports machine specific configs from staging to build
PACKAGE_ARCH = "${MACHINE_ARCH}"

branch_name: refs/heads/master


text:
#======================================#
#           SUMMARY/LICENCE            #
#--------------------------------------#
SUMMARY = "systemd"
DESCRIPTION = "systemd"

LICENSE = "GPLv2 & bzip2"
LIC_FILES_CHKSUM = "file://LICENSE.GPL2;md5=751419260aa954499f7abaabaa882bbe"

#======================================#
#           REQUIRE/INHERIT            #
#--------------------------------------#
inherit meson split-completion qemu

#======================================#
#                SOURCE                #
#--------------------------------------#
SRC_URI = "https://github.com/systemd/systemd/archive/v${PV}.tar.gz;name=source     \
           file://0001-missing-system-calls.patch                                   \
           file://0002-fix-efi-meson-build.patch                                    \
           "

SRC_URI[source.md5sum] = "d53a925f1ca5b2e124de0a8aa65d0db2"
SRC_URI[source.sha256sum] = "25811f96f5a027bf2a4c9383495cf5b623e385d84da31e473cf375932b3e9c52"

#======================================#
#           DEPENDS/PROVIDES           #
#--------------------------------------#
DEPENDS = "             \
    libxslt-native      \
    intltool-native     \
    gperf-native        \
    gettext-native      \
    "

DEPENDS_append = "      \
    virtual/gettext     \
    kmod                \
    curl                \
    libgcrypt           \
    libcap              \
    libcgroup           \
    libutil-linux       \
    gnutls              \
    elfutils            \
    acl                 \
    libseccomp          \
    "

RDEPENDS_${PN}        = " kmod dbus less "
RDEPENDS_${PN}_append = " util-linux-agetty util-linux-sulogin util-linux-mount "
RDEPENDS_${PN}_append = " pam-plugin-keyinit "

#======================================#
#         BUILD CONFIGURATIONS         #
#--------------------------------------#
PACKAGECONFIG ??= " zlib bzip2 xz lz4 pam idn-libidn utmp "

PACKAGECONFIG[utmp] = "-Dutmp=true, -Dutmp=false"

PACKAGECONFIG[remote]   = "-Dremote=true -Dmicrohttpd=true, -Dremote=false -Dmicrohttpd=false, libmicrohttpd"

PACKAGECONFIG[localed]  = "-Dlocaled=true, -Dlocaled=false"
PACKAGECONFIG[xkbcommon] = "-Dxkbcommon=true, -Dxkbcommon=false, libxkbcommon"

PACKAGECONFIG[zlib] = "-Dzlib=true, -Dzlib=false, zlib"
PACKAGECONFIG[bzip2] = "-Dbzip2=true, -Dbzip2=false, bzip2"
PACKAGECONFIG[xz] = "-Dxz=true, -Dxz=false, xz"
PACKAGECONFIG[lz4] = "-Dlz4=true, -Dlz4=false, lz4"

PACKAGECONFIG[pam] = "-Dpam=true, -Dpam=false, libpam"

PACKAGECONFIG[idn-libidn] = "-Didn=true -Dlibidn=true, -Didn=false, libidn"
PACKAGECONFIG[idn-libidn2] = "-Didn=true -Dlibidn2=true, -Didn=false, libidn2"

PACKAGECONFIG[machined] = "-Dmachined=true, -Dmachined=false"
PACKAGECONFIG[importd] = "-Dimportd=true, -Dimportd=false, zlib bzip2 xz"

# quotaon-path and quotacheck-path will be auto detected
PACKAGECONFIG[quotacheck] = "-Dquotacheck=true, -Dquotacheck=false, quota"

# loadkeys-path and setfont-path will be auto detected
PACKAGECONFIG[vconsole] = "-Dvconsole=true, -Dvconsole=false"

# kexec-path will be auto detected
PACKAGECONFIG[kexec] = ", , kexec-tools"

# Security
PACKAGECONFIG[apparmor] = "-Dapparmor=true, -Dapparmor=false"
PACKAGECONFIG[ima] = "-Dima=true, -Dima=false"
PACKAGECONFIG[audit] = "-Daudit=true, -Daudit=false, audit"
PACKAGECONFIG[tpm] = "-Dtpm=true, -Dtpm=false"
PACKAGECONFIG[smack] = "-Dsmack=true, -Dsmack=false"

# We could have /var/lib/systemd/random-seed link to a file on
# non-volatile storage to save the seed.
#
# Read systemd/src/random-seed/random-seed.c for more info.
PACKAGECONFIG[randomseed] = "-Drandomseed=true, -Drandomseed=false"

PACKAGECONFIG[libcryptsetup] = "-Dlibcryptsetup=true, -Dlibcryptsetup=false, cryptsetup"
PACKAGECONFIG[qrencode] = "-Dqrencode=true, -Dqrencode=false, qrencode"
PACKAGECONFIG[libiptc] = "-Dlibiptc=true, -Dlibiptc=false, iptables"

# Configs that are rarely used
PACKAGECONFIG[rfkill] = "-Drfkill=true, -Drfkill=false"
PACKAGECONFIG[ldconfig] = "-Dldconfig=true, -Dldconfig=false"
PACKAGECONFIG[sysusers] = "-Dsysusers=true, -Dsysusers=false"

EXTRA_OEMESON_append = "                    \
    -D split-usr=false                      \
                                            \
    -D sysvinit-path=''                     \
    -D sysvrcnd-path=''                     \
                                            \
    -D telinit-path='/usr/lib/sysvinit/telinit'     \
    -D quotaon-path='/usr/sbin/quotaon'             \
    -D quotacheck-path='/usr/sbin/quotacheck'       \
    -D kill-path='/usr/bin/kill'                    \
    -D kmod-path='/usr/bin/kmod'                    \
    -D kexec-path='/usr/sbin/kexec'                 \
    -D sulogin-path='/usr/sbin/sulogin'             \
    -D mount-path='/usr/bin/mount'                  \
    -D umount-path='/usr/bin/umount'                \
    -D loadkeys-path='/usr/bin/loadkeys'            \
    -D setfont-path='/usr/bin/setfont'              \
                                            \
    -D hibernate=false                      \
    -D resolve=true                         \
    -D environment-d=true                   \
    -D binfmt=false                         \
    -D coredump=true                        \
    -D logind=true                          \
    -D hostnamed=true                       \
    -D networkd=true                        \
    -D timedated=true                       \
    -D timesyncd=true                       \
    -D firstboot=true                       \
                                            \
    -D nss-systemd=true                     \
                                            \
    -D backlight=false                      \
    -D tmpfiles=true                        \
    -D hwdb=false                           \
                                            \
    -D man=false                            \
    -D html=false                           \
                                            \
    -D rpmmacrosdir=no                      \
                                            \
    -D system-uid-max=999                   \
    -D system-gid-max=999                   \
    -D adm-group=false                      \
    -D wheel-group=false                    \
    -D default-kill-user-processes=true     \
    -D gshadow=false                        \
                                            \
    -D selinux=false                        \
    -D smack=false                          \
    -D polkit=false                         \
    -D seccomp=true                         \
                                            \
    -D libblkid=true                        \
    -D kmod=true                            \
    -D libcurl=true                         \
    -D gcrypt=true                          \
    -D gnutls=true                          \
    -D elfutils=true                        \
    -D glib=false                           \
    -D dbus=false                           \
    -D acl=true                             \
    -D efi=false                            \
                                            \
    -D bashcompletiondir=${datadir}/bash-completion/completions     \
    -D zshcompletiondir=${datadir}/zsh/site-functions               \
                                            \
    -D tests=true                           \
    -D slow-tests=false                     \
    -D install-tests=false                  \
    "

#======================================#
#                TASKS                 #
#--------------------------------------#
do_install_append() {
    install -d ${D}${sysconfdir}
    ln -sr ${D}${libdir}/systemd/resolv.conf ${D}${sysconfdir}/resolv.conf

    # Temporarily remove kernel-install files as they use bashisms
    rm ${D}${libdir}/kernel/install.d/50-depmod.install
    rm ${D}${libdir}/kernel/install.d/90-loaderentry.install
    rm ${D}${bindir}/kernel-install
}

#======================================#
#            PACKAGES/FILES            #
#--------------------------------------#
FILES_${PN} = "/"

#======================================#
#            INSTALL SCRIPT            #
#--------------------------------------#
PACKAGE_WRITE_DEPS_append = " qemu-native "
pkg_postinst_${PN} () {
    ${@qemu_run_binary(d, '$D', '${bindir}/udevadm')} hwdb --update --root $D
}

#======================================#
#             ALTERNATIVES             #
#--------------------------------------#
inherit update-alternatives

ALTERNATIVE_${PN} = " init halt reboot shutdown poweroff "

ALTERNATIVE_TARGET[init] = "${libdir}/systemd/systemd"
ALTERNATIVE_LINK_NAME[init] = "${base_sbindir}/init"

ALTERNATIVE_TARGET[halt] = "${bindir}/systemctl"
ALTERNATIVE_LINK_NAME[halt] = "${sbindir}/halt"

ALTERNATIVE_TARGET[reboot] = "${bindir}/systemctl"
ALTERNATIVE_LINK_NAME[reboot] = "${sbindir}/reboot"

ALTERNATIVE_TARGET[shutdown] = "${bindir}/systemctl"
ALTERNATIVE_LINK_NAME[shutdown] = "${sbindir}/shutdown"

ALTERNATIVE_TARGET[poweroff] = "${bindir}/systemctl"
ALTERNATIVE_LINK_NAME[poweroff] = "${sbindir}/poweroff"

#======================================#
#           USERADD/SYSTEMD            #
#--------------------------------------#
inherit useradd-simple

USERADD_PACKAGES = "${PN}"

USERADD_PARAM_${PN}        = " --system --user-group --shell /bin/false --password '*' systemd-resolve; "
USERADD_PARAM_${PN}_append = " --system --user-group --shell /bin/false --password '*' systemd-timesync; "
USERADD_PARAM_${PN}_append = " --system --user-group --shell /bin/false --password '*' systemd-network; "
GROUPADD_PARAM_${PN}        = " --system systemd-journal; "
GROUPADD_PARAM_${PN}_append = " --system utmp; "

# udevd groups
GROUPADD_PARAM_${PN}_append = " --system audio; "
GROUPADD_PARAM_${PN}_append = " --system cdrom; "
GROUPADD_PARAM_${PN}_append = " --system dialout; "
GROUPADD_PARAM_${PN}_append = " --system disk; "
GROUPADD_PARAM_${PN}_append = " --system input; "
GROUPADD_PARAM_${PN}_append = " --system kmem; "
GROUPADD_PARAM_${PN}_append = " --system kvm; "
GROUPADD_PARAM_${PN}_append = " --system lp; "
GROUPADD_PARAM_${PN}_append = " --system tape; "
GROUPADD_PARAM_${PN}_append = " --system tty; "
GROUPADD_PARAM_${PN}_append = " --system video; "

#======================================#
#                 TEST                 #
#--------------------------------------#


text:
package one

import "sort"

func NumMovesStones(a int, b int, c int) []int {
	pointers := []int{a, b, c}
	sort.Ints(pointers)
	// 3个点之间移动距离
	ab := pointers[1] - pointers[0] - 1
	bc := pointers[2] - pointers[1] - 1
	rs := make([]int, 2)
	// 最小值就是每个最大一次移动
	if ab > 0 {
		rs[0]++
	}
	if bc > 0 {
		rs[0]++
	}
	if (ab == 1 || bc == 1) && rs[0] > 1 {
		// 只需移动1次
		rs[0] = 1
	}
	// 最大值就是都移动到一边
	rs[1] = ab + bc
	return rs
}

repository: zywaited/leetcode

repo_name: zywaited/leetcode

gha_language: Go

extension: go


text:
LICENSE = "GPL"
PV = "0.0cvs${CVSDATE}"
SECTION = "libs"
PRIORITY = "optional"
MAINTAINER = "Phil Blundell <pb@handhelds.org>"
DEPENDS = "x11"
DESCRIPTION = "X11 keyboard library"

SRC_URI = "cvs://anoncvs:anoncvs@pdx.freedesktop.org/cvs/xlibs;module=xkbfile"
S = "${WORKDIR}/xkbfile"

inherit autotools pkgconfig

do_stage() {
	oe_runmake install prefix=${STAGING_DIR} \
	       bindir=${STAGING_BINDIR} \
	       includedir=${STAGING_INCDIR} \
	       libdir=${STAGING_LIBDIR} \
	       datadir=${STAGING_DATADIR}
}

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
package main

import (
	"io/ioutil"
	"net/http"

	"github.com/pkg/errors"
)

func getHTML() (string, error) {
	url := "https://go.dev/blog/"

	response, err := http.Get(url)
	if err != nil {
		return "", errors.Wrap(err, "Error getting blog html")
	}

	defer response.Body.Close()

	html, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return "", errors.Wrap(err, "Error reading blog html")
	}
	return string(html), nil
}

repository: svarogg/goblog-rsser

repo_name: svarogg/goblog-rsser


text:
package middleware
import (
	"time"
	"net/http"
	. "github.com/byrnedo/apibase/logger"
)

func LogTime(next http.Handler) http.Handler{
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		startTime := time.Now()

		next.ServeHTTP(w, r)

		duration := time.Since(startTime).Seconds()

		Info.Printf(`[%.6f] "%s"`, duration, r.URL.Path)
	})
}

repository: byrnedo/oauthsvc

repo_name: byrnedo/oauthsvc


text:
cmake_minimum_required (VERSION 3.2)

# Standard settings
set(CMAKE_LIBRARY_ARCHITECTURE "arm")
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_VERSION 1)
set(UNIX True)
set(ANDROID True)

#set toolchain components
set(CMAKE_C_COMPILER /Developer/android-toolchain-arm64-api24/bin/aarch64-linux-android-clang)
set(CMAKE_CXX_COMPILER /Developer/android-toolchain-arm64-api24/bin/aarch64-linux-android-clang++)

add_definitions(-DANDROID)
add_definitions(-D__SYMBIAN32__ -D__EABI__)

repository: victor-timoshin/Switch

repo_name: victor-timoshin/Switch

extension: cmake


text:
@Proceedings{AISTATS-2014,
  booktitle = {Proceedings of the Seventeenth International Conference on Artificial Intelligence and Statistics},
  editor = {Samuel Kaski and Jukka Corander},
  volume = {33},
  year = {2014},
  shortname = {AISTATS},
  sections = {preface=Preface|notable=Notable Papers|default=Regular Papers}
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_license_id: MIT

gha_language: TeX

extension: bib


text:
package hail

import (
	"context"
	"io/ioutil"
	"os"
	"time"

	"github.com/fsnotify/fsnotify"

	"github.com/ActiveState/cli/internal/errs"
)

// Received represents the data related to a message sent via watched file.
type Received struct {
	Open  time.Time
	Time  time.Time
	Data  []byte
	Error error
}

func newReceived(openedAt time.Time, data []byte, err error) *Received {
	return &Received{
		Open:  openedAt,
		Time:  time.Now(),
		Data:  data,
		Error: err,
	}
}

// Send sends a hail by saving data to the file located by the file name
// provided.
func Send(file string, data []byte) error {
	f, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0660)
	if err != nil {
		return errs.Wrap(err, "OpenFile %s failed", file)
	}
	defer f.Close()

	if _, err = f.Write(data); err != nil {
		return errs.Wrap(err, "Write %s failed", file)
	}

	return nil
}

// Open opens a channel for hailing. A *Received is sent in the returned
// channel whenever the file located by the file name provided is created,
// updated, or deleted.
func Open(ctx context.Context, file string) (<-chan *Received, error) {
	openedAt := time.Now()

	f, err := os.OpenFile(file, os.O_CREATE|os.O_APPEND, 0660)
	if err != nil {
		return nil, errs.Wrap(err, "OpenFile %s failed", file)
	}
	f.Close()

	rcvs, err := monitor(ctx.Done(), openedAt, file)
	if err != nil {
		return nil, errs.Wrap(err, "monitor %s failed", file)
	}

	return rcvs, nil
}

func monitor(done <-chan struct{}, openedAt time.Time, file string) (<-chan *Received, error) {
	w, err := newWatcher(file)
	if err != nil {
		return nil, err
	}

	rcvs := make(chan *Received)

	go func() {
		defer w.Close()
		defer close(rcvs)
		loop(done, w, rcvs, openedAt)
	}()

	return rcvs, nil
}

func loop(done <-chan struct{}, w *watcher, rcvs chan<- *Received, t time.Time) {
	for {
		select {
		case <-done:
			return

		case event, ok := <-w.Events:
			// os.OpenFile calls may trigger both write and chmod events, or a single
			// write|chmod event. Filter chmod and break if no other flag is set.
			if event.Op^fsnotify.Chmod == 0 {
				break
			}

			r := newReceived(t, nil, nil)
			if !ok {
				r.Error = errs.New("events channel is closed")
				rcvs <- r
				return
			}

			data, err := w.data()
			if err != nil {
				r.Error = errs.Wrap(err, "watcher.data failed")
				rcvs <- r
				break
			}

			r.Data = data
			rcvs <- r

		case err, ok := <-w.Errors:
			r := newReceived(t, nil, nil)
			if !ok {
				r.Error = errs.New("errors channel is closed")
				rcvs <- r
				return
			}
			if err != nil {
				r.Error = errs.Wrap(err, "watched failed")
				rcvs <- r
				break
			}

			rcvs <- r
		}
	}
}

type watcher struct {
	*fsnotify.Watcher
	file string
}

func newWatcher(file string) (*watcher, error) {
	fw, err := fsnotify.NewWatcher()
	if err != nil {
		return nil, err
	}

	if err := fw.Add(file); err != nil {
		return nil, err
	}

	w := watcher{
		Watcher: fw,
		file:    file,
	}

	return &w, nil
}

func (w *watcher) data() ([]byte, error) {
	return ioutil.ReadFile(w.file)
}

repository: ActiveState/cli

repo_name: ActiveState/cli


text:
// Code generated - DO NOT EDIT.
// This file is a generated binding and any manual changes will be lost.

package bindings

import (
	"math/big"
	"strings"

	"github.com/ethereum/go-ethereum/accounts/abi"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
)

// TokenTimelockABI is the input ABI used to generate the binding from.
const TokenTimelockABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"beneficiary\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"release\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"releaseTime\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"token\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"_token\",\"type\":\"address\"},{\"name\":\"_beneficiary\",\"type\":\"address\"},{\"name\":\"_releaseTime\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"

// TokenTimelockBin is the compiled bytecode used for deploying new contracts.
const TokenTimelockBin = `6060604052341561000f57600080fd5b6040516060806102bf83398101604052808051919060200180519190602001805191505042811161003f57600080fd5b60008054600160a060020a03948516600160a060020a031991821617909155600180549390941692169190911790915560025561023e806100816000396000f3006060604052600436106100485763ffffffff60e060020a60003504166338af3eed811461004d57806386d1a69f1461007c578063b91d400114610091578063fc0c546a146100b6575b600080fd5b341561005857600080fd5b6100606100c9565b604051600160a060020a03909116815260200160405180910390f35b341561008757600080fd5b61008f6100d8565b005b341561009c57600080fd5b6100a4610185565b60405190815260200160405180910390f35b34156100c157600080fd5b61006061018b565b600154600160a060020a031681565b6002546000904210156100ea57600080fd5b600054600160a060020a03166370a082313060405160e060020a63ffffffff8416028152600160a060020a039091166004820152602401602060405180830381600087803b151561013a57600080fd5b5af1151561014757600080fd5b50505060405180519150506000811161015f57600080fd5b60015460005461018291600160a060020a0391821691168363ffffffff61019a16565b50565b60025481565b600054600160a060020a031681565b82600160a060020a031663a9059cbb838360405160e060020a63ffffffff8516028152600160a060020a0390921660048301526024820152604401602060405180830381600087803b15156101ee57600080fd5b5af115156101fb57600080fd5b50505060405180519050151561020d57fe5b5050505600a165627a7a72305820c1da92bfd524c09ee3be2faa41aaf5f9f715caa4055e178efd1516695532d6bd0029`

// DeployTokenTimelock deploys a new Ethereum contract, binding an instance of TokenTimelock to it.
func DeployTokenTimelock(auth *bind.TransactOpts, backend bind.ContractBackend, _token common.Address, _beneficiary common.Address, _releaseTime *big.Int) (common.Address, *types.Transaction, *TokenTimelock, error) {
	parsed, err := abi.JSON(strings.NewReader(TokenTimelockABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(TokenTimelockBin), backend, _token, _beneficiary, _releaseTime)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &TokenTimelock{TokenTimelockCaller: TokenTimelockCaller{contract: contract}, TokenTimelockTransactor: TokenTimelockTransactor{contract: contract}}, nil
}

// TokenTimelock is an auto generated Go binding around an Ethereum contract.
type TokenTimelock struct {
	TokenTimelockCaller     // Read-only binding to the contract
	TokenTimelockTransactor // Write-only binding to the contract
}

// TokenTimelockCaller is an auto generated read-only Go binding around an Ethereum contract.
type TokenTimelockCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// TokenTimelockTransactor is an auto generated write-only Go binding around an Ethereum contract.
type TokenTimelockTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// TokenTimelockSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type TokenTimelockSession struct {
	Contract     *TokenTimelock    // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// TokenTimelockCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type TokenTimelockCallerSession struct {
	Contract *TokenTimelockCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts        // Call options to use throughout this session
}

// TokenTimelockTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type TokenTimelockTransactorSession struct {
	Contract     *TokenTimelockTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
}

// TokenTimelockRaw is an auto generated low-level Go binding around an Ethereum contract.
type TokenTimelockRaw struct {
	Contract *TokenTimelock // Generic contract binding to access the raw methods on
}

// TokenTimelockCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type TokenTimelockCallerRaw struct {
	Contract *TokenTimelockCaller // Generic read-only contract binding to access the raw methods on
}

// TokenTimelockTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type TokenTimelockTransactorRaw struct {
	Contract *TokenTimelockTransactor // Generic write-only contract binding to access the raw methods on
}

// NewTokenTimelock creates a new instance of TokenTimelock, bound to a specific deployed contract.
func NewTokenTimelock(address common.Address, backend bind.ContractBackend) (*TokenTimelock, error) {
	contract, err := bindTokenTimelock(address, backend, backend)
	if err != nil {
		return nil, err
	}
	return &TokenTimelock{TokenTimelockCaller: TokenTimelockCaller{contract: contract}, TokenTimelockTransactor: TokenTimelockTransactor{contract: contract}}, nil
}

// NewTokenTimelockCaller creates a new read-only instance of TokenTimelock, bound to a specific deployed contract.
func NewTokenTimelockCaller(address common.Address, caller bind.ContractCaller) (*TokenTimelockCaller, error) {
	contract, err := bindTokenTimelock(address, caller, nil)
	if err != nil {
		return nil, err
	}
	return &TokenTimelockCaller{contract: contract}, nil
}

// NewTokenTimelockTransactor creates a new write-only instance of TokenTimelock, bound to a specific deployed contract.
func NewTokenTimelockTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenTimelockTransactor, error) {
	contract, err := bindTokenTimelock(address, nil, transactor)
	if err != nil {
		return nil, err
	}
	return &TokenTimelockTransactor{contract: contract}, nil
}

// bindTokenTimelock binds a generic wrapper to an already deployed contract.
func bindTokenTimelock(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(TokenTimelockABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_TokenTimelock *TokenTimelockRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _TokenTimelock.Contract.TokenTimelockCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_TokenTimelock *TokenTimelockRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _TokenTimelock.Contract.TokenTimelockTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_TokenTimelock *TokenTimelockRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _TokenTimelock.Contract.TokenTimelockTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_TokenTimelock *TokenTimelockCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _TokenTimelock.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_TokenTimelock *TokenTimelockTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _TokenTimelock.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_TokenTimelock *TokenTimelockTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _TokenTimelock.Contract.contract.Transact(opts, method, params...)
}

// Beneficiary is a free data retrieval call binding the contract method 0x38af3eed.
//
// Solidity: function beneficiary() constant returns(address)
func (_TokenTimelock *TokenTimelockCaller) Beneficiary(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _TokenTimelock.contract.Call(opts, out, "beneficiary")
	return *ret0, err
}

// Beneficiary is a free data retrieval call binding the contract method 0x38af3eed.
//
// Solidity: function beneficiary() constant returns(address)
func (_TokenTimelock *TokenTimelockSession) Beneficiary() (common.Address, error) {
	return _TokenTimelock.Contract.Beneficiary(&_TokenTimelock.CallOpts)
}

// Beneficiary is a free data retrieval call binding the contract method 0x38af3eed.
//
// Solidity: function beneficiary() constant returns(address)
func (_TokenTimelock *TokenTimelockCallerSession) Beneficiary() (common.Address, error) {
	return _TokenTimelock.Contract.Beneficiary(&_TokenTimelock.CallOpts)
}

// ReleaseTime is a free data retrieval call binding the contract method 0xb91d4001.
//
// Solidity: function releaseTime() constant returns(uint256)
func (_TokenTimelock *TokenTimelockCaller) ReleaseTime(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _TokenTimelock.contract.Call(opts, out, "releaseTime")
	return *ret0, err
}

// ReleaseTime is a free data retrieval call binding the contract method 0xb91d4001.
//
// Solidity: function releaseTime() constant returns(uint256)
func (_TokenTimelock *TokenTimelockSession) ReleaseTime() (*big.Int, error) {
	return _TokenTimelock.Contract.ReleaseTime(&_TokenTimelock.CallOpts)
}

// ReleaseTime is a free data retrieval call binding the contract method 0xb91d4001.
//
// Solidity: function releaseTime() constant returns(uint256)
func (_TokenTimelock *TokenTimelockCallerSession) ReleaseTime() (*big.Int, error) {
	return _TokenTimelock.Contract.ReleaseTime(&_TokenTimelock.CallOpts)
}

// Token is a free data retrieval call binding the contract method 0xfc0c546a.
//
// Solidity: function token() constant returns(address)
func (_TokenTimelock *TokenTimelockCaller) Token(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _TokenTimelock.contract.Call(opts, out, "token")
	return *ret0, err
}

// Token is a free data retrieval call binding the contract method 0xfc0c546a.
//
// Solidity: function token() constant returns(address)
func (_TokenTimelock *TokenTimelockSession) Token() (common.Address, error) {
	return _TokenTimelock.Contract.Token(&_TokenTimelock.CallOpts)
}

// Token is a free data retrieval call binding the contract method 0xfc0c546a.
//
// Solidity: function token() constant returns(address)
func (_TokenTimelock *TokenTimelockCallerSession) Token() (common.Address, error) {
	return _TokenTimelock.Contract.Token(&_TokenTimelock.CallOpts)
}

// Release is a paid mutator transaction binding the contract method 0x86d1a69f.
//
// Solidity: function release() returns()
func (_TokenTimelock *TokenTimelockTransactor) Release(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _TokenTimelock.contract.Transact(opts, "release")
}

// Release is a paid mutator transaction binding the contract method 0x86d1a69f.
//
// Solidity: function release() returns()
func (_TokenTimelock *TokenTimelockSession) Release() (*types.Transaction, error) {
	return _TokenTimelock.Contract.Release(&_TokenTimelock.TransactOpts)
}

// Release is a paid mutator transaction binding the contract method 0x86d1a69f.
//
// Solidity: function release() returns()
func (_TokenTimelock *TokenTimelockTransactorSession) Release() (*types.Transaction, error) {
	return _TokenTimelock.Contract.Release(&_TokenTimelock.TransactOpts)
}

repository: polyswarm/polyswarm

repo_name: polyswarm/polyswarm


text:
package openshift

import (
	"strconv"
	"sync"
	"testing"

	"github.com/fabric8-services/fabric8-jenkins-idler/internal/idler"
	"github.com/stretchr/testify/assert"
)

func Test_retrieve_idler_for_unknown_namespace_returns_nil(t *testing.T) {
	m := NewUserIdlerMap()
	idler, ok := m.Load("foo")
	assert.False(t, ok, "There should be no entry mapped")
	assert.Nil(t, idler, "No reference should be returned")
}

func Test_retrieve_idler_for_empty_namespace_returns_nil(t *testing.T) {
	m := NewUserIdlerMap()
	idler, ok := m.Load("")
	assert.False(t, ok, "There should be no entry mapped")
	assert.Nil(t, idler, "No reference should be returned")
}

func Test_len(t *testing.T) {
	m := NewUserIdlerMap()
	assert.Equal(t, 0, m.Len(), "Empty map should return 0 len")
	m.Store("foo", &idler.UserIdler{})
	assert.Equal(t, 1, m.Len(), "Len should return number of items")
}

func Test_len_mutli(t *testing.T) {
	m := NewUserIdlerMap()
	assert.Equal(t, 0, m.Len(), "Empty map should return 0 len")

	const n = 50
	wg := &sync.WaitGroup{}

	wg.Add(n)
	for i := 0; i < n; i++ {
		go func(x int) {
			defer wg.Done()

			key := strconv.Itoa(x)
			m.Store(key, &idler.UserIdler{})
		}(i)
	}

	wg.Wait()
	assert.Equal(t, n, m.Len(), "Len should return number of items")
}


text:
DESCRIPTION = "Lua is a powerful light-weight programming language designed \
for extending applications."
LICENSE = "MIT"
HOMEPAGE = "http://www.lua.org/"

DEPENDS += "readline"
PR = "r5"
SRC_URI = "http://www.lua.org/ftp/lua-${PV}.tar.gz \
           file://lua5.1.pc"
S = "${WORKDIR}/lua-${PV}"

inherit pkgconfig binconfig

TARGET_CC_ARCH += " -fPIC ${LDFLAGS}"
EXTRA_OEMAKE = "'CC=${CC} -fPIC' 'MYCFLAGS=${CFLAGS} -DLUA_USE_LINUX -fPIC' MYLDFLAGS='${LDFLAGS}'"

do_compile () {
	cp ${WORKDIR}/lua5.1.pc ${S}/
	oe_runmake linux
}

do_install () {
	oe_runmake \
		'INSTALL_TOP=${D}${prefix}' \
		'INSTALL_BIN=${D}${bindir}' \
		'INSTALL_INC=${D}${includedir}/' \
		'INSTALL_MAN=${D}${mandir}/man1' \
		'INSTALL_SHARE=${D}${datadir}/lua' \
		install
}
NATIVE_INSTALL_WORKS = 1
BBCLASSEXTEND = "native"

SRC_URI[md5sum] = "d0870f2de55d59c1c8419f36e8fac150"
SRC_URI[sha256sum] = "b038e225eaf2a5b57c9bcc35cd13aa8c6c8288ef493d52970c9545074098af3a"


text:
package paperless

import (
	"encoding/json"
	"fmt"

	log "github.com/sirupsen/logrus"
)

// Correspondent is a struct representation of Paperless' /api/correspondents/<id> JSON response.
type Correspondent struct {
	ID                int               `json:"id"`
	Slug              string            `json:"slug"`
	Name              string            `json:"name"`
	Match             string            `json:"match"`
	MatchingAlgorithm MatchingAlgorithm `json:"matching_algorithm"`
	IsInsensitive     bool              `json:"is_insensitive"`
}

// How should we represent a Correspondent object when trying to stringify it? This returns the struct as a string.
func (c Correspondent) String() string {
	return fmt.Sprintf("ID: %v, Slug: %v, Name: %v, Match: %v, Matching Algorithm: %v, Is Insensitive: %v",
		c.ID, c.Slug, c.Name, c.Match, c.MatchingAlgorithm, c.IsInsensitive)
}

// CorrespondentList is a slice of https://godoc.org/github.com/stgarf/paperless-cli/paperless/#Correspondent structs.
type CorrespondentList []Correspondent

// GetCorrespondent returns a https://godoc.org/github.com/stgarf/paperless-cli/paperless/#CorrespondentList matching the search string.
func (p Paperless) GetCorrespondent(s string, caseSensitive bool) (CorrespondentList, error) {
	// A place to store the results
	var c Correspondent
	var cl CorrespondentList

	// Make the request
	if caseSensitive {
		p.Root += "/correspondents/?name__contains=" + s
	} else {
		p.Root += "/correspondents/?name__icontains=" + s
	}
	u := fmt.Sprint(p)
	results, err := p.MakeGetRequest(u)
	if err != nil {
		log.Errorf("An error occurred making request: %v", err.Error())
	}

	// Append results so far to CorrespondentList cl
	for _, corr := range results {
		json.Unmarshal([]byte(corr.Raw), &c)
		json.Unmarshal([]byte(corr.Raw), &c)
		cl = append(cl, c)
	}
	return cl, nil
}

// GetCorrespondents returns a https://godoc.org/github.com/stgarf/paperless-cli/paperless/#CorrespondentList.
func (p Paperless) GetCorrespondents() (CorrespondentList, error) {
	// A place to store the results
	var c Correspondent
	var cl CorrespondentList

	// Make the request
	p.Root += "/correspondents"
	u := fmt.Sprint(p)
	results, err := p.MakeGetRequest(u)
	if err != nil {
		log.Errorf("An error occurred making request: %v", err.Error())
	}

	// Append results so far to CorrespondentList cl
	for _, corr := range results {
		json.Unmarshal([]byte(corr.Raw), &c)
		cl = append(cl, c)
	}
	return cl, nil
}

repository: stgarf/paperless-cli

repo_name: stgarf/paperless-cli


text:
@INPROCEEDINGS{6651094,
    author={M. {Wasi-ur-Rahman} and N. S. {Islam} and X. {Lu} and J. {Jose} and H. {Subramoni} and H. {Wang} and D. K. D. {Panda}},
    booktitle={2013 IEEE International Symposium on Parallel Distributed Processing, Workshops and Phd Forum},
    title={High-Performance RDMA-based Design of Hadoop MapReduce over InfiniBand},
    year={2013},
    volume={},
    number={},
    pages={1908-1917},
    doi={10.1109/IPDPSW.2013.238},
    ISSN={},
    month={05},
}

gha_license_id: NOASSERTION


text:
@Manual{R-base,
  title = {R: A Language and Environment for Statistical Computing},
  author = {{R Core Team}},
  organization = {R Foundation for Statistical Computing},
  address = {Vienna, Austria},
  year = {2019},
  url = {https://www.R-project.org/},
}
@Manual{R-bookdown,
  title = {bookdown: Authoring Books and Technical Documents with R Markdown},
  author = {Yihui Xie},
  year = {2019},
  note = {R package version 0.14},
  url = {https://CRAN.R-project.org/package=bookdown},
}
@Manual{R-circlize,
  title = {circlize: Circular Visualization},
  author = {Zuguang Gu},
  year = {2019},
  note = {R package version 0.4.8},
  url = {https://CRAN.R-project.org/package=circlize},
}
@Manual{R-emba,
  title = {emba: Ensemble Boolean Model Biomarker Analysis},
  author = {John Zobolas},
  note = {R package version 0.1.1},
  url = {https://github.com/bblodfon/emba},
  year = {2019},
}
@Manual{R-knitr,
  title = {knitr: A General-Purpose Package for Dynamic Report Generation in R},
  author = {Yihui Xie},
  year = {2019},
  note = {R package version 1.25},
  url = {https://CRAN.R-project.org/package=knitr},
}
@Manual{R-rmarkdown,
  title = {rmarkdown: Dynamic Documents for R},
  author = {JJ Allaire and Yihui Xie and Jonathan McPherson and Javier Luraschi and Kevin Ushey and Aron Atkins and Hadley Wickham and Joe Cheng and Winston Chang and Richard Iannone},
  year = {2019},
  note = {R package version 1.16},
  url = {https://CRAN.R-project.org/package=rmarkdown},
}
@Manual{R-usefun,
  title = {usefun: A Collection of Useful Functions by John},
  author = {John Zobolas},
  note = {R package version 0.4.1},
  url = {https://github.com/bblodfon/usefun},
  year = {2019},
}

repository: druglogics/gitsbe-model-analysis

repo_name: druglogics/gitsbe-model-analysis


text:
DESCRIPTION = "Task to provide factory default packages"
ALLOW_EMPTY = "1"
PR = "r1"

PACKAGES = "${PN}"

RDEPENDS_${PN} = "\
    ti-dvsdk-demos \
    ti-data \
    ti-dvsdk-demos-rc \
    "


text:
//   Copyright 2017 MSolution.IO
//
//   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 users

import (
	"database/sql"
	"errors"
	"fmt"
	"net/http"

	"github.com/trackit/jsonlog"
	"github.com/trackit/trackit2/db"
	"github.com/trackit/trackit2/routes"
)

const (
	passwordMaxLength = 12
)

var (
	ErrPasswordTooShort = errors.New(fmt.Sprintf("Password must be at least %u characters.", passwordMaxLength))
)

func init() {
	routes.Register(
		"/user",
		createUser,
		routes.RequireMethod{"POST"},
		routes.RequireContentType{"application/json"},
		db.WithTransaction{db.Db},
	)
}

type createUserRequestBody struct {
	Email    string `json:"email"`
	Password string `json:"password"`
}

func createUser(request *http.Request, a routes.Arguments) (int, interface{}) {
	var body createUserRequestBody
	err := decodeRequestBody(request, &body)
	tx := a[db.Transaction].(*sql.Tx)
	if err == nil && body.valid() {
		return createUserWithValidBody(request, body, tx)
	} else {
		return 400, errors.New("Body is invalid.")
	}
}

func (body createUserRequestBody) valid() bool {
	return body.Email != "" && body.Password != ""
}

func createUserWithValidBody(request *http.Request, body createUserRequestBody, tx *sql.Tx) (int, interface{}) {
	ctx := request.Context()
	logger := jsonlog.LoggerFromContextOrDefault(ctx)
	user, err := CreateUserWithPassword(ctx, tx, body.Email, body.Password)
	if err == nil {
		logger.Info("User created.", user)
		return 200, user
	} else {
		logger.Error(err.Error(), nil)
		return 500, errors.New("Failed to create user.")
	}
}

repository: giubil/trackit-server

repo_name: giubil/trackit-server


text:
@BOOK{Krizhanovsky2015,
    language = {russian},
	author = {Крижановский, Андрей},
	title = {Работа в вики-среде на примере Русской Википедии: Учебное пособие для студентов и преподавателей вузов},
	publisher = {ПетрГУ},
	year = {2015},
    numpages = {114},
    note = {Препринт.},
    url={http://nauchkor.ru/uploads/documents/5690f7f35f1be74d9400018e.pdf}
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Ниже идут примеры. Ссылки на источники добавляйте ниже с разбивкой по главам.

@BOOK{Bringhurst2005,
    language = {english},
	author = {Robert Bringhurst},
	title = {The Elements of Typography},
	publisher = {Hartley \& Marks},
	year = {2005},
	edition = {3.1},
	isbn = {0-88179-205-5}
}

@BOOK{Mittelbach2004,
    language = {english},
	author = {Frank Mittelbach and Michel Goossens},
	title = {The \LaTeX\ Companion},
	publisher = {Addison--Wesley},
	year = {2004},
	edition = {Second},
	isbn = {0-201-36299-6}
}

@BOOK{KamrianiAndRoy2016,
    language = {english},
	author = {Kamriani, Felicia and Roy, Krishnendu},
	title = {App Inventor~2 Essentials},
	publisher = {Packt},
	year = {2016},
}

@BOOK{Galanin,
    language = {russian},
	author = {Галанин Д. Д.},
	title = {Леонтий Филиппович Магницкий и его арифметика},
	publisher = {Типография О. Л. Сомовой},
	year = {1914},
}

%%%%%%%% aircraft references begin %%%%%%%%%%%%%%%%%%%%

@misc{count_of_aircraft_manufactures,
    language = {english},
    author = {Bálint Tóth},
    key = {List of all Manufacturers},
    title={Aviation Fanatic~--- Free online aviation encyclopedia and pilot logbook},
    year={2020},
    publisher={//Aviation Fanatic - Free online aviation encyclopedia and pilot logbook},
    howpublished = {\url{https://www.aviationfanatic.com/ent_list.php?ent=3}}
}

@misc{count_plants_of_aircrafts,
    language = {english},
    author = {Bálint Tóth},
    key = {List of Manufacturers found},
    title={Aviation Fanatic~--- Free online aviation encyclopedia and pilot logbook},
    year={2020},
    publisher={//Aviation Fanatic - Free online aviation encyclopedia and pilot logbook},
    howpublished = {\url{https://www.aviationfanatic.com/ent_list.php?ent=3&MAN_Country=RU}}
}

@misc{aircraft_prowd,
    language = {english},
    author = {Potes Artem},
    title = {Aircraft in {Russia}, {ProWD}},
    year = {2020},
    howpublished = {\url{https://prowd.id/dashboards/972cd00ce110/profile}}
}

%%%%%%%% aircraft references end %%%%%%%%%%%%%%%%%%%%

%%%%%%%% city references begin %%%%%%%%%%%%%%%%%%%

@misc{city_prowd,
    language = {english},
    author = {Menshikova, Ekaterina},
    title = {Cities in {Russia}, {ProWD}},
    year = {2020},
    howpublished = {\url{https://bit.ly/3lJukwQ}}
}

@misc{big_city_prowd,
    language = {english},
    author = {Menshikova, Ekaterina},
    title = {Big cities in {Russia}, {ProWD}},
    year = {2020},
    howpublished = {\url{https://bit.ly/2VF62t1}}
}

@article{Salkova2020,
    language = {russian},
    author = {Салькова, Алла},
    title = {Рост не бесконечен: что ждет население планеты к концу века},
    year = {2020},
    journal = {Газета.Ru},
    url = {https://bit.ly/3mPOhDi}
}

@misc{sister_city,
    language = {russian},
    key = {Международная ассоциация <<Породнённые города>> (МАПГ)},
    title = {Породнённые города},
    year = {2020},
    howpublished = {\url{https://bit.ly/3qs2JUt}}
}

@misc{city_perepis_2010,
    language = {russian},
    author = {Федеральная служба государственной статистики},
    title = {Итоги всероссийской переписи населения 2010 года},
    chapter = {Число районов, городских и сельских населенных пунктов по субъектам Российской Федерации},
    year = {2010},
    howpublished = {\url{https://bit.ly/2JPL34b}}
}

@misc{city_perepis_2014,
    language = {russian},
    author = {Федеральная служба государственной статистики},
    title = {Итоги переписи населения в Крымском федеральном округе},
    chapter = {Размещение населения по территории Крымского федерального округа},
    year = {2015},
    howpublished = {\url{https://bit.ly/2Lflc6F}}
}

%%%%%%%% city references end   %%%%%%%%%%%%%%%%%%%

%%%%%%%% country references begin %%%%%%%%%%%%%%%%%%%
@misc{prowd_balakireva,
    language = {english},
    author = {Balakireva, Maria},
    title = {Countries, {ProWD}},
    year = {2020},
    howpublished = {\url{http://bit.ly/3o7Bxsz}}
}

@misc{oksm,
    language = {russian},
    key = {World classifier},
    title={Общероссийский классификатор стран мира},
    year={2019},
    publisher={Общероссийские классификаторы: расшифровка, описание, коды.},
    howpublished = {\url{https://classifikators.ru/oksm}}
}

@misc{list_of_sovereign_states,
    language = {russian},
	author = {{Русская Википедия}},
    title={Список государств},
    year={2020},
    howpublished = {\url{https://w.wiki/dWv}}
}

@misc{list_of_sovereign_states_en,
    language = {english},
    key = {English Wikipedia},
    title = {List of sovereign states},
    year = {2020},
    howpublished = {\url{https://w.wiki/d5s}}
}

@article{Zhuravleva2012,
    language  = {russian},
    title     = {Особенности перевода катойконимов (на материале испанского и русского языков)},
    author    = {Журавлева, Наталия Юрьевна},
    year      = {2012},
    pages     = {41--48},
    number    = {3},
    journal   = {Вестник Российского университета дружбы народов. Серия: Лингвистика},
    publisher = {Изд-во РУДН},
	issn      = {2686-8024},
    url = {http://journals.rudn.ru/linguistics/article/view/9530},
}
%%%%%%%% country references end   %%%%%%%%%%%%%%%%%%%

%%%%%%%% operating system references begin %%%%%%%%%%%%%%%%%%%

@misc{list_operating_systems,
	language = {english},
	author={Berka, Stefan},
	year={2020},
	title = {Operating System},
	howpublished = {\url{https://www.operating-system.org/}}
}

@misc{prowd_os_link_ru,
	language = {english},
	title={{ProWD}:  {Operating} systems in {Russia}},
	author={Sysoev, Maxim},
	year={2020},
	publisher={Wikimedia Deutschland Blog},
	howpublished = {\url{https://prowd.id/dashboards/aa81a0428264/profile}}
}

@misc{prowd_os_link,
	language = {english},
	title={{ProWD}:  {Operating} systems},
	author={Sysoev, Maxim},
	year={2020},
	publisher={Wikimedia Deutschland Blog},
	howpublished = {\url{https://prowd.id/dashboards/7a3bd00c32ec/profile}}
}

@misc{Samuel2020DocumentingWiki,
	language = {english},
	title={Documenting {S}oftware {A}pplications on {W}ikidata},
	author={Samuel, John},
	year={2020},
	howpublished = {\url{https://bit.ly/394v0tl}}
}

@misc{WQSResultViews,
	language = {english},
	title={{SPARQL} query service/{W}ikidata {Q}uery {H}elp/{R}esult {V}iews},
	author={Wikipedia},
	year={2020},
	howpublished = {\url{https://w.wiki/ua2}}
}

@misc{Cilyurik2014LangPerformance,
	language = {russian},
	title={Производительность языков программирования. Часть 1},
	author={Цилюрик, Олег},
	year={2014},
	howpublished = {\url{https://ibm.co/2LTwC0o}}
}

%%%%%%%% operating system references end %%%%%%%%%%%%%%%%%%%

%%%%%%%% programming languages references begin   %%%%%%%%%%%%%%%%%%%

@misc{where_devs_live_2017,
    language = {russian},
    author = {Крижановский Андрей, Ковальчук Денис},
    title = {Где учатся и кем работают изобретатели языков программирования},
    year = {2017},
    howpublished = {\url{https://www.authorea.com/users/86022/articles/155483-wd-programming-language}}
}

@misc{where_devs_live_2,
    language = {russian},
    author = {Крижановский Андрей, Ковальчук Денис},
    title = {Где учатся и кем работают изобретатели языков программирования},
    year = {2017},
    howpublished = {\url{ http://nauchkor.ru/pubs/gde-uchatsya-i-kem-rabotayut-izobretateli-yazykov-programmirovaniya-592e95045f1be70a41c8badf}}
}

@misc{prog_langs_2020,
    language = {russian},
    author = {Бурдин, Григорий},
    title = {Языки программирования},
    year = {2020},
    howpublished = {\url{https://www.authorea.com/users/86022/articles/155483-wd-programming-language}}
}

@misc{oo_langs_bourabai,
    language = {russian},
	author = {Ковальчук, Денис},
    title = {Объектно-ориентированное программирование (ООП-1)},
    howpublished = {\url{http://bourabai.ru/alg/oop.htm}},
	year = {2017},

}

@misc{oo_langs_science_wikia,
    language = {russian},
	author = {Ковальчук, Денис},
    title = {Объектно-ориентированное программирование},
    howpublished = {\url{https://bit.ly/33aFvIw}},
	year = {2017},
}

@misc{oo_langs_garshin,
    language = {russian},
	author={Игорь, Гаршин},
    title = {Первые языки объектно-ориентированного программирования (ООП)},
    howpublished = {\url{http://www.garshin.ru/it/computer-languages/object-pioners.html}},
	year = {2017},
}

@misc{prowd_langs_link,
    language = {english},
    title={ProWD:  Operating systems in Russia.},
    author={Burdin, Grigoriy},
    year={2020},
    publisher={Wikimedia Deutschland Blog},
    howpublished = {\url{https://prowd.id/dashboards/2dc82ab0b51e/profile}}
}
%%%%%%%% programming languages references end   %%%%%%%%%%%%%%%%%%%

%%%%%%%% ship references begin   %%%%%%%%%%%%%%%%%%%

@misc{ProWD_ru_ships,
language     = {english},
author       = {Larionov, Dmitry},
title        = {Ships in Russia, {ProWD}},
year         = {2020},
howpublished = {\url{https://prowd.id/dashboards/84384d0e7230/profile}}
}

@misc{FleetMon,
  language     = {english},
  author       = {JAKOTA Cruise Systems GmbH},
  title        = {FleetMon Tracking the Seven Seas},
  year         = {2020},
  howpublished = {\url{https://www.fleetmon.com/vessels/}}
}

@misc{RussianShips,
  language     = {russian},
  author       = {Волков Роман, Бричевский Андрей},
  title        = {RussianShips.info},
  year         = {2020},
  howpublished = {\url{http://russianships.info/today/}},
}

%%%%%%%% ship references end   %%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Ниже идут примеры. Ссылки на статьи, журналы и сайты в алфавитном порядке добавляйте выше.

@misc{Giesemann2020,
    language = {english},
    title={ProWD: Detecting Knowledge Imbalances on Wikidata},
    author={Giesemann, Elisabeth},
    year={2020},
    publisher={Wikimedia Deutschland Blog},
    howpublished = {\url{https://blog.wikimedia.de/2020/09/16/prowd-detecting-knowledge-imbalances-on-wikidata/}}
}

@misc{WDNationalFlags,
    language = {russian},
    author = {Викиданные},
    title = {Список государственных флагов},
    year = {2018},
    howpublished = {\url{http://bit.ly/2OgIdWo}}
}

@misc{MitManyScreens,
    language = {english},
    author = {MIT App Inventor},
    title = {Building Apps with many Screens},
    year = {2012},
    howpublished = {\url{http://ai2.appinventor.mit.edu/reference/other/manyscreens.html}}
}

@misc{Chase2018,
    language = {russian},
    author = {Чейз Адамс},
    title = {Стили написания составных слов в программировании},
    year = {2018},
    howpublished = {\url{https://techrocks.ru/2018/08/09/most-common-programming-case-types/}}
}

@misc{PanfilovaApp,
    language = {russian},
    author = {Панфилова О.С.},
    title = {Программа <<Угадыватель чисел>>},
    year = {2018},
    howpublished = {\url{http://ai2.appinventor.mit.edu/?galleryId=5558160511336448}}
}


text:
SUMMARY = "QtQuick plugins to build user interfaces based on the KDE UX guidelines"
LICENSE = "LGPL-2.0-or-later"
LIC_FILES_CHKSUM = " \
    file://LICENSES/LGPL-2.0-or-later.txt;md5=6d2d9952d88b50a51a5c73dc431d06c7 \
"

inherit kde-kf5

# Is that true: We are depending on plasma-framework and are a tier2??
DEPENDS += " \
    kpackage-native \
    qtquickcontrols2 \
    qtsvg \
"

PV = "${KF5_VERSION}"

SRC_URI[sha256sum] = "b988ebaf93271951aa91ad28cd849d2496a5bb1ef07d425213a81cc0d4dd03e2"

FILES:${PN} += " \
    ${datadir}/kdevappwizard \
    ${OE_QMAKE_PATH_QML} \
"

RPROVIDES:${PN} += "kirigami"
RREPLACES:${PN} += "kirigami"
RCONFLICTS:${PN} += "kirigami"


text:
package wdk

// AlibabaWdkSkuQueryApiResults 结构体
type AlibabaWdkSkuQueryApiResults struct {
	// 结果集合
	Models []AlibabaWdkSkuQueryApiResult `json:"models,omitempty" xml:"models>alibaba_wdk_sku_query_api_result,omitempty"`
	// 错误编码
	ErrCode string `json:"err_code,omitempty" xml:"err_code,omitempty"`
	// 错误信息
	ErrMsg string `json:"err_msg,omitempty" xml:"err_msg,omitempty"`
	// 是否成功
	Success bool `json:"success,omitempty" xml:"success,omitempty"`
}

repository: bububa/opentaobao

repo_name: bububa/opentaobao

branch_name: refs/heads/main


text:
SUMMARY = "Minimal complete  Openwrt system requirements"
DESCRIPTION = "The set of packages required for core Openwrt system with network but no gui"
LICENSE = "MIT"

PACKAGE_ARCH = "${MACHINE_ARCH}"

inherit packagegroup openwrt openwrt-services

PACKAGES = "\
     	   packagegroup-openwrt-minimal \
	   packagegroup-openwrt-minimal-base \
	   packagegroup-openwrt-minimal-network \
	   "

RDEPENDS:${PN} = "\
	         packagegroup-openwrt-minimal-base \
	         packagegroup-openwrt-minimal-network \
	         "

RDEPENDS:${PN}-base = "\
                      packagegroup-core-boot \
                      rpcd \
                      ubox \
                      ubus \
                      uci \
                      "

RDEPENDS:${PN}-network = "\
                         dnsmasq \
                         \
                         firewall3 \
                         iptables \
                         ${VIRTUAL-RUNTIME_network_manager} \
                         uclient \
                         ustream-ssl \
                         ${@bb.utils.contains('COMBINED_FEATURES', 'wifi', 'iw', '',d)} \
                         ${@bb.utils.contains('COMBINED_FEATURES', 'wifi', 'hostapd', '',d)} \
                         ${@bb.utils.contains('DISTRO_FEATURES', 'ipv6', 'odhcp6c', '', d)} \
                         "

repository: kraj/meta-openwrt

repo_name: kraj/meta-openwrt

gha_language: BitBake


text:
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"math/rand"
	"os"
	"runtime"
	"time"

	"github.com/aerth/ndjinn/components/checkout"
	"github.com/aerth/ndjinn/components/database"
	"github.com/aerth/ndjinn/components/email"
	"github.com/aerth/ndjinn/components/jsonconfig"
	"github.com/aerth/ndjinn/components/recaptcha"
	"github.com/aerth/ndjinn/components/server"
	"github.com/aerth/ndjinn/components/session"
	"github.com/aerth/ndjinn/components/view"
	"github.com/aerth/ndjinn/components/view/plugin"
	"github.com/aerth/ndjinn/route"
	"github.com/inconshreveable/mousetrap"
)

var usage = `

									oh wow.
` //`

var t0 = time.Now()

// Globalmessage Channel
var Globalmessage = make(chan string, 3)

// Version is the running version number
func Version() string {
	return "ndjinn v0.2"
}

func init() {

	if runtime.GOOS == "windows" {
		if ok := mousetrap.StartedByExplorer(); ok {
			fmt.Println("Don't double-click. You need to open cmd.exe and run it from the command line!")
			time.Sleep(10 * time.Second)
			os.Exit(1)
		}

	}
	// Verbose logging with file name and line number
	// log.SetFlags(log.Lshortfile)

	// Normal logging
	log.SetFlags(log.LstdFlags)

	// Use all CPU cores
	runtime.GOMAXPROCS(runtime.NumCPU())
}

func main() {

	// Print Version Info
	fmt.Println(Version())

	// Help Mode and bunk options
	if len(os.Args) > 1 {
		switch os.Args[1] {
		case "-V", "--version":
			os.Exit(0)
		case "-h", "--help":
			fmt.Println(usage)
			os.Exit(0)
		case "-v", "--verbose":
			break
		default:
			fmt.Printf("\nNot a valid command. Try %s\n", os.Args[0])
			os.Exit(0)
		}
	}

	/* Boot sequence inspired by the movies */
	fmt.Printf("Boot: Started (%s)\n", time.Now().Format("2006-01-02 15:04:05"))

	// Load the configuration file (./config/config.json)
	fmt.Printf("Boot: Loading config.")
	fmt.Printf(".")
	fmt.Printf(".")
	fmt.Printf(".")
	jsonconfig.Load("config"+string(os.PathSeparator)+"config.json", config)
	fmt.Printf(" done.\n")

	// Configure the session cookie store
	fmt.Printf("Boot: Loading cookie store.")
	fmt.Printf(".")
	fmt.Printf(".")
	fmt.Printf(".")
	session.Configure(config.Session)
	fmt.Printf(" done.\n")

	fmt.Printf("Boot: Loading PayPal.")
	fmt.Printf(".")
	fmt.Printf(".")
	fmt.Printf(".")
	checkout.Configure(config.Checkout)
	fmt.Printf(" done.\n")

	// Connect to database (./database/database.db)

	fmt.Printf("Boot: Loading database.")
	fmt.Printf(".")
	_ = os.Mkdir("backups", 0700)
	fmt.Printf(".")
	fmt.Printf(".")
	database.Connect(config.Database)
	fmt.Printf(" done.\n")

	// Run Maint and Backup
	//_, err := maint.RunSchedule()

	// // // //
	//
	// database.Close()
	// if err != nil {
	// 	fmt.Println(err)
	// }
	// database.Connect(config.Database)
	// fmt.Println("Boot: Database Backup completed.")
	//
	// err = os.Mkdir("logs", 0700)
	// if err != nil && err.Error() != "mkdir logs: file exists" {
	// 	log.Fatal(err)
	// }
	//
	// fmt.Println("Boot: Logging requests to ./logs/access.log")
	// fmt.Println("Boot: Other logging at ./logs/debug.log")

	// // // //

	// Configure the Google reCAPTCHA prior to loading view plugins
	recaptcha.Configure(config.Recaptcha)

	// Setup the views (./template and ./static)
	fmt.Printf("Boot: Loading views.")
	fmt.Printf(".")
	fmt.Printf(".")
	fmt.Printf(".")
	view.Configure(config.View)
	fmt.Printf(" done.\n")

	fmt.Printf("Boot: Loading templates.")
	fmt.Printf(".")
	fmt.Printf(".")
	fmt.Printf(".")
	view.LoadTemplates(config.Template.Root, config.Template.Children)
	fmt.Printf(" done.\n")

	fmt.Printf("Boot: Loading view plugins.")
	fmt.Printf(".")
	fmt.Printf(".")
	fmt.Printf(".")
	view.LoadPlugins(
		plugin.TagHelper(config.View),
		plugin.NoEscape(),
		recaptcha.RecaptchaPlugin())

	fmt.Printf(" done.\n")

	// Monitor Uptime
	go func() {
		for {
			amt := time.Duration(rand.Intn(25) + 10000)
			time.Sleep(time.Second * amt)
			t1 := time.Now()
			log.Println("Info: Running for " + t1.Sub(t0).String())
		}
	}()

	// Test push notification (for site-wide announcements to all online users)
	go func() {
		for {
			time.Sleep(1 * time.Minute)
			fmt.Println("Gopher")

		}
	}()

	// This is our maintainance every hour. (internal cron)
	go func() {
		c := time.Tick(1 * time.Minute)
		go func() {
			for range c {

				// log.Printf("Maint: Starting Maintainance Routine")
				//
				// // Database Backup
				// //	_, err := maint.RunSchedule()
				//
				// //database.Close()
				// if err != nil {
				// 	fmt.Println(err)
				// }
				// database.Connect(config.Database)
				// log.Println("Maint: Database Backup completed.")
				//
				// _, err = maint.BankTransfer()
				// if err != nil {
				// 	fmt.Println(err)
				// }
				// // Bank Transfer
				// log.Println("Maint: Bank Transfer completed.")
				//
				// // Bitcoin Sync
				// _, err = maint.BitcoinSync()
				// if err != nil {
				// 	fmt.Println(err)
				// }
				// log.Println("Maint: Bitcoin Sync completed.")

			}
		}()

	}()
	fmt.Printf("Boot: Complete (%s)\n", time.Now().Format("2006-01-02 15:04:05"))

	if len(os.Args) == 1 {
		if !InitLog() {
			panic("error")
		}
	}
	// Start the listener
	server.Run(route.LoadHTTP(), route.LoadHTTPS(), config.Server)
	log.Println("Server ded.")
	os.Exit(1)
}

// *****************************************************************************
// Application Settings
// *****************************************************************************

// config the settings variable
var config = &configuration{}

// configuration contains the application settings
type configuration struct {
	Database  database.DatabaseInfo   `json:"Database"`
	Email     email.SMTPInfo          `json:"Email"`
	Recaptcha recaptcha.RecaptchaInfo `json:"Recaptcha"`
	Server    server.Server           `json:"Server"`
	Session   session.Session         `json:"Session"`
	Template  view.Template           `json:"Template"`
	View      view.View               `json:"View"`
	Checkout  checkout.CheckoutInfo   `json:"Checkout"`
}

// ParseJSON unmarshals bytes to structs
func (c *configuration) ParseJSON(b []byte) error {
	return json.Unmarshal(b, &c)
}

// InitLog switches the log engine to a file, rather than stdout
func InitLog() bool {
	f, err := os.OpenFile("logs/debug.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0600)
	if err != nil {
		log.Printf("error opening file: %v", err)
		log.Fatal("Hint: touch ./debug.log, or chown/chmod it so that the " + os.Args[0] + " process can access it.")
		return false
	}
	fmt.Println("Switched to log file. Nothing more to see here.")
	log.SetOutput(f)
	return true
}

repository: aerth/ndjinn

repo_name: aerth/ndjinn


text:
// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package personalize

import (
	"github.com/aws/aws-sdk-go/private/protocol"
)

const (

	// ErrCodeInvalidInputException for service response error code
	// "InvalidInputException".
	//
	// Provide a valid value for the field or parameter.
	ErrCodeInvalidInputException = "InvalidInputException"

	// ErrCodeInvalidNextTokenException for service response error code
	// "InvalidNextTokenException".
	//
	// The token is not valid.
	ErrCodeInvalidNextTokenException = "InvalidNextTokenException"

	// ErrCodeLimitExceededException for service response error code
	// "LimitExceededException".
	//
	// The limit on the number of requests per second has been exceeded.
	ErrCodeLimitExceededException = "LimitExceededException"

	// ErrCodeResourceAlreadyExistsException for service response error code
	// "ResourceAlreadyExistsException".
	//
	// The specified resource already exists.
	ErrCodeResourceAlreadyExistsException = "ResourceAlreadyExistsException"

	// ErrCodeResourceInUseException for service response error code
	// "ResourceInUseException".
	//
	// The specified resource is in use.
	ErrCodeResourceInUseException = "ResourceInUseException"

	// ErrCodeResourceNotFoundException for service response error code
	// "ResourceNotFoundException".
	//
	// Could not find the specified resource.
	ErrCodeResourceNotFoundException = "ResourceNotFoundException"

	// ErrCodeTooManyTagKeysException for service response error code
	// "TooManyTagKeysException".
	//
	// The request contains more tag keys than can be associated with a resource
	// (50 tag keys per resource).
	ErrCodeTooManyTagKeysException = "TooManyTagKeysException"

	// ErrCodeTooManyTagsException for service response error code
	// "TooManyTagsException".
	//
	// You have exceeded the maximum number of tags you can apply to this resource.
	ErrCodeTooManyTagsException = "TooManyTagsException"
)

var exceptionFromCode = map[string]func(protocol.ResponseMetadata) error{
	"InvalidInputException":          newErrorInvalidInputException,
	"InvalidNextTokenException":      newErrorInvalidNextTokenException,
	"LimitExceededException":         newErrorLimitExceededException,
	"ResourceAlreadyExistsException": newErrorResourceAlreadyExistsException,
	"ResourceInUseException":         newErrorResourceInUseException,
	"ResourceNotFoundException":      newErrorResourceNotFoundException,
	"TooManyTagKeysException":        newErrorTooManyTagKeysException,
	"TooManyTagsException":           newErrorTooManyTagsException,
}

repository: aws/aws-sdk-go

repo_name: aws/aws-sdk-go


text:
@article{ciotti2016homophily,
  title={Homophily and missing links in citation networks},
  author={Ciotti, Valerio and Bonaventura, Moreno and Nicosia, Vincenzo and Panzarasa, Pietro and Latora, Vito},
  journal={EPJ Data Science},
  volume={5},
  pages={1--14},
  year={2016},
  publisher={Springer}
}

repository: valkiii/blog

repo_name: valkiii/blog


text:
@proceedings{ws-2019-international-semantics-short,
    title = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    editor = "Dobnik, Simon  and
      Chatzikyriakidis, Stergios  and
      Demberg, Vera",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0500",
}
@inproceedings{mcgregor-jezek-2019-distributional,
    title = "A Distributional Model of Affordances in Semantic Type Coercion",
    author = "McGregor, Stephen  and
      Jezek, Elisabetta",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0501",
    doi = "10.18653/v1/W19-0501",
    pages = "1--7",
}
@inproceedings{hu-etal-2019-natural,
    title = "Natural Language Inference with Monotonicity",
    author = "Hu, Hai  and
      Chen, Qi  and
      Moss, Larry",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0502",
    doi = "10.18653/v1/W19-0502",
    pages = "8--15",
}
@inproceedings{kuzmenko-herbelot-2019-distributional,
    title = "Distributional Semantics in the Real World: Building Word Vector Representations from a Truth-Theoretic Model",
    author = "Kuzmenko, Elizaveta  and
      Herbelot, Aur{\'e}lie",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0503",
    doi = "10.18653/v1/W19-0503",
    pages = "16--23",
}
@inproceedings{van-noord-etal-2019-linguistic,
    title = "Linguistic Information in Neural Semantic Parsing with Multiple Encoders",
    author = "van Noord, Rik  and
      Toral, Antonio  and
      Bos, Johan",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0504",
    doi = "10.18653/v1/W19-0504",
    pages = "24--31",
}
@inproceedings{diller-etal-2019-making,
    title = "Making Sense of Conflicting (Defeasible) Rules in the Controlled Natural Language {ACE}: Design of a System with Support for Existential Quantification Using Skolemization",
    author = "Diller, Martin  and
      Wyner, Adam  and
      Strass, Hannes",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0505",
    doi = "10.18653/v1/W19-0505",
    pages = "32--37",
}
@inproceedings{frassinelli-schulte-im-walde-2019-distributional,
    title = "Distributional Interaction of Concreteness and Abstractness in Verb{--}Noun Subcategorisation",
    author = "Frassinelli, Diego  and
      Schulte im Walde, Sabine",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0506",
    doi = "10.18653/v1/W19-0506",
    pages = "38--43",
}
@inproceedings{krishnaswamy-pustejovsky-2019-generating,
    title = "Generating a Novel Dataset of Multimodal Referring Expressions",
    author = "Krishnaswamy, Nikhil  and
      Pustejovsky, James",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0507",
    doi = "10.18653/v1/W19-0507",
    pages = "44--51",
}
@inproceedings{silva-amarathunga-2019-learning,
    title = "On Learning Word Embeddings From Linguistically Augmented Text Corpora",
    author = "Silva, Amila  and
      Amarathunga, Chathurika",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0508",
    doi = "10.18653/v1/W19-0508",
    pages = "52--58",
}
@inproceedings{wartena-etal-2019-sentiment,
    title = "Sentiment Independent Topic Detection in Rated Hospital Reviews",
    author = "Wartena, Christian  and
      Sander, Uwe  and
      Patzelt, Christiane",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0509",
    doi = "10.18653/v1/W19-0509",
    pages = "59--64",
}
@inproceedings{pierrejean-tanguy-2019-investigating,
    title = "Investigating the Stability of Concrete Nouns in Word Embeddings",
    author = "Pierrejean, B{\'e}n{\'e}dicte  and
      Tanguy, Ludovic",
    booktitle = "Proceedings of the 13th International Conference on Computational Semantics - Short Papers",
    month = may,
    year = "2019",
    address = "Gothenburg, Sweden",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W19-0510",
    doi = "10.18653/v1/W19-0510",
    pages = "65--70",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings


text:
DESCRIPTION = "C++ bindings for ZeroMQ"
HOMEPAGE = "http://www.zeromq.org"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

DEPENDS = "zeromq boost"

SRC_URI = "git://github.com/zeromq/azmq;protocol=https"

SRCREV = "${AUTOREV}"

S = "${WORKDIR}/git"

inherit cmake

EXTRA_OECMAKE = ""

PACKAGES = "${PN}-dev"

RDEPENDS_${PN}-dev = "zeromq-dev"

repository: algebratech/meta-algebra

repo_name: algebratech/meta-algebra


text:
package main

func main() {

	var i int
	for i < 5 {
		println(i)
		i++
		if i == 3 {
			break
		}

		// for i := 0; 5 < i; i++ {

		// 	println(i)
		// }
	}

}


text:
@article{meng_self-learning_2019,
 abstract = {In current dynamic optical networks with cascaded filters and amplifiers, the optical signal-to-noise ratio (OSNR) can vary significantly from channel to channel. Under such uncertainty, OSNR prediction for unestab-lished channels becomes indispensable but remains a big challenge. For protective network planning purposes such as margin threshold setting or wavelength assignment, it is desirable to evaluate the worst OSNR performance of each network link. Such exploration will unavoidably employ active monitoring probes, which may cause interruptions to the network. An efficient active monitoring strategy that optimizes the choice of probes or monitoring trials is needed. We propose a "self-learning" monitoring strategy integrated at intermediate nodes. Our method can intelligently select the channel to be monitored in order to search for the target global maxima of OSNR degradation for a specific link. Our monitoring scheme detects intermediate node OSNR in the linear regime. It is shown that our method can predict the target OSNR value with only 0.5 dB error while reducing the required monitoring data by up to 91% compared to conventional methods.},
 author = {Meng, F. and Mavromatis, A. and Bi, Y. and Wang, R. and Yan, S. and Nejabati, R. and Simeonidou, D.},
 date = {2019-02},
 doi = {10.1364/JOCN.11.00A144},
 file = {/Users/sy13201/Zotero/storage/JRT9T9H5/Meng et al_2019_Self-learning monitoring on-demand strategy for optical networks.pdf;/Users/sy13201/Zotero/storage/7NSPLMUS/8657333.html;/Users/sy13201/Zotero/storage/ZW5EWR5J/abstract.html},
 ids = {meng_self-learning_2019-1},
 issn = {1943-0620},
 journaltitle = {IEEE/OSA Journal of Optical Communications and Networking},
 number = {2},
 pages = {A144-A154},
 title = {Self-Learning Monitoring on-Demand Strategy for Optical Networks},
 volume = {11}
}


text:
@InProceedings{chenane:biorob:2016,
  author    = {Chenane, Kathia and Touati, Youcef, Younes and Boubchir, Larbi and Daachi, Boubaker and Ali-Cherif, Arab},
  title     = {Algorithms of control by thought in robotics: active and passive BMIs based on prior knowledge},
  booktitle = {International Conference on Biomedical Robotics and Biomechatronics},
  year      = {2016},
  address   = {Singapore},
  month     = {June 26-June 29},
  url       = {https://www.researchgate.net/profile/Younes-Youcef-Touati/publication/305908314\_Algorithms\_of\_control\_by\_thought\_in\_robotics\_Active\_and\_passive\_BMIs\_based\_on\_prior\_knowledge/links/5e8f5628299bf130798d82c9/Algorithms-of-control-by-thought-in-robotics-Active-and-passive-BMIs-based-on-prior-knowledge.pdf},
  keywords  = {BCI, BMI, SSVEP technique, EEG, Control by thought.},
  doi       = {10.1109/BIOROB.2016.7523627},
  abstract  = {One of the objectives of the control using the human thought is to make useful robotic systems for persons with high dependency (quadriplegics, paraplegics, etc.). When the human subject is not able to move his limbs, upper or lower, he is no longer able to perform basic and necessary tasks in his daily life. Recently, robotic systems have reached a very advanced level. For example, humanoid robots have become able to walk, recognize and carry objects simultaneously. On the other hand, wearable robots or exoskeletons can help dependent human subject to move and perform tasks previously difficult to imagine. Of course, all these robotic systems cannot perform these tasks except if they are fitted with advanced control schemes. To make these robotic systems, having already some intelligence, more useful, many researchers have studied the problem of controllers based on the user thought. The real challenge is to translate/classify correctly the thought of the user into robotic actions. When the brain activities are not correctly classified or the action thought by the user is not quite performed, it is important to discover it at time. This allows us to update the classifier/controller parameters in order to interpret more precisely the brain activities concerning the following action. This paper deals with looking for relevant prior knowledge that can anticipate any classification error. Thereafter, we propose some reflections regarding the control of robots by passive thought. Our analysis and results are based on the brain machine interface (BMI) using the Steady State Visual Evoked Potentials technique (SSVEP).}
}


text:
SUMMARY = "Firmware for si2168"
LICENSE = "CLOSED"

PACKAGE_ARCH = "all"

PR = "r0"

SRC_URI = "file://firmware-si2168.zip"

S = "${WORKDIR}"

PACKAGES = "${PN}"

FILES_${PN} += "${base_libdir}/firmware"

do_install() {
	install -d ${D}${base_libdir}/firmware
	install -m 0644 dvb-demod-si2168-a20-01.fw ${D}${base_libdir}/firmware
	install -m 0644 dvb-demod-si2168-a30-01.fw ${D}${base_libdir}/firmware
	install -m 0644 dvb-demod-si2168-b40-01.fw ${D}${base_libdir}/firmware
	install -m 0644 dvb-tuner-si2158-a20-01.fw ${D}${base_libdir}/firmware
}

repository: avlogic/meta-edision

repo_name: avlogic/meta-edision


text:
@article{RN595,
 author = {Engelke Infante, N. and Murphy, K. and Glenn, C. and Sealey, V. L.},
 doi = {10.1080/0020739X.2017.1410737},
 journal = {International Journal of Mathematical Education in Science and Technology},
 number = {5},
 pages = {643-659},
 title = {How concept images affect students’ interpretations of Newton’smethod},
 type = {Journal Article},
 url = {https://doi.org/10.1080/0020739X.2017.1410737},
 volume = {49},
 year = {2018}
}


text:
require linux.inc
require linux-openmoko.inc

KERNEL_RELEASE="2.6.34"

SRCREV = "f37686260161644129601ba19880abe48c56cc8d"
OEV = "oe4"
PV = "${KERNEL_RELEASE}-${OEV}+gitr${SRCPV}"

SRC_URI = "\
  git://git.openmoko.org/git/kernel.git;protocol=git;branch=om-gta02-2.6.34 \
# build fix
  file://wm8753-fix-build-with-gcc-4.4.2-which-works-ok-with-.patch \
# fix for lost touchscreen https://docs.openmoko.org/trac/ticket/2328
  file://touchscreen_ignoreunexpectedintr34.patch \
# fix runtime issue when built with gcc-4.5
  file://use-noclone-attribute-for-naked.patch \
# patches from Thomas White's gdrm-for-merging branch
  file://0001-DRM-for-platform-devices.patch \
  file://0002-Glamo-DRM-and-KMS-driver.patch \
  file://0003-Work-on-Glamo-core-for-DRM.patch \
  file://0004-JBT6k74-work-for-KMS.patch \
  file://0005-Fix-crash-when-reading-Glamo-registers-via-sysfs.patch \
  file://0006-Fix-dynamic-command-queue-allocation.patch \
  file://0007-Debug-statements-for-testing.patch \
  file://0008-Fix-claim-of-2D-register-resource.patch \
  file://0009-Use-unlocked_ioctl-rather-than-ioctl.patch \
# patches from Radek Polak used in qtmoko
  file://0001-accels.patch.patch \
  file://0002-usbhost.patch.patch \
  file://0003-ar6000_delay.patch.patch \
  file://0004-save_regs.patch.patch \
"

S = "${WORKDIR}/git"

CONFIG_NAME_om-gta02 = "gta02_drm_defconfig"

do_configure_prepend() {
        install -m 644 ./arch/arm/configs/${CONFIG_NAME} ${WORKDIR}/defconfig-oe
}


text:
package main

import (
  "fmt"
  "strings"
  )

func Index(vs *[]string, t string) int {
    for i, v := range *vs {
      if v == t {
        return i
      }
    }
    return -1
}

func Include(vs *[]string, t string) bool {
  return Index(vs, t) >= 0
}

func Any(vs *[]string, f func(string) bool) bool {
  for _, v := range *vs {
    if f(v) {
      return true
    }
  }
  return false
}

func Filter(vs *[]string, f func(string) bool) []string {
  temp := make([]string, 0)
  for _, v := range *vs {
    if f(v) {
      temp = append(temp, v)
    }
  }
  return temp
}

func Map(vs *[]string, f func(string) string) []string {
    temp := make([]string , len(*vs))
    for i, v := range *vs {
      temp[i] = f(v)
    }

    return temp
}

func main() {
  var strs = []string{"peach", "apple", "pear", "plum"}

  fmt.Println("Index of peach is ", Index(&strs, "peach"))
  fmt.Println("Index of apple is ", Index(&strs, "apple"))
  fmt.Println("Index of pear is ", Index(&strs, "pear"))
  fmt.Println("Index of plum is ", Index(&strs, "plum"))

  fmt.Println("Does slice include plum", Include(&strs, "plum"))
  fmt.Println("Does slice include peach", Include(&strs, "peach"))
  fmt.Println("Does slice include apple", Include(&strs, "apple"))
  fmt.Println("Does slice include peac", Include(&strs, "peac"))

  fmt.Println("Does any entry in slice has prefix pe: ", Any(&strs, func(v string) bool {
    return strings.HasPrefix(v, "pe")
    }))

  fmt.Println("Does any entry in slice has prefix re: ", Any(&strs, func(v string) bool {
    return strings.HasPrefix(v, "re")
    }))

  fmt.Println("Does any string in slice contain e: ", Filter(&strs, func(v string) bool {
    return strings.Contains(v, "e")
    }))

  fmt.Println("Does any string in slice contain v: ", Filter(&strs, func(v string) bool {
    return strings.Contains(v, "v")
    }))

  fmt.Println(Map(&strs, strings.ToUpper))
}

license: ISC

repository: chaitanyav/go

repo_name: chaitanyav/go


text:
package operator

import (
	"bytes"
	"fmt"
	"io"

	"github.com/pingcap-incubator/tiops/pkg/meta"
	"github.com/pingcap-incubator/tiops/pkg/module"
	"github.com/pingcap/errors"
)

// Destroy the cluster.
func Destroy(
	getter ExecutorGetter,
	w io.Writer,
	spec *meta.Specification,
) error {
	coms := spec.ComponentsByStopOrder()

	for _, com := range coms {
		err := DestroyComponent(getter, w, com.Instances())
		if err != nil {
			return errors.Annotatef(err, "failed to stop %s", com.Name())
		}
	}
	return nil
}

// StopComponent stop the instances.
func DestroyComponent(getter ExecutorGetter, w io.Writer, instances []meta.Instance) error {
	if len(instances) <= 0 {
		return nil
	}

	name := instances[0].ComponentName()
	fmt.Fprintf(w, "Destroying component %s\n", name)

	for _, ins := range instances {
		e := getter.Get(ins.GetHost())
		fmt.Fprintf(w, "Destroying instance %s\n", ins.GetHost())

		// Stop by systemd.
		var command string
		switch name {
		case meta.ComponentTiKV, meta.ComponentPD, meta.ComponentPump, meta.ComponentDrainer, meta.ComponentPrometheus, meta.ComponentAlertManager:
			command = command + fmt.Sprintf("rm -rf %s;", ins.DataDir())
		default:
			command = ""
		}
		command = command + fmt.Sprintf("rm -rf %s;", ins.DeployDir()) + fmt.Sprintf("rm -rf /etc/systemd/system/%s;", ins.ServiceName())
		c := module.ShellModuleConfig{
			Command:  command,
			Sudo:     true, // the .service files are in a directory owned by root
			Chdir:    "",
			UseShell: false,
		}
		shell := module.NewShellModule(c)
		stdout, stderr, err := shell.Execute(e)

		io.Copy(w, bytes.NewReader(stdout))
		io.Copy(w, bytes.NewReader(stderr))

		if err != nil {
			return errors.Annotatef(err, "failed to destroy: %s", ins.GetHost())
		}

		err = ins.WaitForDown(e)
		if err != nil {
			str := fmt.Sprintf("%s failed to destroy: %s", ins.GetHost(), err)
			fmt.Fprintln(w, str)
			return errors.Annotatef(err, str)
		}

		fmt.Fprintf(w, "Destroy %s success\n", ins.GetHost())
	}

	return nil
}

repository: YangKeao/tiops

repo_name: YangKeao/tiops


text:
package cmd

import (
	"fmt"

	"github.com/spf13/cobra"
)

// metricCmd represents the metric command
var metricCmd = &cobra.Command{
	Use:   "metric",
	Short: "List, get, and put metrics",
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println(cmd.UsageString())
	},
}

func init() {
	rootCmd.AddCommand(metricCmd)
}

repository: Polarishq/nova-cli

repo_name: Polarishq/nova-cli


text:
@incollection{Ninness&Hjalmarsson:04a,
 address = {Berlin},
 author = {B. Ninness and H. Hjalmarsson},
 booktitle = {Modelling and Identification with Rational Orthogonal Functions},
 editor = {P.M.J. Van den Hof, P. Heuberger and B. Wahlberg},
 pages = {},
 publisher = {Springer Verlag},
 title = {Variance Error, Reproducing Kernels and Orhonormal Bases},
 year = {2005}
}

repository: hhjalmars/academic-kickstart

repo_name: hhjalmars/academic-kickstart


text:
SUMMARY = "A generic AST to represent Python2 and Python3's Abstract Syntax Tree(AST)."
HOMEPAGE = "https://github.com/serge-sans-paille/gast"
SECTION = "devel/python"
LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://LICENSE;md5=a3ad9b6802e713fc5e307e1230f1ea90"

SRC_URI = "git://github.com/serge-sans-paille/gast.git"
SRCREV ?= "ed82e2a507505c6b18eb665d3738b6c0602da5e7"

inherit setuptools3

S = "${WORKDIR}/git"

BBCLASSEXTEND = "native"


text:
SUMMARY = "AWS IoT Greengrass Core Recipe"
DESCRIPTION = "Recipe created by bitbake-layers"
LICENSE = "MIT"

SRC_URI_arm = " \
    https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/${PV}/greengrass-linux-armv7l-${PV}.tar.gz;name=arm \
    file://greengrass.service \
    file://greengrass-init \
"

SRC_URI_aarch64 = " \
    https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/${PV}/greengrass-linux-aarch64-${PV}.tar.gz;name=aarch64 \
    file://greengrass.service \
    file://greengrass-init \
"

SRC_URI_x86-64 = " \
    https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/${PV}/greengrass-linux-x86-64-${PV}.tar.gz;name=x86-64 \
    file://greengrass.service \
    file://greengrass-init \
"

LIC_FILES_CHKSUM = " \
    file://ggc/core/THIRD-PARTY-LICENSES;md5=53b6a4caa097863bc3971d5e0ac6d1db \
"

SRC_URI[arm.md5sum]        = "63a1f6aae22260be19f34f278f7e7833"
SRC_URI[arm.sha256sum]     = "4bc0bc8a938cdb3d846df92e502155c6ec8cbaf1b63dfa9f3cc3a51372d95af5"

SRC_URI[aarch64.md5sum]    = "967cd25ac77e733b0a1b42d83dc96ed1"
SRC_URI[aarch64.sha256sum] = "4cbaf91e5354fe49ded160415394413f068426c2bba13089e6b8a28775990a9c"

SRC_URI[x86-64.md5sum]     = "a1f90898cc324b3c2a6a7cf50038d70a"
SRC_URI[x86-64.sha256sum]  = "ee55e370491905415cfab962f5429228c58aec4c7f481e66a14e952e1b62fe36"

S = "${WORKDIR}/${BPN}"

inherit update-rc.d useradd systemd

GG_USESYSTEMD = "${@bb.utils.contains('DISTRO_FEATURES', 'systemd', 'yes', 'no', d)}"

# Check if we have all the env variables set
python __anonymous () {
	pkgname = d.getVar("PN")
#	if d.getVar("GREENGRASS_CERTS_DIR", False) == None:
#		bb.error("%s: GREENGRASS_CERTS_DIR is not set" % pkgname)

#	if d.getVar("GREENGRASS_CONFIG_DIR", False) == None:
#		bb.error("%s: GREENGRASS_CONFIG_DIR is not set" % pkgname)
}

# Disable tasks not needed for the binary package
do_configure[noexec] = "1"
do_compile[noexec]   = "1"

do_install() {
    install -d ${D}/${BPN}
    tar --no-same-owner --exclude='./patches' --exclude='./.pc' -cpf - -C ${S} . \
        | tar --no-same-owner -xpf - -C ${D}/${BPN}

    # Install wrapper bootscript to launch Greengrass core on boot
    install -d ${D}${sysconfdir}/init.d
    install -m 0755 ${WORKDIR}/greengrass-init ${D}${sysconfdir}/greengrass
    sed -i -e "s,##GG_INSTALL_DIR##,/${BPN},g" ${D}${sysconfdir}/greengrass
    ln -sf ${sysconfdir}/greengrass ${D}${sysconfdir}/init.d/greengrass

    # Install systemd service
    install -d ${D}${systemd_unitdir}/system/
    install -m 0644 ${WORKDIR}/greengrass.service ${D}${systemd_unitdir}/system/greengrass.service

    # Install the greengrass core specific certificates and config.json
#    install -m 0644 ${GREENGRASS_CERTS_DIR}/* ${D}/${BPN}/certs/
#    install -m 0644 ${GREENGRASS_CONFIG_DIR}/* ${D}/${BPN}/config/

    # Configure whether to use systemd or not
    sed -i -e "/useSystemd/{s,\[yes|no],${GG_USESYSTEMD},g}" ${D}/${BPN}/config/config.json
}

pkg_postinst_ontarget_${PN}() {
    # Enable protection for hardlinks and symlinks
    if ! grep -qs 'protected_.*links' $D${sysconfdir}/sysctl.conf; then
    cat >> $D${sysconfdir}/sysctl.conf <<-_EOF_
# Greengrass: protect hardlinks/symlinks
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
_EOF_
    fi

    # Customize '/etc/fstab'
    if [ -f "$D${sysconfdir}/fstab" ]; then
        # Disable TMPFS /var/volatile
        sed -i -e '\#^tmpfs[[:blank:]]\+/var/volatile#s,^,#,g' $D${sysconfdir}/fstab

		# Mount a cgroup hierarchy with all available subsystems
		if ! grep -qs '^cgroup' $D${sysconfdir}/fstab; then
			cat >> $D${sysconfdir}/fstab <<-_EOF_
				# Greengrass: mount cgroups
				cgroup    /sys/fs/cgroup    cgroup    defaults    0  0
			_EOF_
		fi
	fi

	# Disable '/etc/resolv.conf' symlink
	if [ -f "$D${sysconfdir}/default/volatiles/00_core" ]; then
		sed -i -e '/resolv.conf/d' $D${sysconfdir}/default/volatiles/00_core
		cat >> $D${sysconfdir}/default/volatiles/00_core <<-_EOF_
			# Greengrass: create a real (no symlink) resolv.conf
			f root root 0644 /etc/resolv.conf none
		_EOF_
	fi
}

FILES_${PN} = "/${BPN} ${sysconfdir} ${systemd_unitdir}"

CONFFILES_${PN} += "/${BPN}/config/config.json"

INITSCRIPT_NAME = "greengrass"
INITSCRIPT_PARAMS = "defaults 80 20"

SYSTEMD_SERVICE_${PN} = "greengrass.service"

USERADD_PACKAGES = "${PN}"
GROUPADD_PARAM_${PN} = "-r ggc_group"
USERADD_PARAM_${PN} = "-r -M -N -g ggc_group -s /bin/false ggc_user"

#
# Disable failing QA checks:
#
#   Binary was already stripped
#   No GNU_HASH in the elf binary
#
INSANE_SKIP_${PN} += "already-stripped ldflags file-rdeps"

RDEPENDS_${PN} += "ca-certificates python-argparse python-json python-numbers sqlite3"

repository: jianzhong-xu/meta-aws

repo_name: jianzhong-xu/meta-aws


text:
// Copyright 2019 Yunion
//
// 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 secrules

import (
	"testing"
)

func TestPorts(t *testing.T) {
	t.Run("basic", func(t *testing.T) {
		ps := newPortsFromInts(1, 3)
		if !ps.contains(1) {
			t.Fatalf("contains")
		}
	})
	t.Run("dedup", func(t *testing.T) {
		ps := newPortsFromInts(1, 3, 3, 4, 1, 3, 5)
		ps1 := ps.dedup()
		if len(ps1) != 4 || !ps.containsPorts(newPortsFromInts(1, 3, 4, 5)) {
			t.Fatalf("dedup")
		}
	})
	t.Run("subs ports", func(t *testing.T) {
		ps0 := newPortsFromInts(1, 3, 4)
		ps1 := newPortsFromInts(1, 4, 9)
		left, sub := ps0.substractPorts(ps1)
		if len(left) != 1 || !left.contains(3) {
			t.Fatalf("bad `left`")
		}
		if len(sub) != 2 || !sub.contains(1) || !sub.contains(4) {
			t.Fatalf("bad `sub`")
		}
	})
	t.Run("subs range", func(t *testing.T) {
		ps := newPortsFromInts(4, 7, 8)
		t.Run("disjoint (left)", func(t *testing.T) {
			pr := newPortRange(9, 10)
			left, sub := ps.substractPortRange(pr)
			if len(left) != 3 || !left.sameAs(ps) {
				t.Fatalf("bad `left`")
			}
			if len(sub) != 0 {
				t.Fatalf("bad `sub`")
			}
		})
		t.Run("overlap (left)", func(t *testing.T) {
			pr := newPortRange(1, 4)
			left, sub := ps.substractPortRange(pr)
			if len(left) != 2 || !left.sameAs(newPortsFromInts(7, 8)) {
				t.Fatalf("bad `left`")
			}
			if len(sub) != 1 || !sub.contains(4) {
				t.Fatalf("bad `sub`")
			}
		})
		t.Run("contained by", func(t *testing.T) {
			pr := newPortRange(1, 10)
			left, sub := ps.substractPortRange(pr)
			if len(left) != 0 {
				t.Fatalf("bad `left`")
			}
			if len(sub) != len(ps) || !sub.sameAs(ps) {
				t.Fatalf("bad `sub`")
			}
		})
	})
}

func TestPortRange(t *testing.T) {
	t.Run("basic", func(t *testing.T) {
		pr := newPortRange(5, 7)
		if !pr.contains(5) {
			t.Fatalf("contains")
		}
		if pr.count() != 3 {
			t.Fatalf("count")
		}
		if !pr.containsRange(newPortRange(5, 6)) {
			t.Fatalf("containsRange")
		}
		if pr.containsRange(newPortRange(4, 6)) {
			t.Fatalf("!containsRange")
		}
	})
	t.Run("subs ports", func(t *testing.T) {
		pr := newPortRange(5, 7)
		ps := newPortsFromInts(1, 6)
		lefts, sub := pr.substractPorts(ps)
		if len(lefts) != 2 || !lefts[0].equals(newPortRange(5, 5)) || !lefts[1].equals(newPortRange(7, 7)) {
			t.Fatalf("bad `lefts`")
		}
		if len(sub) != 1 || !sub.contains(6) {
			t.Fatalf("bad `sub`")
		}
	})
	t.Run("subs range", func(t *testing.T) {
		pr := newPortRange(5, 7)
		t.Run("disjoint (left)", func(t *testing.T) {
			pr1 := newPortRange(2, 4)
			lefts, sub := pr.substractPortRange(pr1)
			if len(lefts) != 1 || !lefts[0].equals(pr) {
				t.Fatalf("bad `lefts`")
			}
			if sub != nil && sub.count() != 0 {
				t.Fatalf("bad `sub`")
			}
		})
		t.Run("overlap (cut right)", func(t *testing.T) {
			pr1 := newPortRange(2, 5)
			lefts, sub := pr.substractPortRange(pr1)
			if len(lefts) != 1 || !lefts[0].equals(newPortRange(6, 7)) {
				t.Fatalf("bad `lefts`")
			}
			if sub == nil || !sub.equals(newPortRange(5, 5)) {
				t.Fatalf("bad `sub`")
			}
		})
		t.Run("contains (true subset)", func(t *testing.T) {
			pr1 := newPortRange(6, 6)
			lefts, sub := pr.substractPortRange(pr1)
			if len(lefts) != 2 || !lefts[0].equals(newPortRange(5, 5)) || !lefts[1].equals(newPortRange(7, 7)) {
				t.Fatalf("bad `lefts`")
			}
			if sub == nil || !sub.equals(newPortRange(6, 6)) {
				t.Fatalf("bad `sub`")
			}
		})
		t.Run("contains (align left)", func(t *testing.T) {
			pr1 := newPortRange(5, 6)
			lefts, sub := pr.substractPortRange(pr1)
			if len(lefts) != 1 || !lefts[0].equals(newPortRange(7, 7)) {
				t.Fatalf("bad `lefts`")
			}
			if sub == nil || !sub.equals(newPortRange(5, 6)) {
				t.Fatalf("bad `sub`")
			}
		})
		t.Run("contains (align right)", func(t *testing.T) {
			pr1 := newPortRange(6, 7)
			lefts, sub := pr.substractPortRange(pr1)
			if len(lefts) != 1 || !lefts[0].equals(newPortRange(5, 5)) {
				t.Fatalf("bad `lefts`")
			}
			if sub == nil || !sub.equals(newPortRange(6, 7)) {
				t.Fatalf("bad `sub`")
			}
		})
		t.Run("contained by", func(t *testing.T) {
			pr1 := newPortRange(2, 9)
			lefts, sub := pr.substractPortRange(pr1)
			if len(lefts) != 0 {
				t.Fatalf("bad `lefts`")
			}
			if sub == nil || !sub.equals(pr) {
				t.Fatalf("bad `sub`")
			}
		})
	})
}

repository: yunionio/pkg

repo_name: yunionio/pkg


text:
@article{bangsund_isolating_2018,
 abstract = {Degradation in organic light-emitting devices (OLEDs) is generally driven by reactions involving excitons and polarons. Accordingly, a common design strategy to improve OLED lifetime is to reduce the density of these species by engineering an emissive layer architecture to achieve a broad exciton recombination zone. Here, the effect of exciton density on device degradation is analyzed in a mixed host emissive layer (M-EML) architecture which exhibits a broad recombination zone. To gain further insight into the dominant degradation mechanism, losses in the exciton formation efficiency and photoluminescence (PL) efficiency are decoupled by tracking the emissive layer PL during device degradation. By varying the starting luminance and M-EML thickness, the rate of PL degradation is found to depend strongly on recombination zone width and hence exciton density. In contrast, losses in the exciton formation depend only weakly on the recombination zone, and thus may originate outside of the emissive layer. These results suggest that the lifetime enhancement observed in the M-EML architectures reflects a reduction in the rate of PL degradation. Moreover, the varying roles of excitons and polarons in degrading the PL and exciton formation efficiencies suggest that kinetically distinct pathways drive OLED degradation and that a single degradation mechanism cannot be assumed when attempting to model the device lifetime. This work highlights the potential to extract fundamental insight into OLED degradation by tracking the emissive layer PL during lifetime testing, while also enabling diagnostic tests on the root causes of device instability.},
 author = {Bangsund, John S. and Hershey, Kyle W. and Holmes, Russell J.},
 doi = {10.1021/acsami.7b16643},
 file = {ACS Full Text Snapshot:/Users/jsb/Zotero/storage/H35QCA33/acsami.html:text/html;Bangsund et al_2018_ACS Appl. Mater. Interfaces_Isolating Degradation Mechanisms in Mixed Emissive Layer Organic Light-Emitting.pdf:C\:\\Users\\JSB\\Google Drive\\Papers-Zotfile\\CV\\Bangsund et al_2018_ACS Appl. Mater. Interfaces_Isolating Degradation Mechanisms in Mixed Emissive Layer Organic Light-Emitting.pdf:application/pdf;SI_Bangsund et al_2018_ACS Appl. Mater. Interfaces_Isolating Degradation Mechanisms in Mixed Emissive Layer Organic Light-Emitting3.pdf:C\:\\Users\\JSB\\Google Drive\\Papers-Zotfile\\CV\\SI_Bangsund et al_2018_ACS Appl. Mater. Interfaces_Isolating Degradation Mechanisms in Mixed Emissive Layer Organic Light-Emitting3.pdf:application/pdf},
 issn = {1944-8244},
 journal = {ACS Applied Materials & Interfaces},
 month = {feb},
 number = {6},
 pages = {5693--5699},
 title = {Isolating Degradation Mechanisms in Mixed Emissive Layer Organic Light-Emitting Devices},
 url = {https://doi.org/10.1021/acsami.7b16643},
 urldate = {2018-02-14},
 volume = {10},
 year = {2018}
}

repository: jsbangsund/academic-kickstart

repo_name: jsbangsund/academic-kickstart


text:
SUMMARY = "Armbian Linux firmware"
LICENSE = "Proprietary"
LIC_FILES_CHKSUM = "file://xr819/device-xradio.mk;md5=01a5e63ddf60e2a4af5b073cec783bb7"

SRC_URI = "git://github.com/armbian/firmware;branch=master"
SRCREV = "d48638ae83026979d617f80c054f8f239d8945dd"

S = "${WORKDIR}/git"

inherit allarch

# workaround for PACKAGE_CLASSES="package_rpm":
# do not 'own' directories to avoid conflicts with other packages
DIRFILES = "1"

do_compile() {
        :
}

do_install () {
	install -d  ${D}${nonarch_base_libdir}/firmware/
	install -d  ${D}${nonarch_base_libdir}/firmware/xr819/
	install -d  ${D}${nonarch_base_libdir}/firmware/brcm/
	install -m 644 ${S}/xr819/*.bin ${D}${nonarch_base_libdir}/firmware/xr819/
	install -m 644 ${S}/brcm/*.bin ${D}${nonarch_base_libdir}/firmware/brcm/
	install -m 644 ${S}/brcm/*.txt ${D}${nonarch_base_libdir}/firmware/brcm/
}

FILES_${PN}-xr819 = " \
	${nonarch_base_libdir}/firmware/xr819/boot_xr819.bin \
	${nonarch_base_libdir}/firmware/xr819/fw_xr819.bin \
	${nonarch_base_libdir}/firmware/xr819/sdd_xr819.bin \
"

PACKAGES =+ "${PN}-xr819"
RPROVIDES_${PN}-xr819 = "armbian-firmware-xr819"

FILES_${PN}-brcm = " \
	${nonarch_base_libdir}/firmware/brcm/*bin \
	${nonarch_base_libdir}/firmware/brcm/*txt \
"

PACKAGES =+ "${PN}-brcm"
RPROVIDES_${PN}-brcm = "armbian-firmware-brcm"

# Firmware files are generally not ran on the CPU, so they can be
# allarch despite being architecture specific
INSANE_SKIP = "arch"

repository: geomatsi/meta-sunxi-contrib

repo_name: geomatsi/meta-sunxi-contrib