text:
if(BDE_UOR_INCLUDED)
    return()
endif()
set(BDE_UOR_INCLUDED true)

include(bde_interface_target)
include(bde_log)
include(bde_struct)
include(bde_utils)

bde_register_struct_type(
    BDE_UOR_TYPE
        SOURCES
        HEADERS
        DEPENDS
        TARGET
        INTERFACE_TARGETS
        TEST_TARGETS
)

function(internal_target_objlib_sources target)
    bde_utils_list_template_substitute(
        objSources "%" "$<TARGET_OBJECTS:%>" ${ARGN}
    )
    target_sources(${target} PRIVATE ${objSources})
endfunction()

function(bde_project_add_uor uor packages)
    bde_assert_no_extra_args()

    bde_struct_get_field(uorName ${uor} NAME)
    bde_struct_get_field(uorTarget ${uor} TARGET)
    bde_struct_get_field(uorDeps ${uor} DEPENDS)

    # uorInterfaceTarget contains _only_ the build requirements
    # specified for the UOR itself. It does NOT contain the requirements
    # transitively included from the member packages. This interface
    # target is only used directly by the test targets.
    set(uorInterfaceTarget ${uorName}-uor)
    bde_add_interface_target(${uorInterfaceTarget})
    bde_interface_target_link_libraries(${uorInterfaceTarget} PUBLIC ${uorDeps})

    # uorFullInterfaceTarget contains both the requirements of
    # the UOR itself and all the requirements of all the member packages.
    # This interface target is used for the building the final UOR
    # as well as for the external users.
    set(uorFullInterfaceTarget ${uorInterfaceTarget}-full)
    bde_add_interface_target(${uorFullInterfaceTarget})
    bde_interface_target_assimilate(${uorFullInterfaceTarget} ${uorInterfaceTarget})
    bde_target_link_interface_target(${uorTarget} ${uorFullInterfaceTarget})

    set(uorTestTarget ${uorName}.t)
    add_custom_target(${uorTestTarget})
    bde_struct_set_field(${uor} TEST_TARGETS ${uorTestTarget})

    # Process packages
    bde_struct_set_field(
        ${uor}
        INTERFACE_TARGETS
            ${uorInterfaceTarget}
            ${uorFullInterfaceTarget}
    )

    set(allInterpackageDeps)
    set(allPackageTargets)
    foreach(package IN LISTS packages)
        bde_struct_get_field(packageName ${package} NAME)
        bde_struct_get_field(packageInterfaceTarget ${package} INTERFACE_TARGET)

        # Add package usage requirements to the UOR target
        # Do not add private requirements as they should only affect the
        # package itself
        bde_interface_target_assimilate(
            ${uorFullInterfaceTarget}
            ${packageInterfaceTarget}
            INTERFACE_ONLY
        )
        bde_struct_append_field(
            ${uor}
            INTERFACE_TARGETS
                ${packageInterfaceTarget}
        )

        bde_struct_get_field(packageSrcs ${package} SOURCES)
        bde_struct_get_field(packageHdrs ${package} HEADERS)
        bde_struct_get_field(packageDeps ${package} DEPENDS)
        list(APPEND allInterpackageDeps ${packageDeps})

        bde_log(
            VERBOSE
            "[${uorName}]: Adding package [${packageName}] (${packageDeps})"
        )

        bde_interface_target_names(uorInterfaceTargets ${uorInterfaceTarget})
        bde_interface_target_names(packageInterfaceTargets ${packageInterfaceTarget})

        set(
            allPackageDepends
            # Requirements specific to this particular package
            ${packageInterfaceTargets}
            # Inter-package dependencies
            ${packageDeps}
            # 'Pure' requirements of the package
            ${uorInterfaceTargets}
        )

        # The package name may clash with uor name for standalone packages
        set(packageLibrary ${packageName})
        if (${uorName} STREQUAL ${packageName})
            set(packageLibrary ${packageName}-pkg)
        endif()
        list(APPEND allPackageTargets ${packageLibrary})

        if(packageSrcs)
            set(packageObjLibrary ${packageLibrary}-obj)

            # object library
            add_library(
                ${packageObjLibrary}
                OBJECT EXCLUDE_FROM_ALL
                ${packageSrcs} ${packageHdrs}
            )

            # CMake as of 3.10 does not allow calling target_link_libraries
            # on OBJECT libraries. This command, however successfully imports
            # the build requirements, such as compiler options and include
            # directories
            set_target_properties(
                ${packageObjLibrary}
                PROPERTIES
                    LINK_LIBRARIES "${allPackageDepends}"
            )

            # target for tests
            add_library(${packageLibrary} EXCLUDE_FROM_ALL "")
            set_target_properties(${packageLibrary} PROPERTIES LINKER_LANGUAGE CXX)
            internal_target_objlib_sources(${packageLibrary} ${packageObjLibrary})

            # Add object files as sources to the package froup target
            internal_target_objlib_sources(${uorTarget} ${packageObjLibrary})
        else()
            # Add IDE target (https://gitlab.kitware.com/cmake/cmake/issues/15234)
            add_custom_target(${packageLibrary}-headers SOURCES ${packageHdrs})

            # target for tests
            add_library(${packageLibrary} INTERFACE)
        endif()

        # Add usage requirements to the package target for tests
        target_link_libraries(${packageLibrary} INTERFACE ${packageDeps} ${uorInterfaceTargets})
        bde_target_link_interface_target(${packageLibrary} ${packageInterfaceTarget} INTERFACE_ONLY)

        # Process package tests
        bde_struct_get_field(tests ${package} TEST_TARGETS)
        if (tests)
            foreach(test IN LISTS tests)
                target_link_libraries(${test} PRIVATE ${packageLibrary})
                bde_target_link_interface_target(${test} ${packageInterfaceTarget})
                bde_append_test_labels(${test} ${uorName})
            endforeach()

            set(packageTestName ${packageLibrary}.t)
            add_custom_target(${packageTestName})
            add_dependencies(${uorTestTarget} ${packageTestName})
            add_dependencies(${packageTestName} ${tests})
        endif()
    endforeach()

    if(allInterpackageDeps)
        list(REMOVE_ITEM allInterpackageDeps ${allPackageTargets})
        if(allInterpackageDeps)
            message(
                FATAL_ERROR
                "Found unresolved inter-package dependencies: \
                ${allInterpackageDeps}"
            )
        endif()
    endif()

endfunction()

function(bde_install_uor uor)
    bde_assert_no_extra_args()

    bde_struct_get_field(uorName ${uor} TARGET)
    bde_struct_get_field(depends ${uor} DEPENDS)
    bde_struct_get_field(interfaceTargets ${uor} INTERFACE_TARGETS)

    set(ufidInstallDir ${bde_install_lib_suffix}/${bde_install_ufid})

    # Install main target
    install(
        TARGETS ${uorName}
        EXPORT ${uorName}Targets
        COMPONENT "${uorName}"
        ARCHIVE DESTINATION ${ufidInstallDir}
        LIBRARY DESTINATION ${ufidInstallDir}
        RUNTIME DESTINATION ${ufidInstallDir}
    )

    if(CMAKE_HOST_UNIX)
        # This code will create a symlink to a corresponding "ufid" build.
        # Use with care.
        set(libName "${CMAKE_STATIC_LIBRARY_PREFIX}${uorName}${CMAKE_STATIC_LIBRARY_SUFFIX}")
        set(symlinkVal "${bde_install_ufid}/${libName}")
        set(symlinkFile "\$ENV{DESTDIR}/\${CMAKE_INSTALL_PREFIX}/${bde_install_lib_suffix}/${libName}")

        install(
            CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${symlinkVal} ${symlinkFile})"
            COMPONENT "${uorName}-symlinks"
            EXCLUDE_FROM_ALL
        )
    endif()

    install(
        EXPORT ${uorName}Targets
        DESTINATION "ufidInstallDir/cmake"
        COMPONENT "${uorName}"
    )

    # Install interface targets
    foreach(interfaceTarget IN LISTS interfaceTargets)
        bde_install_interface_target(
            ${interfaceTarget}
            EXPORT ${uorName}InterfaceTargets
        )
    endforeach()

    # Namespace is needed for disambuguation of
    # common interface target if multiple UORs built by this
    # project are used by an external project
    install(
        EXPORT ${uorName}InterfaceTargets
        DESTINATION "ufidInstallDir/cmake"
        NAMESPACE "${uorName}::"
        COMPONENT "${uorName}"
    )

    # Create the groupConfig.cmake for the build tree
    find_file(configFile "groupConfig.cmake.in" PATHS ${CMAKE_MODULE_PATH})
    set(group ${uorName})
    configure_file(
        ${configFile}
        "${PROJECT_BINARY_DIR}/${uorName}Config.cmake"
        @ONLY
    )
    unset(configFile)

    install(
        FILES "${PROJECT_BINARY_DIR}/${uorName}Config.cmake"
        DESTINATION "ufidInstallDir/cmake"
        COMPONENT "${uorName}"
    )

    # Create the group.pc for the build tree
    # In CMake a list is a string with ';' as an item separator.
    find_file(configFile "group.pc.in" PATHS ${CMAKE_MODULE_PATH})
    set(pc_depends ${depends})
    string(REPLACE ";" " " pc_depends "${pc_depends}")
    configure_file(
        ${configFile}
        "${PROJECT_BINARY_DIR}/${uorName}.pc"
        @ONLY
    )
    unset(configFile)

    install(
        FILES "${PROJECT_BINARY_DIR}/${uorName}.pc"
        DESTINATION "ufidInstallDir/pkgconfig"
        COMPONENT "${uorName}"
    )

    set(extraInstallArg)
    if(MSVC)
        set(extraInstallArg "-DBUILD_TYPE=${CMAKE_CFG_INTDIR}")
    endif()

    add_custom_target(
        "install.${uorName}"
        COMMAND ${CMAKE_COMMAND}
            -DCOMPONENT="${uorName}"
            ${extraInstallArg}
            -P ${CMAKE_BINARY_DIR}/cmake_install.cmake
        COMMAND ${CMAKE_COMMAND}
            -DCOMPONENT="${uorName}-headers"
            ${extraInstallArg}
            -P ${CMAKE_BINARY_DIR}/cmake_install.cmake
        DEPENDS ${uorName}
    )
endfunction()

repository: EricHripko/bde-tools

repo_name: EricHripko/bde-tools

extension: cmake


text:
# Recipe created by recipetool
# This is the basis of a recipe and may need further editing in order to be fully functional.
# (Feel free to remove these comments when editing.)

# WARNING: the following LICENSE and LIC_FILES_CHKSUM values are best guesses - it is
# your responsibility to verify that the values are complete and correct.
#
# The following license files were not able to be identified and are
# represented as "Unknown" below, you will need to check them yourself:
#   usr/share/doc/cockpit-bridge/copyright
#
# LICENSE = "LGPLv2.1"
# LIC_FILES_CHKSUM = "file://tools/debian/copyright.template;md5=62230c0032c15b542b5682f99168b2a0"

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

# No information for SRC_URI yet (only an external source tree was specified)
SRC_URI = "file://data.tar.xz.yo"

inherit useradd

USERADD_PACKAGES = "${PN}"
USERADD_PARAM_${PN} = "--system -M --user-group -s /bin/false cockpit-ws"

# inherit bin_package

INSANE_SKIP_${PN} += "already-stripped arch"

DEPENDS = "glib-2.0 json-glib glib-networking krb5 libpam systemd"

do_install() {

    bbplain running the crazy bit
    [ -d "${S}" ] || exit 1
    cd ${S} || exit 1

    tar xvf ${WORKDIR}/data.tar.xz.yo --directory .

    tar --no-same-owner --exclude='./patches' --exclude='./.pc' -cpf - . \
        | tar --no-same-owner -xpf - -C ${D}

}

FILES_${PN} = "/"

license: MIT

repository: FEEprojects/meta-remote-management

license_type: permissive

repo_name: FEEprojects/meta-remote-management

branch_name: refs/heads/master

extension: bb


text:
/** @jsx React.DOM */

var React = require('react'),
    Router = require('react-router'),
    Home = require('./Home'),
    Batman = require('./Batman'),
    CoBrowseButton = require('./CoBrowseButton'),
    HelloMessage = require('./HelloMessage');

var Route = Router.Route,
    RouteHandler = Router.RouteHandler,
    DefaultRoute = Router.DefaultRoute;

var routes = (
  <Route name="app" path="/"handler={App}>
    <DefaultRoute handler={Home} />
    <Route name="home" path="/home" handler={Home} />
    <Route name="batman" path="/batman" handler={Batman} />
    <Route name="hello" path="/hello" handler={HelloMessage} />
  </Route>
);

//var TogetherJSConfig_toolName = 'Co-Browse';

var App = React.createClass({
  render: function() {
    return (
      <RouteHandler/>
    );
  }
});

Router.run(routes, function (Handler) {
  React.render(<Handler/>, document.body);
});

// Or, if you'd like to use the HTML5 history API for cleaner URLs:
// Router.run(routes, Router.HistoryLocation, function (Handler) {
//   React.render(<Handler/>, document.body);
// });

React.render(<App/>, document.getElementById('app'));

extension: js


text:
SUMMARY = "Transmission is a cross-platform BitTorrent client"
HOMEPAGE = "http://www.transmissionbt.com/"
LICENSE = "GPL-2.0"

LIC_FILES_CHKSUM = "file://COPYING;md5=a1923fe8f8ff37c33665716af0ec84f1"
SRC_URI = "https://transmission.cachefly.net/transmission-${PV}.tar.xz \
    file://0001-replace-libsystemd-daemon-dependency.patch"

SRC_URI[md5sum] = "3fce404a436e3cd7fde80fb6ed61c264"
SRC_URI[sha256sum] = "3a8d045c306ad9acb7bf81126939b9594553a388482efa0ec1bfb67b22acd35f"

inherit autotools systemd useradd
DEPENDS = "zlib openssl curl libevent"
PACKAGECONFIG = "utp daemon ${@bb.utils.contains('DISTRO_FEATURES','systemd','systemd','',d)}"
PACKAGECONFIG[utp] = "--enable-utp,--disable-utp"
PACKAGECONFIG[daemon] = "--enable-daemon,--disable-daemon"
PACKAGECONFIG[systemd] = "--with-systemd-daemon,--without-systemd-daemon,systemd"
EXTRA_OECONF = " \
    HAVE_CXX=yes \
    --enable-lightweight \
    --without-gtk \
    --disable-nls \
    --disable-cli \
    "

SYSTEMD_SERVICE_${PN} = "transmission.service"
SYSTEMD_AUTO_ENABLE = "disable"

USERADD_PACKAGES = "${PN}"
USERADD_PARAM_${PN} = "-c 'Transmission BitTorrent Client' -u 169 -g transmission -b '/var/lib' -m -s /bin/false transmission"
GROUPADD_PARAM_${PN} = "-g 169 transmission"
do_install_append () {
    install -D -m644 "${S}/daemon/transmission-daemon.service" "${D}${systemd_unitdir}/system/transmission.service"
}

repository: ivovka/meta-htpc

repo_name: ivovka/meta-htpc


text:
DESCRIPTION = "Task to install wireless headers and libraries into the SDK"
LICENSE = "MIT"
PR = "r7"

inherit packagegroup

PACKAGE_ARCH = "${MACHINE_ARCH}"

BLUETOOTH_STACK = "\
    bluez4-dev \
"

CONNECTIVITY_RDEPENDS = ""

CONNECTIVITY_RDEPENDS_ti33x  = "\
    wpa-supplicant-wl18xx-dev \
    ${BLUETOOTH_STACK} \
"

CONNECTIVITY_RDEPENDS_ti43x  = "\
    wpa-supplicant-wl18xx-dev \
    ${BLUETOOTH_STACK} \
"

RDEPENDS_${PN} = "\
    ${CONNECTIVITY_RDEPENDS} \
"

repository: varigit/meta-arago-var

repo_name: varigit/meta-arago-var


text:
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
  "C"
  )
# The set of files for implicit dependencies of each language:
set(CMAKE_DEPENDS_CHECK_C
  "/home/romerion/Git/ml-ethereum-client/libs/secp256k1/src/secp256k1.c" "/home/romerion/Git/ml-ethereum-client/libs/secp256k1/src/CMakeFiles/secp256k1.dir/secp256k1.o"
  )
set(CMAKE_C_COMPILER_ID "GNU")

# The include file search paths:
set(CMAKE_C_TARGET_INCLUDE_PATH
  )

# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
  )

# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

repository: rimrakhimov/ml-ethereum-cllient

repo_name: rimrakhimov/ml-ethereum-cllient


text:
package main

import (
	"gopkg.in/jeevatkm/go-model.v1"
	"github.com/it-chain/it-chain-Engine/legacy/domain"
	pb "github.com/it-chain/it-chain-Engine/legacy/network/protos"
	"fmt"
)

func main(){

	peer1 := &domain.Peer{}
	peer1.PeerID ="1"
	peer1.IpAddress = "127.0.0.1"
	peer1.PubKey = []byte("hello world!")

	peerTable := &domain.PeerTable{}
	peerTable.MyID = "123"
	peerTable.PeerMap = make(map[string]*domain.Peer)
	peerTable.AddPeer(peer1)

	pbPeerTable := &pb.PeerTable{}

	//srchResMap, err := model.Map(peerTable)

	err := model.Copy(pbPeerTable, peerTable)

	if err != nil{
		fmt.Println(err)
	}

	fmt.Println(pbPeerTable)
}

extension: go


text:
package config

import (
	"encoding/json"
	"os"
)

var GlobalConfig *Config

type Config struct {
	TransientPath   string
	TransientPeriod int64
	StandingPath    string
	AdminUser       string
	AdminPassword   string
	DbPath          string
}

func FromFile(path string) (*Config, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	decoder := json.NewDecoder(file)
	config := new(Config)

	err = decoder.Decode(config)
	if err != nil {
		return nil, err
	}

	return config, nil
}


text:
package river

import (
	"bytes"
	"encoding/json"
	"fmt"
	"github.com/juju/errors"
	"github.com/siddontang/go-mysql-elasticsearch/elastic"
	"github.com/siddontang/go-mysql/canal"
	"github.com/siddontang/go-mysql/client"
	"github.com/siddontang/go-mysql/mysql"
	"github.com/siddontang/go-mysql/replication"
	"github.com/siddontang/go-mysql/schema"
	log "github.com/sirupsen/logrus"
	"reflect"
	"strconv"
	"strings"
	"time"
)

const (
	syncInsertDoc = iota
	syncDeleteDoc
	syncUpdateDoc
)

const (
	fieldTypeList = "list"
	// for the mysql int type to es date type
	// set the [rule.field] created_time = ",date"
	fieldTypeDate = "date"
)

type posSaver struct {
	pos   mysql.Position
	force bool
}

type eventHandler struct {
	r *River
}

func (h *eventHandler) OnRotate(e *replication.RotateEvent) error {
	pos := mysql.Position{
		string(e.NextLogName),
		uint32(e.Position),
	}

	h.r.syncCh <- posSaver{pos, true}

	return h.r.ctx.Err()
}

func (h *eventHandler) OnTableChanged(schema, table string) error {
	err := h.r.updateRule(schema, table)
	if err != nil && err != ErrRuleNotExist {
		return errors.Trace(err)
	}
	return nil
}

func (h *eventHandler) OnDDL(nextPos mysql.Position, _ *replication.QueryEvent) error {
	h.r.syncCh <- posSaver{nextPos, true}
	return h.r.ctx.Err()
}

func (h *eventHandler) OnXID(nextPos mysql.Position) error {
	h.r.syncCh <- posSaver{nextPos, false}
	return h.r.ctx.Err()
}

func (h *eventHandler) OnRow(e *canal.RowsEvent) error {
	rule, ok := h.r.rules[ruleKey(e.Table.Schema, e.Table.Name)]
	if !ok {
		return nil
	}
	var reqs []*elastic.BulkRequest
	var err error
	switch e.Action {
	case canal.InsertAction:
		reqs, err = h.r.makeInsertRequest(rule, e.Rows)
	case canal.DeleteAction:
		reqs, err = h.r.makeDeleteRequest(rule, e.Rows)
	case canal.UpdateAction:
		reqs, err = h.r.makeUpdateRequest(rule, e.Rows)
	default:
		err = errors.Errorf("invalid rows action %s", e.Action)
	}

	if err != nil {
		h.r.cancel()
		return errors.Errorf("make %s ES request err %v, close sync", e.Action, err)
	}

	h.r.syncCh <- reqs

	return h.r.ctx.Err()
}

func (h *eventHandler) OnGTID(gtid mysql.GTIDSet) error {
	return nil
}

func (h *eventHandler) OnPosSynced(pos mysql.Position, force bool) error {
	return nil
}

func (h *eventHandler) String() string {
	return "ESRiverEventHandler"
}

func (r *River) syncLoop() {
	bulkSize := r.c.BulkSize
	if bulkSize == 0 {
		bulkSize = 128
	}

	interval := r.c.FlushBulkTime.Duration
	if interval == 0 {
		interval = 200 * time.Millisecond
	}

	ticker := time.NewTicker(interval)
	defer ticker.Stop()
	defer r.wg.Done()

	lastSavedTime := time.Now()
	reqs := make([]*elastic.BulkRequest, 0, 1024)

	var pos mysql.Position

	for {
		needFlush := false
		needSavePos := false

		select {
		case v := <-r.syncCh:
			switch v := v.(type) {
			case posSaver:
				now := time.Now()
				if v.force || now.Sub(lastSavedTime) > 3*time.Second {
					lastSavedTime = now
					needFlush = true
					needSavePos = true
					pos = v.pos
				}
			case []*elastic.BulkRequest:
				reqs = append(reqs, v...)
				needFlush = len(reqs) >= bulkSize
			}
		case <-ticker.C:
			needFlush = true
		case <-r.ctx.Done():
			return
		}

		if needFlush {
			// TODO: retry some times?
			if err := r.doBulk(reqs); err != nil {
				log.Errorf("do ES bulk err %v, close sync", err)
				r.cancel()
				return
			}
			reqs = reqs[0:0]
		}

		if needSavePos {
			if err := r.master.Save(pos); err != nil {
				log.Errorf("save sync position %s err %v, close sync", pos, err)
				r.cancel()
				return
			}
		}
	}
}

// for insert and delete
func (r *River) makeRequest(rule *Rule, action string, rows [][]interface{}) ([]*elastic.BulkRequest, error) {
	reqs := make([]*elastic.BulkRequest, 0, len(rows))

	for _, values := range rows {
		id, err := r.getDocID(rule, values)
		if err != nil {
			return nil, errors.Trace(err)
		}

		parentID := ""
		if len(rule.Parent) > 0 {
			if parentID, err = r.getParentID(rule, values, rule.Parent); err != nil {
				return nil, errors.Trace(err)
			}
		}

		req := &elastic.BulkRequest{Index: rule.Index, Type: rule.Type, ID: id, Parent: parentID, Pipeline: rule.Pipeline}

		if action == canal.DeleteAction {
			req.Action = elastic.ActionDelete
			r.st.DeleteNum.Add(1)
		} else {
			r.makeInsertReqData(req, rule, values)
			r.st.InsertNum.Add(1)
		}

		reqs = append(reqs, req)
	}

	return reqs, nil
}

func (r *River) makeInsertRequest(rule *Rule, rows [][]interface{}) ([]*elastic.BulkRequest, error) {
	return r.makeRequest(rule, canal.InsertAction, rows)
}

func (r *River) makeDeleteRequest(rule *Rule, rows [][]interface{}) ([]*elastic.BulkRequest, error) {
	return r.makeRequest(rule, canal.DeleteAction, rows)
}

func (r *River) makeUpdateRequest(rule *Rule, rows [][]interface{}) ([]*elastic.BulkRequest, error) {
	if len(rows)%2 != 0 {
		return nil, errors.Errorf("invalid update rows event, must have 2x rows, but %d", len(rows))
	}

	reqs := make([]*elastic.BulkRequest, 0, len(rows))

	for i := 0; i < len(rows); i += 2 {
		beforeID, err := r.getDocID(rule, rows[i])
		if err != nil {
			return nil, errors.Trace(err)
		}

		afterID, err := r.getDocID(rule, rows[i+1])

		if err != nil {
			return nil, errors.Trace(err)
		}

		beforeParentID, afterParentID := "", ""
		if len(rule.Parent) > 0 {
			if beforeParentID, err = r.getParentID(rule, rows[i], rule.Parent); err != nil {
				return nil, errors.Trace(err)
			}
			if afterParentID, err = r.getParentID(rule, rows[i+1], rule.Parent); err != nil {
				return nil, errors.Trace(err)
			}
		}

		req := &elastic.BulkRequest{Index: rule.Index, Type: rule.Type, ID: beforeID, Parent: beforeParentID}

		if beforeID != afterID || beforeParentID != afterParentID {
			req.Action = elastic.ActionDelete
			reqs = append(reqs, req)

			req = &elastic.BulkRequest{Index: rule.Index, Type: rule.Type, ID: afterID, Parent: afterParentID, Pipeline: rule.Pipeline}
			r.makeInsertReqData(req, rule, rows[i+1])

			r.st.DeleteNum.Add(1)
			r.st.InsertNum.Add(1)
		} else {
			if len(rule.Pipeline) > 0 {
				// Pipelines can only be specified on index action
				r.makeInsertReqData(req, rule, rows[i+1])
				// Make sure action is index, not create
				req.Action = elastic.ActionIndex
				req.Pipeline = rule.Pipeline
			} else {
				r.makeUpdateReqData(req, rule, rows[i], rows[i+1])
			}
			r.st.UpdateNum.Add(1)
		}

		reqs = append(reqs, req)
	}

	return reqs, nil
}

func (r *River) makeReqColumnData(col *schema.TableColumn, value interface{}) interface{} {
	switch col.Type {
	case schema.TYPE_ENUM:
		switch value := value.(type) {
		case int64:
			// for binlog, ENUM may be int64, but for dump, enum is string
			eNum := value - 1
			if eNum < 0 || eNum >= int64(len(col.EnumValues)) {
				// we insert invalid enum value before, so return empty
				log.Warnf("invalid binlog enum index %d, for enum %v", eNum, col.EnumValues)
				return ""
			}

			return col.EnumValues[eNum]
		}
	case schema.TYPE_SET:
		switch value := value.(type) {
		case int64:
			// for binlog, SET may be int64, but for dump, SET is string
			bitmask := value
			sets := make([]string, 0, len(col.SetValues))
			for i, s := range col.SetValues {
				if bitmask&int64(1<<uint(i)) > 0 {
					sets = append(sets, s)
				}
			}
			return strings.Join(sets, ",")
		}
	case schema.TYPE_BIT:
		switch value := value.(type) {
		case string:
			// for binlog, BIT is int64, but for dump, BIT is string
			// for dump 0x01 is for 1, \0 is for 0
			if value == "\x01" {
				return int64(1)
			}

			return int64(0)
		}
	case schema.TYPE_STRING:
		switch value := value.(type) {
		case []byte:
			return string(value[:])
		}
	case schema.TYPE_JSON:
		var f interface{}
		var err error
		switch v := value.(type) {
		case string:
			err = json.Unmarshal([]byte(v), &f)
		case []byte:
			err = json.Unmarshal(v, &f)
		}
		if err == nil && f != nil {
			return f
		}
	case schema.TYPE_DATETIME, schema.TYPE_TIMESTAMP:
		switch v := value.(type) {
		case string:
			vt, _ := time.ParseInLocation(mysql.TimeFormat, string(v), time.Local)
			return vt.Format(time.RFC3339)
		}
	}

	return value
}

func (r *River) getFieldParts(k string, v string) (string, string, string) {
	composedField := strings.Split(v, ",")

	mysql := k
	elastic := composedField[0]
	fieldType := ""

	if 0 == len(elastic) {
		elastic = mysql
	}
	if 2 == len(composedField) {
		fieldType = composedField[1]
	}

	return mysql, elastic, fieldType
}

func (r *River) makeInsertReqData(req *elastic.BulkRequest, rule *Rule, values []interface{}) {
	req.Data = make(map[string]interface{}, len(values))
	//fmt.Printf("%#v\n", rule.TableInfo)
	//定义全局字符串存储
	var spercontact string
	var si_zwnk string
	var si_id string
	var percontact_r schema.TableColumn
	var si_zwnk_r schema.TableColumn
	var si_id_r schema.TableColumn
	var i_partprice schema.TableColumn
	var i_price schema.TableColumn
	var i_boxprice schema.TableColumn
	var v_discount_acmount schema.TableColumn
	var v_platform_rate schema.TableColumn
	var v_shop_rate schema.TableColumn
	var v_fee schema.TableColumn
	var v_shopfee schema.TableColumn
	var v_atotalprice schema.TableColumn
	var v_asid schema.TableColumn
	var v_aorderstatus schema.TableColumn
	var v_aend_deliverytime schema.TableColumn
	var sdatabase string

	req.Action = elastic.ActionIndex
	for i, c := range rule.TableInfo.Columns {
		if !rule.CheckFilter(c.Name) {
			continue
		}
		mapped := false
		for k, v := range rule.FieldMapping {
			mysql, elastic, fieldType := r.getFieldParts(k, v)
			if mysql == c.Name {
				mapped = true
				req.Data[elastic] = r.getFieldValue(&c, fieldType, values[i])
			}
		}

		if rule.TableInfo.Name == "alp_merchant_order" {
			if c.Name == "totalprice" {
				i_partprice = c
				i_price = c
				i_boxprice = c
				v_discount_acmount = c
				v_platform_rate = c
				v_shop_rate = c
				v_fee = c
			}
			//添加拼接字符串处理
			switch c.Name {
			case "contact":
				si_zwnk = fmt.Sprintf("%s%s-", si_zwnk, values[i])
			case "mobile":
				si_zwnk = fmt.Sprintf("%s%s-", si_zwnk, values[i])
			case "address":
				si_zwnk = fmt.Sprintf("%s%s", si_zwnk, values[i])
				si_zwnk_r = c
			}
		}

		if rule.TableInfo.Name == "alp_dish_sales" {
			//添加拼接字符串处理
			switch c.Name {
			case "category_name":
				spercontact = fmt.Sprintf("%s%s_", spercontact, values[i])
			case "dish_name":
				spercontact = fmt.Sprintf("%s%s_", spercontact, values[i])
				percontact_r = c
			case "sku_name":
				spercontact = fmt.Sprintf("%s%s_", spercontact, values[i])
			case "dishsno":
				spercontact = fmt.Sprintf("%s%s", spercontact, values[i])
			}
		}

		if rule.TableInfo.Name == "alp_merchant_order_activity" {
			//添加拼接字符串处理
			switch c.Name {
			case "activity_type":
				si_id = fmt.Sprintf("%s%s_", si_id, values[i])
			case "discount_acmount":
				si_id = fmt.Sprintf("%s%s_", si_id, values[i])
			case "shop_rate":
				si_id = fmt.Sprintf("%s%s_", si_id, values[i])
				v_shopfee = c
				v_atotalprice = c
			case "source":
				si_id = fmt.Sprintf("%s%s", si_id, values[i])
			}
			if c.Name == "activity_name" {
				si_id_r = c
			}
			if c.Name == "amwaid" {
				v_asid = c
				v_aorderstatus = c
			}
			if c.Name == "utime" {
				v_aend_deliverytime = c
			}
		}
		if mapped == false {
			req.Data[c.Name] = r.makeReqColumnData(&c, values[i])
		}
	}

	//定制化需求
	if rule.TableInfo.Name == "alp_merchant_order" {
		for _, s := range r.c.Sources {
			sdatabase = s.Schema
		}
		time.Sleep(1000 * time.Millisecond)
		conn, _ := client.Connect(r.c.MyAddr, r.c.MyUser, r.c.MyPassword, sdatabase)
		conn.Ping()
		// ress, err := conn.Execute("select amoid from alp_merchant_order order by amoid desc limit 0,1")
		// amoid, _ := ress.GetIntByName(0, "amoid")
		s_amoid := "select sum(if(partstatus=2,partprice,0)) partprice,sum(price) price ,sum(if(itemname='餐盒费',price,0)) boxprice from alp_merchant_order_item where amoid=" + req.ID
		//fmt.Printf("%s", s_amoid)
		res, err := conn.Execute(s_amoid)
		if err != nil {
			log.Errorf("err %v ", err)
		}
		partprice, _ := res.GetFloatByName(0, "partprice")
		price, _ := res.GetFloatByName(0, "price")
		boxprice, _ := res.GetFloatByName(0, "boxprice")
		f_partprice := fmt.Sprintf("%0.2f", partprice)
		f_price := fmt.Sprintf("%0.2f", price)
		f_boxprice := fmt.Sprintf("%0.2f", boxprice)
		i_partprice.Name = "i_partprice"
		i_price.Name = "price"
		i_boxprice.Name = "i_boxprice"
		a_amoid := "select sum(discount_acmount) discount_acmount,sum(platform_rate) platform_rate,sum(shop_rate) shop_rate from alp_merchant_order_activity  where amoid=" + req.ID
		rss, err := conn.Execute(a_amoid)
		discount_acmount, _ := rss.GetFloatByName(0, "discount_acmount")
		platform_rate, _ := rss.GetFloatByName(0, "platform_rate")
		shop_rate, _ := rss.GetFloatByName(0, "shop_rate")
		f_discount_acmount := fmt.Sprintf("%0.2f", discount_acmount)
		f_platform_rate := fmt.Sprintf("%0.2f", platform_rate)
		f_shop_rate := fmt.Sprintf("%0.2f", shop_rate)
		v_discount_acmount.Name = "v_discount_acmount"
		v_platform_rate.Name = "v_platform_rate"
		v_shop_rate.Name = "v_shop_rate"
		//e_amoid := "select sum(fee) fee from alp_merchant_order_extras where amoid=" + strconv.FormatInt(amoid, 10)
		e_amoid := "select sum(fee) fee from alp_merchant_order_extras where amoid=" + req.ID
		rse, err := conn.Execute(e_amoid)
		fee, _ := rse.GetFloatByName(0, "fee")
		f_fee := fmt.Sprintf("%0.2f", fee)
		v_fee.Name = "v_fee"
		req.Data["i_partprice"] = r.makeReqColumnData(&i_partprice, f_partprice)
		req.Data["price"] = r.makeReqColumnData(&i_price, f_price)
		req.Data["i_boxprice"] = r.makeReqColumnData(&i_boxprice, f_boxprice)
		req.Data["v_discount_acmount"] = r.makeReqColumnData(&v_discount_acmount, f_discount_acmount)
		req.Data["v_platform_rate"] = r.makeReqColumnData(&v_platform_rate, f_platform_rate)
		req.Data["v_shop_rate"] = r.makeReqColumnData(&v_shop_rate, f_shop_rate)
		req.Data["v_fee"] = r.makeReqColumnData(&v_fee, f_fee)
		conn.Close()
	}

	//定制化需求
	if rule.TableInfo.Name == "alp_merchant_order_activity" {
		for _, s := range r.c.Sources {
			sdatabase = s.Schema
		}
		time.Sleep(1000 * time.Millisecond)
		aconn, _ := client.Connect(r.c.MyAddr, r.c.MyUser, r.c.MyPassword, sdatabase)
		aconn.Ping()
		aress, err := aconn.Execute("select amoid from alp_merchant_order_activity where amoaid =" + req.ID)
		aamoid, _ := aress.GetIntByName(0, "amoid")
		as_amoid := "select ifnull(shopfee,0) as shopfee,totalprice+ifnull(order_delivery_pay,0)-ifnull(delivery_pay,0) as totalprice,sid,orderstatus,end_deliverytime from alp_merchant_order where amoid=" + strconv.FormatInt(aamoid, 10)
		//fmt.Printf("%s", s_amoid)
		ares, err := aconn.Execute(as_amoid)
		if err != nil {
			log.Errorf("err %v ", err)
		}
		shopfee, _ := ares.GetFloatByName(0, "shopfee")
		atotalprice, _ := ares.GetFloatByName(0, "totalprice")
		asid, _ := ares.GetIntByName(0, "sid")
		aorderstatus, _ := ares.GetIntByName(0, "orderstatus")
		aend_deliverytime, _ := ares.GetStringByName(0, "end_deliverytime")
		f_shopfee := fmt.Sprintf("%0.2f", shopfee)
		f_atotalprice := fmt.Sprintf("%0.2f", atotalprice)
		t, _ := time.Parse("2006-01-02 15:04:05", aend_deliverytime)
		t_aend_deliverytime := t.Unix()
		v_shopfee.Name = "shopfee"
		v_atotalprice.Name = "totalprice"
		v_asid.Name = "sid"
		v_aorderstatus.Name = "orderstatus"
		v_aend_deliverytime.Name = "end_deliverytime"
		req.Data["shopfee"] = r.makeReqColumnData(&v_shopfee, f_shopfee)
		req.Data["totalprice"] = r.makeReqColumnData(&v_atotalprice, f_atotalprice)
		req.Data["sid"] = r.makeReqColumnData(&v_asid, asid)
		req.Data["orderstatus"] = r.makeReqColumnData(&v_aorderstatus, aorderstatus)
		req.Data["end_deliverytime"] = r.makeReqColumnData(&v_aend_deliverytime, t_aend_deliverytime)
		//添加插入处理
		si_id_r.Name = "id"
		req.Data["id"] = r.makeReqColumnData(&si_id_r, si_id)
		aconn.Close()
	}

	if rule.TableInfo.Name == "alp_dish_sales" {
		//添加插入处理
		percontact_r.Name = "percontact"
		req.Data["percontact"] = r.makeReqColumnData(&percontact_r, spercontact)
	}
	if rule.TableInfo.Name == "alp_merchant_order" {
		//添加插入处理
		si_zwnk_r.Name = "i_zwnk"
		req.Data["i_zwnk"] = r.makeReqColumnData(&si_zwnk_r, si_zwnk)
	}
}

func (r *River) makeUpdateReqData(req *elastic.BulkRequest, rule *Rule,
	beforeValues []interface{}, afterValues []interface{}) {
	req.Data = make(map[string]interface{}, len(beforeValues))

	// maybe dangerous if something wrong delete before?
	req.Action = elastic.ActionUpdate

	for i, c := range rule.TableInfo.Columns {
		mapped := false
		if !rule.CheckFilter(c.Name) {
			continue
		}
		if reflect.DeepEqual(beforeValues[i], afterValues[i]) {
			//nothing changed
			continue
		}
		for k, v := range rule.FieldMapping {

			mysql, elastic, fieldType := r.getFieldParts(k, v)
			if mysql == c.Name {
				mapped = true
				req.Data[elastic] = r.getFieldValue(&c, fieldType, afterValues[i])

			}
		}
		if mapped == false {
			req.Data[c.Name] = r.makeReqColumnData(&c, afterValues[i])
		}

	}
}

// If id in toml file is none, get primary keys in one row and format them into a string, and PK must not be nil
// Else get the ID's column in one row and format them into a string
func (r *River) getDocID(rule *Rule, row []interface{}) (string, error) {
	var (
		ids []interface{}
		err error
	)
	if rule.ID == nil {
		ids, err = canal.GetPKValues(rule.TableInfo, row)
		if err != nil {
			return "", err
		}
	} else {
		ids = make([]interface{}, 0, len(rule.ID))
		for _, column := range rule.ID {
			value, err := canal.GetColumnValue(rule.TableInfo, column, row)
			if err != nil {
				return "", err
			}
			ids = append(ids, value)
		}
	}

	var buf bytes.Buffer

	sep := ""
	for i, value := range ids {
		if value == nil {
			return "", errors.Errorf("The %ds id or PK value is nil", i)
		}

		buf.WriteString(fmt.Sprintf("%s%v", sep, value))
		sep = ":"
	}

	return buf.String(), nil
}

func (r *River) getParentID(rule *Rule, row []interface{}, columnName string) (string, error) {
	index := rule.TableInfo.FindColumn(columnName)
	if index < 0 {
		return "", errors.Errorf("parent id not found %s(%s)", rule.TableInfo.Name, columnName)
	}

	return fmt.Sprint(row[index]), nil
}

func (r *River) doBulk(reqs []*elastic.BulkRequest) error {
	if len(reqs) == 0 {
		return nil
	}

	if resp, err := r.es.Bulk(reqs); err != nil {
		log.Errorf("sync docs err %v after binlog %s", err, r.canal.SyncedPosition())
		return errors.Trace(err)
	} else if resp.Code/100 == 2 || resp.Errors {
		for i := 0; i < len(resp.Items); i++ {
			for action, item := range resp.Items[i] {
				if len(item.Error) > 0 {
					log.Errorf("%s index: %s, type: %s, id: %s, status: %d, error: %s",
						action, item.Index, item.Type, item.ID, item.Status, item.Error)
				}
			}
		}
	}

	return nil
}

// get mysql field value and convert it to specific value to es
func (r *River) getFieldValue(col *schema.TableColumn, fieldType string, value interface{}) interface{} {
	var fieldValue interface{}
	switch fieldType {
	case fieldTypeList:
		v := r.makeReqColumnData(col, value)
		if str, ok := v.(string); ok {
			fieldValue = strings.Split(str, ",")
		} else {
			fieldValue = v
		}

	case fieldTypeDate:
		if col.Type == schema.TYPE_NUMBER {
			col.Type = schema.TYPE_DATETIME

			v := reflect.ValueOf(value)
			switch v.Kind() {
			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
				fieldValue = r.makeReqColumnData(col, time.Unix(v.Int(), 0).Format(mysql.TimeFormat))
			}
		}
	}

	if fieldValue == nil {
		fieldValue = r.makeReqColumnData(col, value)
	}
	return fieldValue
}


text:
DESCRIPTION = "Helper script for OE's llvm support"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COREBASE}/LICENSE;md5=3f40d7994397109285ec7b81fdeb3b58 \
                    file://${COREBASE}/meta/COPYING.MIT;md5=3da9cfbcb788c80a0384361b4de20420 \
"

SRC_URI = "file://llvm-config"

ALLOW_EMPTY_${PN} = "1"
SYSROOT_PREPROCESS_FUNCS_append_class-target = " llvm_common_sysroot_preprocess"

llvm_common_sysroot_preprocess() {
    install -d ${SYSROOT_DESTDIR}${bindir_crossscripts}/
    install -m 0755 ${WORKDIR}/llvm-config ${SYSROOT_DESTDIR}${bindir_crossscripts}/
}

do_install_class-native() {
    install -d ${D}${bindir}
    install -m 0755 ${WORKDIR}/llvm-config ${D}${bindir}
}

BBCLASSEXTEND = "native"

repository: ExorEmbedded/exor-workspace

repo_name: ExorEmbedded/exor-workspace

gha_language: Python


text:
require clutter-gst.inc

PR = "${INC_PR}.0"

SRC_URI = "http://source.clutter-project.org/sources/clutter-gst/1.3/clutter-gst-${PV}.tar.bz2 \
          "

SRC_URI[md5sum] = "4f74f78df215cba54444dd6256a29bd4"
SRC_URI[sha256sum] = "de4ce6d3313be3074c6afc6f20276ef06f1a460b3a6755fc5c6e048685de137a"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@article{Arora2005b,
abstract = {Leaf phenology remains one of the most difficult processes to parameterize in terrestrial ecosystem models because our understanding of the physical processes that initiate leaf onset and senescence is incomplete. While progress has been made at the molecular level, for example by identifying genes that are associated with senescence and flowering for selected plant species, a picture of the processes controlling leaf phenology is only beginning to emerge. A variety of empirical formulations have been used with varying degrees of success in terrestrial ecosystem models for both extratropical and tropical biomes. For instance, the use of growing degree-days (GDDs) to initiate leaf onset has received considerable recognition and this approach is used in a number of models. There are, however, limitations when using GDDs and other empirically based formulations in global transient climate change simulations. The phenology scheme developed for the Canadian Terrestrial Ecosystem Model (CTEM), designed for inclusion in the Canadian Centre for Climate Modelling and Analysis coupled general circulation model, is described. The representation of leaf phenology is general enough to be applied over the globe and sufficiently robust for use in transient climate change simulations. Leaf phenology is functionally related to the (possibly changing) climate state and to atmospheric composition rather than to geographical boundaries or controls implicitly based on current climate. In this approach, phenology is controlled by environmental conditions as they affect the carbon balance. A carbon-gain-based scheme initiates leaf onset when it is beneficial for the plant, in carbon terms, to produce new leaves. Leaf offset is initiated by unfavourable environmental conditions that incur carbon losses and these include shorter day length, cooler temperatures, and dry soil moisture conditions. The comparison of simulated leaf onset and offset times with observation-based estimates for temperate and boreal deciduous, tropical evergreen, and tropical deciduous plant functional types at selected locations indicates that the phenology scheme performs satisfactorily. Model simulated leaf area index and stem and root biomass are also compared with observational estimates to illustrate the performance of CTEM.},
author = {Arora, Vivek K. and Boer, George J.},
doi = {10.1111/j.1365-2486.2004.00890.x},
file = {::},
isbn = {1354-1013},
issn = {13541013},
journal = {Global Change Biology},
keywords = {Allocation,Dynamic vegetation models,Ecosystem models,Leaf phenology},
number = {1},
pages = {39--59},
pmid = {88},
title = {{A parameterization of leaf phenology for the terrestrial ecosystem component of climate models}},
volume = {11},
year = {2005}
}
@article{Jolly2005,
abstract = {The phenological state of vegetation significantly affects exchanges of heat, mass, and momentum between the Earth's surface and the atmosphere. Although current patterns can be estimated from satellites, we lack the ability to predict future trends in response to climate change. We searched the literature for a common set of variables that might be combined into an index to quantify the greenness of vegetation throughout the year. We selected as variables: daylength (photoperiod), evaporative demand (vapor pressure deficit), and suboptimal (minimum) temperatures. For each variable we set threshold limits, within which the relative phenological performance of the vegetation was assumed to vary from inactive (0) to unconstrained (1). A combined Growing Season Index (GSI) was derived as the product of the three indices. Ten-day mean GSI values for nine widely dispersed ecosystems showed good agreement (r{\textgreater}0.8) with the satellite-derived Normalized Difference Vegetation Index (NDVI). We also tested the model at a temperate deciduous forest by comparing model estimates with average field observations of leaf flush and leaf coloration. The mean absolute error of predictions at this site was 3 days for average leaf flush dates and 2 days for leaf coloration dates. Finally, we used this model to produce a global map that distinguishes major differences in regional phenological controls. The model appears sufficiently robust to reconstruct historical variation as well as to forecast future phenological responses to changing climatic conditions.},
author = {Jolly, William M. and Nemani, Ramakrishna and Running, Steven W.},
doi = {10.1111/j.1365-2486.2005.00930.x},
file = {::},
isbn = {1365-2486},
issn = {13541013},
journal = {Global Change Biology},
keywords = {Climate change,Global,Minimum temperature,Model,Phenology,Photoperiod,Vapor pressure deficit},
number = {4},
pages = {619--632},
title = {{A generalized, bioclimatic index to predict foliar phenology in response to climate}},
volume = {11},
year = {2005}
}
@article{Jolly2004,
abstract = {We utilized an ecosystem process model to investigate the influence of precipitation and soil water potential on vegetation phenology in the semi-arid, drought-deciduous ecosystems in the Kalahari region of South Africa. The timing of leaf flush was assumed to be the first day during which a rainfall event exceeded that day's estimate of potential evapotranspiration after a defined dry season. Leaf senescence was assumed to be a dynamic feedback between soil water potential and net plant carbon gain and was determined by dynamically modeling the effects of concomitant trends in soil water potential and net primary production on leaf area index (LAI). Model predictions of LAI were compared with satellite-derived normalized difference vegetation indices (NDVI) for 3 years at two sites along the Kalahari transect. The mean absolute error for the prediction of modeled leaf flush date compared with leaf flush dates estimated from NDVI were 10.0 days for the Maun site and 39.3 days for the Tshane site. Correlations between model predicted 10-day average LAI and 10-day composite NDVI for both Maun and Tshane were high (q50.67 and 0.74, respectively, Po0.001), suggesting that this method adequately predicts intra-annual leaf area dynamics in these dry tropical ecosystems.},
author = {Jolly, William M. and Running, Steven W.},
doi = {10.1046/j.1365-2486.2003.00701.x},
file = {::},
isbn = {1365-2486},
issn = {13541013},
journal = {Global Change Biology},
keywords = {BIOME-BGC,Drought deciduous,Model,Phenology,Tropical},
number = {3},
pages = {303--308},
title = {{Effects of precipitation and soil water potential on drought deciduous phenology in the Kalahari}},
volume = {10},
year = {2004}
}
@article{Richardson2012,
abstract = {Phenology, by controlling the seasonal activity of vegetation on the land surface, plays a fundamental role in regulating photosynthesis and other ecosystem processes, as well as competitive interactions and feedbacks to the climate system. We conducted an analysis to evaluate the representation of phenology, and the associated seasonality of ecosystem-scale CO2 exchange, in 14 models participating in the North American Carbon Program Site Synthesis. Model predictions were evaluated using long-term measurements (emphasizing the period 20002006) from 10 forested sites within the AmeriFlux and Fluxnet-Canada networks. In deciduous forests, almost all models consistently predicted that the growing season started earlier, and ended later, than was actually observed; biases of 2weeks or more were typical. For these sites, most models were also unable to explain more than a small fraction of the observed interannual variability in phenological transition dates. Finally, for deciduous forests, misrepresentation of the seasonal cycle resulted in over-prediction of gross ecosystem photosynthesis by +160145gCm2yr1 during the spring transition period and +75130gCm2yr1 during the autumn transition period (13{\%} and 8{\%} annual productivity, respectively) compensating for the tendency of most models to under-predict the magnitude of peak summertime photosynthetic rates. Models did a better job of predicting the seasonality of CO2 exchange for evergreen forests. These results highlight the need for improved understanding of the environmental controls on vegetation phenology and incorporation of this knowledge into better phenological models. Existing models are unlikely to predict future responses of phenology to climate change accurately and therefore will misrepresent the seasonality and interannual variability of key biosphereatmosphere feedbacks and interactions in coupled global climate models.},
author = {Richardson, Andrew D. and Anderson, Ryan S. and Arain, M. Altaf and Barr, Alan G. and Bohrer, Gil and Chen, Guangsheng and Chen, Jing M. and Ciais, Philippe and Davis, Kenneth J. and Desai, Ankur R. and Dietze, Michael C. and Dragoni, Danilo and Garrity, Steven R. and Gough, Christopher M. and Grant, Robert and Hollinger, David Y. and Margolis, Hank A. and Mccaughey, Harry and Migliavacca, Mirco and Monson, Russell K. and Munger, J. William and Poulter, Benjamin and Raczka, Brett M. and Ricciuto, Daniel M. and Sahoo, Alok K. and Schaefer, Kevin and Tian, Hanqin and Vargas, Rodrigo and Verbeeck, Hans and Xiao, Jingfeng and Xue, Yongkang},
doi = {10.1111/j.1365-2486.2011.02562.x},
file = {::},
isbn = {1354-1013},
issn = {13541013},
journal = {Global Change Biology},
keywords = {Autumn senescence,Carbon cycle,Land surface model (LSM),Leaf area index (LAI),Model error,North American Carbon Program (NACP),Phenology,Seasonal dynamics,Spring onset},
number = {2},
pages = {566--584},
title = {{Terrestrial biosphere models need better representation of vegetation phenology: Results from the North American Carbon Program Site Synthesis}},
volume = {18},
year = {2012}
}
@article{Richardson2013,
abstract = {Vegetation phenology is highly sensitive to climate change. Phenology also controls many feedbacks of vegetation to the climate system by influencing the seasonality of albedo, surface roughness length, canopy conductance, and fluxes of water, energy, CO2 and biogenic volatile organic compounds. In this review, we first discuss the environmental drivers of phenology, and the impacts of climate change on phenology, in different biomes. We then examine the vegetation-climate feedbacks that are mediated by phenology, and assess the potential impact on these feedbacks of shifts in phenology driven by climate change. We finish with an overview of phenological modeling and we suggest ways in which models might be improved using existing data sets. Several key weaknesses in our current understanding emerge from this analysis. First, we need a better understanding of the drivers of phenology, particularly in under-studied biomes (e.g. tropical forests). We do not have a mechanistic understanding of the role of photoperiod, even in well-studied biomes. In all biomes, the factors controlling senescence and dormancy are not well-documented. Second, for the most part (i.e. with the exception of phenology impacts on CO2 exchange) we have only a qualitative understanding of the feedbacks between vegetation and climate that are mediated by phenology. We need to quantify the magnitude of these feedbacks, and ensure that they are accurately reproduced by models. Third, we need to work towards a new understanding of phenological processes that enables progress beyond the modeling paradigms currently in use. Accurate representation of phenological processes in models that couple the land surface to the climate system is particularly important, especially when such models are being used to predict future climate. ?? 2012 Elsevier B.V.},
author = {Richardson, Andrew D. and Keenan, Trevor F. and Migliavacca, Mirco and Ryu, Youngryel and Sonnentag, Oliver and Toomey, Michael},
doi = {10.1016/j.agrformet.2012.09.012},
file = {::},
isbn = {0168-1923},
issn = {01681923},
journal = {Agricultural and Forest Meteorology},
keywords = {Autumn senescence,Biosphere-atmosphere interactions,Budburst,Carbon cycle,Climate change,Global warming,Models,Phenology,Seasonality,Spring onset},
pages = {156--173},
publisher = {Elsevier B.V.},
title = {{Climate change, phenology, and phenological control of vegetation feedbacks to the climate system}},
url = {http://dx.doi.org/10.1016/j.agrformet.2012.09.012},
volume = {169},
year = {2013}
}
@article{St??ckli2008,
abstract = {Predicting the global carbon and water cycle requires a realistic representation of vegetation phenology in climate models. However most prognostic phenology models are not yet suited for global applications, and diagnostic satellite data can be uncertain and lack predictive power. We present a framework for data assimilation of Fraction of Photosynthetically Active Radiation absorbed by vegetation (FPAR) and Leaf Area Index (LAI) from the MODerate Resolution Imaging Spectroradiometer (MODIS) to constrain empirical temperature, light, moisture and structural vegetation parameters of a prognostic phenology model. We find that data assimilation better constrains structural vegetation parameters than climate control parameters. Improvements are largest for drought-deciduous ecosystems where correlation of predicted versus satellite-observed FPAR and LAI increases from negative to 0.7-0.8. Data assimilation effectively overcomes the cloud- and aerosol-related deficiencies of satellite data sets in tropical areas. Validation with a 49-year-long phenology data set reveals that the temperature-driven start of season (SOS) is light limited in warm years. The model has substantial skill (R = 0.73) to reproduce SOS inter-annual and decadal variability. Predicted SOS shows a higher inter-annual variability with a negative bias of 5-20 days compared to species-level SOS. It is however accurate to within 1-2 days compared to SOS derived from net ecosystem exchange (NEE) measurements at a FLUXNET tower. The model only has weak skill to predict end of season (EOS). Use of remote sensing data assimilation for phenology model development is encouraged but validation should be extended with phenology data sets covering mediterranean, tropical and arctic ecosystems.},
author = {Stockli, Reto and Rutishauser, T. and Dragoni, D. and O'Keefe, J. and Thornton, P. E. and Jolly, M. and Lu, L. and Denning, A. S.},
doi = {10.1029/2008JG000781},
file = {::},
isbn = {0148-0227},
issn = {01480227},
journal = {Journal of Geophysical Research: Biogeosciences},
number = {4},
pages = {1--19},
pmid = {261245300003},
title = {{Remote sensing data assimilation for a prognostic phenology model}},
volume = {113},
year = {2008}
}

extension: bib


text:
@misc{besancon2021frankwolfejl,
      title={{FrankWolfe.jl: a high-performance and flexible toolbox for Frank-Wolfe algorithms and Conditional Gradients}},
      author={Mathieu Besan\c{c}on and Alejandro Carderera and Sebastian Pokutta},
      year={2021},
      eprint={2104.06675},
      archivePrefix={arXiv},
      primaryClass={math.OC},
      note={\url{https://arxiv.org/abs/2104.06675}}
}


text:
@inproceedings{yaosheng2018deep,
  title = {Deep Semantic Role Labeling with Self-Attention},
  author = {Zhixing Tan and Mingxuan Wang and Jun Xie and Yidong Chen and Xiaodong Shi},
  booktitle={AAAI},
  year = {2018},
  url = {https://www.aaai.org/ocs/index.php/AAAI/AAAI18/paper/download/16725/16025}
}

url: https://raw.githubusercontent.com/Hugh-Shi/DL-NLP-Readings/924e4d189e5660c5b5d4854278f3df755ae2231d/Bibtex/Deep Semantic Role Labeling with Self-Attention.bib

repository: Hugh-Shi/DL-NLP-Readings

repo_name: Hugh-Shi/DL-NLP-Readings

gha_license_id: MIT


text:
@article{dodds2008systematic,
 author = {Dodds, Eric D and Clowers, Brian H and Hagerman, Paul J and Lebrilla, Carlito B},
 doi = {10.1016/j.ab.2007.10.009},
 journal = {Analytical biochemistry},
 number = {2},
 pages = {156--166},
 publisher = {Elsevier},
 title = {Systematic characterization of high mass accuracy influence on false discovery and probability scoring in peptide mass fingerprinting},
 volume = {372},
 year = {2008}
}

repository: bhclowers/academic-clowers

repo_name: bhclowers/academic-clowers


text:
DESCRIPTION = "Meta-package of extra applications for the GPE Palmtop Environment"
LICENSE = "MIT"
PR = "r4"

RDEPENDS_${PN} = "\
    task-gpe-apps \
    task-gpe-games \
    task-gpe-web \
    task-gpe-desktopapps"

inherit meta


text:
@misc{puris2020desarrollo,
  title={Desarrollo de metaheur{\'\i}sticas poblacionales para la soluci{\'o}n de problemas complejos},
  author={Puris C{\'a}ceres, Amilkar Yudier and Novoa Hern{\'a}ndez, Pavel and Oviedo Bayas, Byron},
  year={2020},
  publisher={Grupo Comp{\'a}s-Universidad Estatal T{\'e}cnica de Quevedo}
}

@phdthesis{novoa2014tecnicas,
  title={T{\'e}cnicas avanzadas de optimizaci{\'o}n en ambientes din{\'a}micos},
  author={Novoa Hern{\'a}ndez, Pavel},
  year={2014},
  school={Universidad de Granada}
}

@thesis{novoa2007aplicacion,
  title={Aplicaci{\'o}n Web para el Presupuesto de Ventas de la empresa Comandante Ernesto Che Guevara},
  author={Novoa Hern{\'a}ndez, Pavel},
  year={2007},
  school={Universidad de Holgu{\'\i}n}
}

repository: pnovoa/cv

repo_name: pnovoa/cv

branch_name: refs/heads/main


text:
cmake_minimum_required(VERSION 2.7)

project(libxml2 C)

# set (SOURCES buf.c c14n.c catalog.c chvalid.c debugXML.c dict.c encoding.c
#              entities.c error.c globals.c hash.c HTMLparser.c HTMLtree.c
#              legacy.c list.c nanoftp.c nanohttp.c parserInternals.c
#              parser.c pattern.c relaxng.c SAX2.c SAX.c schematron.c
#              testdso.c threads.c tree.c uri.c valid.c xinclude.c xlink.c
#              xmlIO.c xmlmemory.c xmlmodule.c xmlreader.c xmlregexp.c
#              xmlsave.c xmlschemas.c xmlschemastypes.c xmlstring.c
#              xmlunicode.c xmlwriter.c xpath.c xpointer.c xzlib.c)

FILE (GLOB SOURCES LIST_DIRECTORIES false *.c)
FILE (GLOB HEADERS_local LIST_DIRECTORIES false *.h)
FILE (GLOB_RECURSE HEADERS_include LIST_DIRECTORIES false include/*.h)
SET (HEADERS ${HEADERS_local} ${HEADERS_include})

include_directories(${CMAKE_CURRENT_SOURCE_DIR} include/)

add_library(xml2 SHARED ${SOURCES})
set_target_properties(xml2 PROPERTIES OUTPUT_NAME "xml2")

install(TARGETS xml2
        LIBRARY DESTINATION lib
        RUNTIME DESTINATION bin)

install(FILES HEADERS_include DESTINATION include)

repository: GDATAAdvancedAnalytics/bindifflib

repo_name: GDATAAdvancedAnalytics/bindifflib


text:
@proceedings{ws-2011-textgraphs,
    title = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    editor = "Matveeva, Irina  and
      Moschitti, Alessandro  and
      M{\`a}rquez, Llu{\'\i}s  and
      Massimo Zanzotto, Fabio",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1100",
}
@inproceedings{li-etal-2011-combination,
    title = "A Combination of Topic Models with Max-margin Learning for Relation Detection",
    author = "Li, Dingcheng  and
      Somasundaran, Swapna  and
      Chakraborty, Amit",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1101",
    pages = "1--9",
}
@inproceedings{yao-van-durme-2011-nonparametric,
    title = "Nonparametric {B}ayesian Word Sense Induction",
    author = "Yao, Xuchen  and
      Van Durme, Benjamin",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1102",
    pages = "10--14",
}
@inproceedings{gaillard-etal-2011-invariants,
    title = "Invariants and Variability of Synonymy Networks: Self Mediated Agreement by Confluence",
    author = "Gaillard, Beno{\^\i}t  and
      Gaume, Bruno  and
      Navarro, Emmanuel",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1103",
    pages = "15--23",
}
@inproceedings{jurgens-2011-word,
    title = "Word Sense Induction by Community Detection",
    author = "Jurgens, David",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1104",
    pages = "24--28",
}
@inproceedings{yazdani-popescu-belis-2011-using,
    title = "Using a {W}ikipedia-based Semantic Relatedness Measure for Document Clustering",
    author = "Yazdani, Majid  and
      Popescu-Belis, Andrei",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1105",
    pages = "29--36",
}
@inproceedings{tannier-etal-2011-grawltcq,
    title = "{G}rawl{TCQ}: Terminology and Corpora Building by Ranking Simultaneously Terms, Queries and Documents using Graph Random Walks",
    author = "Tannier, Xavier  and
      Couto, Javier  and
      de Groc, Cl{\'e}ment",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1106",
    pages = "37--41",
}
@inproceedings{muthukrishnan-etal-2011-simultaneous,
    title = "Simultaneous Similarity Learning and Feature-Weight Learning for Document Clustering",
    author = "Muthukrishnan, Pradeep  and
      Radev, Dragomir  and
      Mei, Qiaozhu",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1107",
    pages = "42--50",
}
@inproceedings{manshadi-allen-2011-unrestricted,
    title = "Unrestricted Quantifier Scope Disambiguation",
    author = "Manshadi, Mehdi  and
      Allen, James",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1108",
    pages = "51--59",
}
@inproceedings{sogaard-2011-ranked,
    title = "From ranked words to dependency trees: two-stage unsupervised non-projective dependency parsing",
    author = "S{\o}gaard, Anders",
    booktitle = "Proceedings of {T}ext{G}raphs-6: Graph-based Methods for Natural Language Processing",
    month = jun,
    year = "2011",
    address = "Portland, Oregon",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W11-1109",
    pages = "60--68",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings

gha_license_id: NOASSERTION

gha_language: TeX


text:
@InProceedings{zliobaite11a,
  title = {MOA Concept Drift Active Learning Strategies for Streaming Data},
  author = {Indre Zliobaite and Albert Bifet and Geoff Holmes and Bernhard Pfahringer},
  pages = {48--55},
  abstract = {We present a framework for active learning on evolving data streams, as an extension to the MOA system. In learning to classify streaming data, obtaining the true labels may require major effort and may incur excessive cost. Active learning focuses on learning an accurate model with as few labels as possible. Streaming data poses additional challenges for active learning, since the data distribution may change over time (concept drift) and classifiers need to adapt. Conventional active learning strategies concentrate on querying the most uncertain instances, which are typically concentrated around the decision boundary. If changes do not occur close to the boundary, they will be missed and classifiers will fail to adapt. We propose a software system that implements active learning strategies, extending the MOA framework. This software is released under the GNU GPL license.},
  pdf = {http://jmlr.org/proceedings/papers/v17/zliobaite11a/zliobaite11a.pdf},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
@inproceedings{2015ASPC..499..355S,
 adsnote = {Provided by the SAO/NASA Astrophysics Data System},
 adsurl = {http://adsabs.harvard.edu/abs/2015ASPC..499..355S},
 author = {Shinnaga, H. and Humphreys, E. and Indebetouw, R. and
Villard, E. and Kern, J. and Davis, L. and Miura, R.~E. and
Nakazato, T. and Sugimoto, K. and Kosugi, G. and Akiyama, E. and
Muders, D. and Wyrowski, F. and Williams, S. and Lightfoot, J. and
Kent, B. and Momjian, E. and Hunter, T. and ALMA Pipeline Team
},
 booktitle = {Revolution in Astronomy with ALMA: The Third Year},
 editor = {Iono, D. and Tatematsu, K. and Wootten, A. and Testi, L.
},
 month = {December},
 pages = {355},
 series = {Astronomical Society of the Pacific Conference Series},
 title = {ALMA Pipeline: Current Status},
 volume = {499},
 year = {2015}
}

repository: miurare/academic-kickstart

repo_name: miurare/academic-kickstart


text:
@inproceedings{butz2015determining,
  title={Determining good elimination orderings with darwinian networks},
  author={Butz, Cory James and Oliveira, Jhonatan Souza and dos Santos, Andr{\'e} Evaristo},
  booktitle={Twenty-eighth International Florida Artificial Intelligence Research Society Conference (FLAIRS)},
  pages={600--603},
  year={2015}
}

@article{butz2017darwinian,
  title={On Darwinian networks},
  author={Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E},
  journal={Computational Intelligence},
  volume={33},
  number={4},
  pages={629--655},
  year={2017},
  publisher={John Wihley \& Sons, Ltd}
}

@article{butz2017simple,
  title={On a simple method for testing independencies in Bayesian networks},
  author={Butz, Cory J and dos Santos, Andr{\'e} E and Oliveira, Jhonatan S and Gonzales, Christophe},
  journal={Computational Intelligence},
  volume={34},
  number={3},
  pages={789--801},
  year={2017}
}

@inproceedings{madsen2016tree,
  title={On Tree Structures Used by Simple Propagation},
  author={Madsen, Anders L and Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E},
  booktitle={Twenty-ninth Canadian Conference on Artificial Intelligence (AI)},
  pages={207--212},
  year={2016},
  organization={Springer, Cham}
}

@inproceedings{butz2016testing,
  title={Testing Independencies in Bayesian Networks with i-Separation},
  author={Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E and Madsen, Anders L},
  booktitle={Twenty-ninth International Florida Artificial Intelligence Research Society Conference (FLAIRS)},
  pages={644--649},
  year={2016}
}

@inproceedings{butz2016relevant,
  title={Relevant path separation: A faster method for testing independencies in bayesian networks},
  author={Butz, Cory J and dos Santos, Andr{\'e} E and Oliveira, Jhonatan S},
  booktitle={Eighth International Conference on Probabilistic Graphical Models (PGM)},
  pages={74--85},
  year={2016}
}

@inproceedings{oliveira2017resolving,
  title={Resolving Inconsistencies of Scope Interpretations in Sum-Product Networks},
  author={Oliveira, Jhonatan S and Butz, Cory J and dos Santos, Andr{\'e} E},
  booktitle={Thirtieth Canadian Conference on Artificial Intelligence (AI)},
  pages={305--315},
  year={2017},
  organization={Springer, Cham}
}

@inproceedings{dos2017converting,
  title={On Converting Sum-Product Networks into Bayesian Networks},
  author={dos Santos, Andr{\'e} E and Butz, Cory J and Oliveira, Jhonatan S},
  booktitle={Thirtieth Canadian Conference on Artificial Intelligence (AI)},
  pages={329--334},
  year={2017},
  organization={Springer, Cham}
}

@article{butz2018empirical,
  title={An empirical study of testing independencies in Bayesian networks using rp-separation},
  author={Butz, Cory J and dos Santos, Andre E and Oliveira, Jhonatan S and Gonzales, Christophe},
  journal={International Journal of Approximate Reasoning},
  volume={92},
  pages={270--278},
  year={2018},
  publisher={Elsevier}
}

@article{butz2018empirical,
  title={An empirical study of Bayesian network inference with simple propagation},
  author={Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E and Madsen, Anders L},
  journal={International Journal of Approximate Reasoning},
  volume={92},
  pages={198--211},
  year={2018},
  publisher={Elsevier}
}

@inproceedings{butz2017learning,
  title={On learning the structure of sum-product networks},
  author={Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andre E},
  booktitle={2017 IEEE Symposium Series on Computational Intelligence (SSCI)},
  pages={1--8},
  year={2017},
  organization={IEEE}
}

@inproceedings{butz2018efficient,
  title={Efficient Examination of Soil Bacteria Using Probabilistic Graphical Models},
  author={Butz, Cory J and dos Santos, Andr{\'e} E and Oliveira, Jhonatan S and Stavrinides, John},
  booktitle={Thirty-first International Conference on Industrial, Engineering \& Other Applications of Applied Intelligent Systems},
  pages={315--326},
  year={2018},
  organization={Springer, Cham}
}

@inproceedings{butz2017finding,
  title={On Finding Relevant Variables in Discrete Bayesian Network Inference},
  author={Butz, Cory James and Dos Santos, Andre Evaristo and Oliveira, Jhonatan Souza},
  booktitle={Thirtieth International Florida Artificial Intelligence Research Society Conference (FLAIRS)},
  pages={730--735},
  year={2017}
}

@inproceedings{butz2019deep,
  title={Deep Convolutional Sum-Product Networks},
  author={Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E and Teixeira, Andr{\'e} L},
  booktitle={Thirty-Third AAAI Conference on Artificial Intelligence (AAAI)},
  year={2019}
}

@inproceedings{butz2019tree,
  title={On the Tree Structure of Deep Convolutional Sum-Product Networks},
  author={Butz, Cory and Teixeira, Andre Lobo and Dos Santos, Andre E and Oliveira, Jhonatan S},
  booktitle={Thirty-Second International Florida Artificial Intelligence Research Society Conference (FLAIRS)},
  pages={500--503},
  year={2019}
}

@inproceedings{butz2019exploiting,
  title={Exploiting Symmetry of Independence in d-Separation},
  author={Butz, Cory J and dos Santos, Andr{\'e} E and Oliveira, Jhonatan S and Madsen, Anders L},
  booktitle={Thirty-second Canadian Conference on Artificial Intelligence (AI)},
  pages={42--54},
  year={2019},
  organization={Springer, Cham}
}

@inproceedings{madsen2019solving,
  title={Solving Influence Diagrams with Simple Propagation},
  author={Madsen, Anders L and Butz, Cory J and Oliveira, Jhonatan and dos Santos, Andr{\'e} E},
  booktitle={Thirty-second Canadian Conference on Artificial Intelligence (AI)},
  pages={68--79},
  year={2019},
  organization={Springer, Cham}
}

@inproceedings{butz2015darwinian,
  title={Darwinian Networks},
  author={Butz, C.J. and Oliveira, J.S. and dos Santos, A.E.},
  booktitle={Twenty-eighth Canadian Conference on Artificial Intelligence (AI)},
  pages={16--29},
  year={2015}
}

@inproceedings{butz2016bayesian,
  title={Bayesian Network Inference with Simple Propagation},
  author={Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E and Madsen, Anders L},
  booktitle={Twenty-ninth International Florida Artificial Intelligence Research Society Conference (FLAIRS)},
  pages={650--655},
  year={2016}
}

@inproceedings{butz2016simple,
  title={A Simple Method for Testing Independencies in Bayesian Networks},
  author={Butz, Cory J and dos Santos, Andr{\'e} E and Oliveira, Jhonatan S and Gonzales, Christophe},
  booktitle={Twenty-ninth Canadian Conference on Artificial Intelligence (AI)},
  pages={213--223},
  year={2016}
}

@inproceedings{butz2016bayesian,
  title={On Bayesian Network Inference with Simple Propagation},
  author={Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E and Madsen, Anders L},
  booktitle={Conference on Probabilistic Graphical Models},
  pages={62--73},
  year={2016}
}

@inproceedings{madsen2018simple,
  title={Simple Propagation with Arc-Reversal in Bayesian Networks},
  author={Madsen, Anders L and Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E},
  booktitle={Ninth International Conference on Probabilistic Graphical Models (PGM)},
  year={2018}
}

@inproceedings{butz2018empirical,
  title={An Empirical Study of Methods for SPN Learning and Inference},
  author={Butz, Cory J and Oliveira, Jhonatan S and dos Santos, Andr{\'e} E and Teixeira, Andr{\'e} L and Poupart, Pascal and Kalra, Agastya},
  booktitle={Ninth International Conference on Probabilistic Graphical Models (PGM)},
  pages={49--60},
  year={2018}
}

@article{dos2017proposal,
  title={Proposal and evaluation of a selection procedure for cast parts},
  author={dos Santos, Andr{\'e} Evaristo and Bringhenti, Anderson Tonello and Zimmermann, Juliana Ilha and Verran, Guilherme Ourique and Scalice, R{\'e}gis Kovacs and Bond, Danielle},
  journal={Journal of the Brazilian Society of Mechanical Sciences and Engineering},
  volume={39},
  number={8},
  pages={3151--3163},
  year={2017},
  publisher={Springer}
}


text:
file(REMOVE_RECURSE
  "CMakeFiles/rpc_server.dir/rpc/Util.cpp.o"
  "CMakeFiles/rpc_server.dir/rpc/DynamicThreadPool.cpp.o"
  "CMakeFiles/rpc_server.dir/rpc/Policy.cpp.o"
  "CMakeFiles/rpc_server.dir/rpc/MemoryPool.cpp.o"
  "CMakeFiles/rpc_server.dir/rpc/TaskQueue.cpp.o"
  "CMakeFiles/rpc_server.dir/rpc/Channel.cpp.o"
  "CMakeFiles/rpc_server.dir/rpc/TcpServer.cpp.o"
  "CMakeFiles/rpc_server.dir/rpc/test_memory_pool.cpp.o"
  "rpc_server.pdb"
  "rpc_server"
)

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


text:
package cache

import (
	"context"
	"fmt"
	"testing"

	"github.com/rafaeljusto/redigomock"
	"github.com/stretchr/testify/assert"
)

// TestSetAdd test the method SetAdd()
func TestSetAdd(t *testing.T) {

	t.Run("set add command using mocked redis", func(t *testing.T) {
		t.Parallel()

		// Load redis
		client, conn := loadMockRedis()
		assert.NotNil(t, client)
		defer client.CloseAll(conn)

		var tests = []struct {
			testCase     string
			setName      string
			member       interface{}
			dependencies []string
		}{
			{"set with dep", testKey, testStringValue, []string{testDependantKey}},
			{"set multiple strings", testKey, []string{"one", "two", "three"}, []string{testDependantKey}},
			{"set multiple integers", testKey, []int{1, 2, 3}, []string{testDependantKey}},
			{"empty value", testKey, "", []string{testDependantKey}},
			{"no value, no dep", testKey, "", []string{}},
		}
		for _, test := range tests {
			t.Run(test.testCase, func(t *testing.T) {
				conn.Clear()

				var commands []*redigomock.Cmd

				// The main command to test
				commands = append(commands, conn.Command(AddToSetCommand, test.setName, test.member))

				// Loop for each dependency
				if len(test.dependencies) > 0 {
					commands = append(commands, conn.Command(MultiCommand))
					for _, dep := range test.dependencies {
						commands = append(commands, conn.Command(AddToSetCommand, DependencyPrefix+dep, test.setName))
					}
					commands = append(commands, conn.Command(ExecuteCommand))

					err := SetAddRaw(conn, test.setName, test.member, test.dependencies...)
					assert.NoError(t, err)
				} else {
					err := SetAddRaw(conn, test.setName, test.member, test.dependencies...)
					assert.NoError(t, err)
				}

				for _, c := range commands {
					assert.Equal(t, true, c.Called)
				}
			})
		}
	})

	t.Run("set add command using real redis", func(t *testing.T) {
		if testing.Short() {
			t.Skip("skipping live local redis tests")
		}

		// Load redis
		client, conn, err := loadRealRedis()
		assert.NotNil(t, client)
		assert.NoError(t, err)
		defer client.CloseAll(conn)

		// Start with a fresh db
		err = clearRealRedis(conn)
		assert.NoError(t, err)

		// Fire the command
		err = SetAddRaw(conn, testKey, testStringValue)
		assert.NoError(t, err)

		// Check that the command worked
		var found bool
		found, err = SetIsMemberRaw(conn, testKey, testStringValue)
		assert.NoError(t, err)
		assert.Equal(t, true, found)
	})
}

// ExampleSetAdd is an example of the method SetAdd()
func ExampleSetAdd() {
	// Load a mocked redis for testing/examples
	client, _ := loadMockRedis()

	// Close connections at end of request
	defer client.Close()

	// Set the key/value
	_ = SetAdd(context.Background(), client, testKey, testStringValue, testDependantKey)

	// Fire the command
	_, _ = SetIsMember(context.Background(), client, testKey, testStringValue)
	fmt.Printf("found member: %v", testStringValue)
	// Output:found member: test-string-value
}

// TestSetAddMany test the method SetAddMany()
func TestSetAddMany(t *testing.T) {

	t.Run("set add many command using mocked redis", func(t *testing.T) {
		t.Parallel()

		// Load redis
		client, conn := loadMockRedis()
		assert.NotNil(t, client)
		defer client.CloseAll(conn)

		var tests = []struct {
			testCase string
			setName  string
			members  []interface{}
		}{
			{"set one", testKey, []interface{}{testStringValue}},
			{"set multiple strings", testKey, []interface{}{"one", "two", "three"}},
			{"empty value", testKey, []interface{}{}},
		}
		for _, test := range tests {
			t.Run(test.testCase, func(t *testing.T) {
				conn.Clear()

				var commands []*redigomock.Cmd

				// Create the arguments
				args := make([]interface{}, len(test.members)+1)
				args[0] = test.setName

				// Loop members
				for i, key := range test.members {
					args[i+1] = key
				}

				// The main command to test
				commands = append(commands, conn.Command(AddToSetCommand, args...))

				err := SetAddManyRaw(conn, test.setName, test.members...)
				assert.NoError(t, err)

				for _, c := range commands {
					assert.Equal(t, true, c.Called)
				}
			})
		}
	})

	t.Run("set add many command using real redis", func(t *testing.T) {
		if testing.Short() {
			t.Skip("skipping live local redis tests")
		}

		// Load redis
		client, conn, err := loadRealRedis()
		assert.NotNil(t, client)
		assert.NoError(t, err)
		defer client.CloseAll(conn)

		// Start with a fresh db
		err = clearRealRedis(conn)
		assert.NoError(t, err)

		// Fire the command
		err = SetAddMany(context.Background(), client, testKey, testStringValue, testStringValue+"2")
		assert.NoError(t, err)

		// Check that the command worked
		var found bool
		found, err = SetIsMember(context.Background(), client, testKey, testStringValue+"2")
		assert.NoError(t, err)
		assert.Equal(t, true, found)
	})
}

// ExampleSetAddMany is an example of the method SetAddMany()
func ExampleSetAddMany() {
	// Load a mocked redis for testing/examples
	client, _ := loadMockRedis()

	// Close connections at end of request
	defer client.Close()

	// Set the key/value
	_ = SetAddMany(context.Background(), client, testKey, testStringValue, testStringValue+"2")

	// Fire the command
	_, _ = SetIsMember(context.Background(), client, testKey, testStringValue+"2")
	fmt.Printf("found member: %v", testStringValue+"2")
	// Output:found member: test-string-value2
}

// TestSetRemoveMember test the method SetRemoveMember()
func TestSetRemoveMember(t *testing.T) {

	t.Run("set remove member command using mocked redis", func(t *testing.T) {
		t.Parallel()

		// Load redis
		client, conn := loadMockRedis()
		assert.NotNil(t, client)
		defer client.CloseAll(conn)

		var tests = []struct {
			testCase string
			setName  string
			member   interface{}
		}{
			{"set with dep", testKey, testStringValue},
			{"set multiple strings", testKey, testStringValue + "2"},
			{"set multiple integers", testKey, 1},
			{"empty value", testKey, ""},
		}
		for _, test := range tests {
			t.Run(test.testCase, func(t *testing.T) {
				conn.Clear()

				var commands []*redigomock.Cmd

				// The main command to test
				commands = append(commands, conn.Command(RemoveMemberCommand, test.setName, test.member))

				err := SetRemoveMember(context.Background(), client, test.setName, test.member)
				assert.NoError(t, err)

				for _, c := range commands {
					assert.Equal(t, true, c.Called)
				}
			})
		}
	})

	t.Run("set remove member command using real redis", func(t *testing.T) {
		if testing.Short() {
			t.Skip("skipping live local redis tests")
		}

		// Load redis
		client, conn, err := loadRealRedis()
		assert.NotNil(t, client)
		assert.NoError(t, err)
		defer client.CloseAll(conn)

		// Start with a fresh db
		err = clearRealRedis(conn)
		assert.NoError(t, err)

		// Fire the command
		err = SetAddRaw(conn, testKey, testStringValue)
		assert.NoError(t, err)

		// Check that the command worked
		var found bool
		found, err = SetIsMemberRaw(conn, testKey, testStringValue)
		assert.NoError(t, err)
		assert.Equal(t, true, found)

		// Fire the command
		err = SetRemoveMemberRaw(conn, testKey, testStringValue)
		assert.NoError(t, err)

		// Check that the command worked
		found, err = SetIsMemberRaw(conn, testKey, testStringValue)
		assert.NoError(t, err)
		assert.Equal(t, false, found)
	})
}

// ExampleSetRemoveMember is an example of the method SetRemoveMember()
func ExampleSetRemoveMember() {
	// Load a mocked redis for testing/examples
	client, _ := loadMockRedis()

	// Close connections at end of request
	defer client.Close()

	// Set the key/value
	_ = SetAddMany(context.Background(), client, testKey, testStringValue, testStringValue+"2")

	// Fire the command
	_ = SetRemoveMember(context.Background(), client, testKey, testStringValue+"2")
	fmt.Printf("removed member: %v", testStringValue+"2")
	// Output:removed member: test-string-value2
}

// TestSetIsMember test the method SetIsMember()
func TestSetIsMember(t *testing.T) {

	t.Run("set is member command using mocked redis", func(t *testing.T) {
		t.Parallel()

		// Load redis
		client, conn := loadMockRedis()
		assert.NotNil(t, client)
		defer client.CloseAll(conn)

		var tests = []struct {
			testCase      string
			setName       interface{}
			member        interface{}
			expectedFound int64
		}{
			{"valid set and member", testKey, testStringValue, 1},
			{"no set name", "", testStringValue, 0},
			{"no member", testKey, "", 0},
		}
		for _, test := range tests {
			t.Run(test.testCase, func(t *testing.T) {
				conn.Clear()

				// The main command to test
				isCmd := conn.Command(IsMemberCommand, test.setName, test.member).Expect(interface{}(test.expectedFound))

				found, err := SetIsMemberRaw(conn, test.setName, test.member)
				assert.NoError(t, err)
				assert.Equal(t, test.expectedFound > 0, found)
				assert.Equal(t, true, isCmd.Called)
			})
		}
	})

	t.Run("set is member command using real redis", func(t *testing.T) {
		if testing.Short() {
			t.Skip("skipping live local redis tests")
		}

		// Load redis
		client, conn, err := loadRealRedis()
		assert.NotNil(t, client)
		assert.NoError(t, err)
		defer client.CloseAll(conn)

		// Start with a fresh db
		err = clearRealRedis(conn)
		assert.NoError(t, err)

		// Fire the command
		err = SetAdd(context.Background(), client, testKey, testStringValue)
		assert.NoError(t, err)

		// Check that the command worked
		var found bool
		found, err = SetIsMember(context.Background(), client, testKey, testStringValue)
		assert.NoError(t, err)
		assert.Equal(t, true, found)
	})
}

// ExampleSetIsMember is an example of the method SetIsMember()
func ExampleSetIsMember() {
	// Load a mocked redis for testing/examples
	client, _ := loadMockRedis()

	// Close connections at end of request
	defer client.Close()

	// Set the key/value
	_ = SetAddMany(context.Background(), client, testKey, testStringValue, testStringValue+"2")

	// Fire the command
	_, _ = SetIsMember(context.Background(), client, testKey, testStringValue+"2")
	fmt.Printf("found member: %v", testStringValue+"2")
	// Output:found member: test-string-value2
}

// TestSetMembers will test the method SetMembers()
func TestSetMembers(t *testing.T) {

	t.Run("get members using mocked redis", func(t *testing.T) {
		t.Parallel()

		// Load redis
		client, conn := loadMockRedis()
		assert.NotNil(t, client)
		defer client.CloseAll(conn)

		var tests = []struct {
			testCase      string
			setName       interface{}
			expectedFound []interface{}
		}{
			{"valid set and members", testKey, []interface{}{"one", "two"}},
		}
		for _, test := range tests {
			t.Run(test.testCase, func(t *testing.T) {
				conn.Clear()

				// The main command to test
				cmd := conn.Command(MembersCommand, test.setName).Expect(test.expectedFound)

				found, err := SetMembersRaw(conn, test.setName)
				assert.NoError(t, err)
				assert.Equal(t, 2, len(found))
				assert.Equal(t, "one", found[0])
				assert.Equal(t, "two", found[1])
				assert.Equal(t, true, cmd.Called)
			})
		}
	})

}

// ExampleSetMembers is an example of the method SetMembers()
func ExampleSetMembers() {
	// Load a mocked redis for testing/examples
	client, _ := loadMockRedis()

	// Close connections at end of request
	defer client.Close()

	// Set the key/value
	_ = SetAddMany(context.Background(), client, testKey, testStringValue, testStringValue)

	// Fire the command
	_, _ = SetMembers(context.Background(), client, testKey)
	fmt.Printf("found members: [%v]", testStringValue)
	// Output:found members: [test-string-value]
}

gha_language: Go


text:
@article{Everett2010,
 abstract = {This study was designed to investigate the factors associated with the high rate of false-positive test results observed with the 4th-generation Murex HIV Ag/Ab Combination EIA (enzyme immunoassay) within an adolescent and young-adult cohort in northwest Tanzania. (4th-generation assays by definition detect both HIV antigen and antibody.) The clinical and sociodemographic factors associated with false-positive HIV results were analyzed for 6,940 Tanzanian adolescents and young adults. A subsample of 284 Murex assay-negative and 240 false-positive serum samples were analyzed for immunological factors, including IgG antibodies to malaria and schistosoma parasites, heterophile antibodies, and rheumatoid factor (RF) titers. Conditional logistic regression was used to estimate odds ratios (ORs) and 95% confidence intervals (CIs). False-positive HIV test results were associated with evidence of other infections. False positivity was strongly associated with increasing levels of Schistosoma haematobium worm IgG1, with adolescents with optical densities in the top quartile being at the highest risk (adjusted OR=40.7, 95% CI=8.5 to 194.2 compared with the risk for those in the bottom quartile). False positivity was also significantly associated with increasing S. mansoni egg IgG1 titers and RF titers of >or=80 (adjusted OR=8.2, 95% CI=2.8 to 24.3). There was a significant negative association between Murex assay false positivity and the levels of S. mansoni worm IgG1 and IgG2 and Plasmodium falciparum IgG1 and IgG4. In Africa, endemic infections may affect the specificities of immunoassays for HIV infection. Caution should be used when the results of 4th-generation HIV test results are interpreted for African adolescent populations.},
 article-pii = {2264-09},
 author = {Everett, Dean B. and Baisely, Kathy J. and McNerney, Ruth and Hambleton, Ian and Chirwa, Tobias and Ross, David A. and Changalucha, John and Watson-Jones, Deborah and Helmby, Helena and Dunne, David W. and Mabey, David and Hayes, Richard J.},
 completed = {20100806},
 doi = {10.1128/JCM.02264-09},
 electronic-issn = {1098-660X},
 electronic-publication = {20100224},
 grantno = {G0901756/Medical Research Council/United Kingdom},
 history = {2010/08/07 06:00 [medline]},
 issue = {5},
 journal = {Journal of clinical microbiology},
 keywords = {Adolescent, Adult, Animals, Antibodies, Helminth/blood, *False Positive Reactions, Female, HIV Infections/*diagnosis, Humans, Immunoenzyme Techniques/methods, Immunoglobulin G/blood, Male, Schistosoma haematobium/immunology, Schistosoma mansoni/immunology, Schistosomiasis/*complications, Tanzania, Young Adult},
 language = {eng},
 linking-issn = {0095-1137},
 location-id = {10.1128/JCM.02264-09 [doi]},
 month = {May},
 nlm-unique-id = {7505564},
 owner = {NLM},
 pages = {1570-7},
 print-issn = {0095-1137},
 publication-status = {ppublish},
 registry-number = {0 (Immunoglobulin G)},
 revised = {20181113},
 source = {J Clin Microbiol. 2010 May;48(5):1570-7. doi: 10.1128/JCM.02264-09. Epub 2010 Feb 24.},
 status = {MEDLINE},
 subset = {IM},
 title = {Association of schistosomiasis with false-positive HIV test results in an African adolescent population.},
 title-abbreviation = {J Clin Microbiol},
 volume = {48},
 year = {2010}
}


text:
require xorg-app-common.inc
DEPENDS += " glproto virtual/libgl"
PE = "1"
PR = "${INC_PR}.0"

SRC_URI[archive.md5sum] = "be3c5a9b242a57226b5bb5f22ec341ca"
SRC_URI[archive.sha256sum] = "f693977bdaea7eb6b095a6b6bc60b8a62110ecdef4c455211346e592f59c3772"

repository: trini/openembedded

repo_name: trini/openembedded


text:
SUMMARY = "A small Python module for determining appropriate + platform-specific dirs, e.g. a user data dir."
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=31625363c45eb0c67c630a2f73e438e4"

SRC_URI += " \
	file://run-ptest \
"

SRC_URI[md5sum] = "d6bca12613174185dd9abc8a29f4f012"
SRC_URI[sha256sum] = "7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"

inherit pypi setuptools3 ptest

RDEPENDS:${PN}-ptest += " \
	${PYTHON_PN}-pytest \
"

do_install_ptest() {
	install -d ${D}${PTEST_PATH}/test
	cp -rf ${S}/test/* ${D}${PTEST_PATH}/test/
}

BBCLASSEXTEND = "native nativesdk"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

gha_language: BitBake


text:
DESCRIPTION = "Initialization and demo application for bluetooth on WL1271 chipset"
SECTION = "network"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://LICENSE;md5=bb965abb1955d78452750ca40717999c"

DEPENDS += "openobex"
RDEPENDS_${PN} += "bluez4 openobex ussp-push obexftp bluez-hcidump obex-client"

PACKAGE_ARCH = "${MACHINE_ARCH}"
PACKAGE_STRIP = "no"

PR = "r5+gitr${SRCPV}"

BRANCH = "wl12xx"
SRCREV = "7736f86b8c157ffc3e2a0b9e55a97c093faae14e"

COMPATIBLE_MACHINE = "am37x-evm|am180x-evm|da850-omapl138-evm|am335x-evm"

SRC_URI = "git://github.com/TI-ECS/wl1271-bluetooth.git;protocol=git;branch=${BRANCH} \
           file://0001-Add-additional-hci0-up.patch \
"

S = "${WORKDIR}/git"

PLATFORM_am37x-evm = "omap3evm"
PLATFORM_am180x-evm = "am1808"
PLATFORM_da850-omapl138-evm = "am1808"
PLATFORM_am335x-evm = "am335x"
PLATFORM ?= "UNKNOWN"

do_install () {
	install -d ${D}${datadir}/wl1271-demos
	install -d ${D}${datadir}/wl1271-demos/bluetooth
	install -d ${D}${datadir}/wl1271-demos/bluetooth/gallery
	install -d ${D}${datadir}/wl1271-demos/bluetooth/scripts
	install -d ${D}${datadir}/wl1271-demos/bluetooth/ftp_folder

	install -m 0755 ${S}/gallery/* ${D}${datadir}/wl1271-demos/bluetooth/gallery
	install -m 0755 ${S}/script/common/* ${D}${datadir}/wl1271-demos/bluetooth/scripts
	install -m 0755 ${S}/script/${PLATFORM}/* ${D}${datadir}/wl1271-demos/bluetooth/scripts
	install -m 0755 ${S}/ftp_folder/* ${D}${datadir}/wl1271-demos/bluetooth/ftp_folder
}

FILES_${PN} +=" \
	${datadir}/wl1271-demos/bluetooth/scripts \
	${datadir}/wl1271-demos/bluetooth/gallery \
	${datadir}/wl1271-demos/bluetooth/ftp_folder \
	"


text:
DESCRIPTION = "Enhance translates between glade .xml files and ETK"
LICENSE = "MIT"
DEPENDS = "exml"
PV = "0.0.0+cvs${SRCDATE}"

inherit efl_library

repository: jdegges/gumstix-pip-oe

repo_name: jdegges/gumstix-pip-oe


text:
package val

/* ============================================
	Created by andy pangaribuan on 2021/05/18
	Copyright andypangaribuan. All rights reserved.
   ============================================ */
var Val *valStruct

func init() {
	Val = &valStruct{}
}

type valStruct struct { }

repository: andypangaribuan/vision-go

repo_name: andypangaribuan/vision-go


text:
SUMMARY = "Supervisor"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"
SRC_URI[md5sum] = "202f760f9bf4930ec06557bac73e5cf2"
SRC_URI[sha256sum] = "fc3af22e5a7af2f6c3be787acf055c1c17777f5607cd4dc935fe633ab97061fd"

SRC_URI = "file://supervisord.conf file://supervisord.init"

do_install_append() {
	     install -d ${D}${sysconfdir}/supervisor/conf.d
	     install -d ${D}${sysconfdir}/init.d

	     install -m 0644 ${WORKDIR}/supervisor/supervisord.conf ${D}${sysconfdir}
	     install -m 0755 ${WORKDIR}/supervisord.init ${D}${sysconfdir}/init.d/supervisord

}

pkg_postinst_${PN}_append() {
    update-rc.d supervisord defaults 90
}

pkg_postrm_${PN}_append() {
    update-rc.d supervisord remove
}

FILES_${PN} += "${sysconfdir}/supervisor/supervisord.conf"

inherit pypi setuptools

CLEANBROKEN = "1"

PYPI_PACKAGE = "supervisor"

RDEPENDS_${PN} = "python-modules python-distribute python-meld3"

repository: Sensorflow/meta-sensorflow

repo_name: Sensorflow/meta-sensorflow