text:
package gelf_test

import (
	"encoding/json"
	"io"
	"os"
	"testing"

	"github.com/stretchr/testify/assert"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"

	gelf "github.com/snovichkov/zap-gelf"
)

func TestAddr(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.Addr("127.0.0.1:80"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestHost(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.Host("google.com"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestVersion(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.Version("1.2"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestMessageKey(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.MessageKey("custom_message"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestLevelKey(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.LevelKey("custom_level"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestTimeKey(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.TimeKey("custom_time"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestNameKey(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.NameKey("custom_name"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestCallerKey(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.CallerKey("custom_caller"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestFunctionKey(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.FunctionKey("custom_function"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestStacktraceKey(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.StacktraceKey("custom_stacktrace"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestSkipLineEnding(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.SkipLineEnding(true),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestLineEnding(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.LineEnding("\r\n"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestEncodeDuration(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.EncodeDuration(zapcore.NanosDurationEncoder),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestEncodeCaller(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.EncodeCaller(zapcore.FullCallerEncoder),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestEncodeName(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.EncodeName(zapcore.FullNameEncoder),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestWriteSyncers(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.WriteSyncers(os.Stderr),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestNewReflectedEncoder(t *testing.T) {
	var newEncoder = func(writer io.Writer) zapcore.ReflectedEncoder {
		return json.NewEncoder(writer)
	}
	var core, err = gelf.NewCore(
		gelf.NewReflectedEncoder(newEncoder),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

func TestLevel(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.Level(zap.ErrorLevel),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
	assert.True(t, core.Enabled(zap.ErrorLevel))
	assert.False(t, core.Enabled(zap.WarnLevel))
}

func TestLevelString(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.LevelString("error"),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
	assert.True(t, core.Enabled(zap.ErrorLevel))
	assert.False(t, core.Enabled(zap.WarnLevel))
}

func TestLevelAtomic(t *testing.T) {
	atomicLevel := zap.NewAtomicLevel()
	atomicLevel.SetLevel(zap.ErrorLevel)

	var core, err = gelf.NewCore(
		gelf.LevelAtomic(atomicLevel),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
	assert.True(t, core.Enabled(zap.ErrorLevel))
	assert.False(t, core.Enabled(zap.WarnLevel))

	atomicLevel.SetLevel(zap.WarnLevel)

	assert.True(t, core.Enabled(zap.ErrorLevel))
	assert.True(t, core.Enabled(zap.WarnLevel))
}

func TestChunkSize(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.ChunkSize(2000),
	)
	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")

	core, err = gelf.NewCore(
		gelf.ChunkSize(gelf.MaxChunkSize + 1),
	)
	assert.Equal(t, gelf.ErrChunkTooLarge, err, "Unexpected error")
	assert.Nil(t, core, "Expected nil")

	core, err = gelf.NewCore(
		gelf.ChunkSize(gelf.MinChunkSize - 1),
	)
	assert.Equal(t, gelf.ErrChunkTooSmall, err, "Unexpected error")
	assert.Nil(t, core, "Expected nil")
}

func TestCompressionType(t *testing.T) {
	var (
		err              error
		core             zapcore.Core
		compressionTypes = []int{
			gelf.CompressionNone,
			gelf.CompressionGzip,
			gelf.CompressionZlib,
		}
	)

	for _, compressionType := range compressionTypes {
		core, err = gelf.NewCore(
			gelf.CompressionType(compressionType),
		)
		assert.Nil(t, err, "Unexpected error")
		assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
	}

	core, err = gelf.NewCore(
		gelf.CompressionType(13),
	)
	assert.Equal(t, gelf.ErrUnknownCompressionType, err, "Unexpected error")
	assert.Nil(t, core, "Expected nil")
}

func TestCompressionLevel(t *testing.T) {
	var core, err = gelf.NewCore(
		gelf.CompressionLevel(9),
	)

	assert.Nil(t, err, "Unexpected error")
	assert.Implements(t, (*zapcore.Core)(nil), core, "Expect zapcore.Core")
}

repository: snovichkov/zap-gelf

repo_name: snovichkov/zap-gelf


text:
DESCRIPTION = "Driftnet watches network traffic, and picks out and displays JPEG and GIF \
images for display. It is an horrific invasion of privacy and shouldn't be used \
by anyone anywhere. It can also extract MPEG audio data from the network and \
play it."
SECTION = "net"
PRIORITY = "optional"

DEPENDS = "libpcap jpeg libungif gtk+ libgpewidget"
PV = "0.1.6"

SRC_URI = "http://www.ex-parrot.com/~chris/driftnet/${PN}-${PV}.tar.gz \
	file://arm.patch"

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

inherit autotools

do_compile() {
	oe_runmake STAGING_INCDIR="${STAGING_INCDIR}"
}

do_install() {
	install -d ${D}/${bindir}
	install -m 0744 driftnet ${D}/${bindir}/
}

SRC_URI[md5sum] = "8e11d77770452f97bb3c23f510489815"
SRC_URI[sha256sum] = "dbdf7ead3ae14b109f88c86dedeb7524be8c257aa773a781891216f013373d6d"

license: MIT

repository: overo/overo-oe-natty

license_type: permissive

repo_name: overo/overo-oe-natty

branch_name: HEAD

extension: bb


text:
---
---

@article{LBS-2019,
  title    = {Origins of the concepts cause, cost, and goal in prereaching infants},
  author   = {Liu, S. and Brooks, N. B. and Spelke, E. S.},
  abstract = {We investigated the origins and interrelations of causal knowledge and
              knowledge of agency in 3-month-old infants, who cannot yet effect changes in
              the world by reaching for, grasping, and picking up objects. Across 5 experiments,
              n = 152 prereaching infants viewed object-directed reaches that varied in efficiency
              (following the shortest physically possible path vs. a longer path), goal
              (lifting an object vs. causing a change in its state), and causal structure
              (action on contact vs. action at a distance and after a delay). Prereaching infants
              showed no strong looking preference between a person's efficient and inefficient
              reaches when the person grasped and displaced an object. When the person reached for
              and caused a change in the state of the object on contact, however, infants looked
              longer when this action was inefficient than when it was efficient. Three-month-old
              infants also showed a key signature of adults' and older infants' causal inferences:
              This looking preference was abolished if a short spatial and temporal gap separated
              the action from its effect. The basic intuition that people are causal agents, who
              navigate around physical constraints to change the state of the world, may be one
              important foundation for infants' ability to plan their own actions and learn from
              the acts of others.},
  journal  = {Proc. Natl. Acad. Sci. U. S. A.},
  volume   =  {116},
  issue    =  {36},
  pages    = {17747--17752},
  month    =  {Sep},
  year     =  {2019},
  doi      = {10.1073/pnas.1904410116},
  url      = {https://www.pnas.org/content/116/36/17747},
  pdf      = {ehttps://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/liu_brooks_spelke_2019_pnas.pdf},
  selected = {true},
  abbr     = {PNAS},
  materials      = {https://osf.io/rcsns/},
  supp     = https://www.pnas.org/content/pnas/suppl/2019/08/19/1904410116.DCSupplemental/pnas.1904410116.sapp.pdf,
  bibtex_show = true
}

@article{LUTS-2017,
  title     = {Ten-month-old infants infer the value of goals from the costs of
               actions},
  author    = {Liu, S., and Ullman, T. D. and Tenenbaum, J. B. and
               Spelke, E. S.},
  abstract  = {Infants understand that people pursue goals, but how do they
               learn which goals people prefer? We tested whether infants solve
               this problem by inverting a mental model of action planning,
               trading off the costs of acting against the rewards actions
               bring. After seeing an agent attain two goals equally often at
               varying costs, infants expected the agent to prefer the goal it
               attained through costlier actions. These expectations held
               across three experiments that conveyed cost through different
               physical path features (height, width, and incline angle),
               suggesting that an abstract variable---such as ``force,''
               ``work,'' or ``effort''---supported infants' inferences. We
               modeled infants' expectations as Bayesian inferences over
               utility-theoretic calculations, providing a bridge to recent
               quantitative accounts of action understanding in older children
               and adults.},
  journal   = {Science},
  volume    =  {358},
  number    =  {6366},
  pages     = {1038--1041},
  month     =  {nov},
  year      =  {2017},
  language  = {en},
  abbr      = {Science},
  selected  =  {false},
  pdf       = {https://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/liu_etal_2017_science.pdf},
  materials       = {https://osf.io/mykph/},
  sup = https://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/liu_etal_2017_science_sm.pdf,
  bibtex_show = true
}

@article{Parkinson2014-ab,
  title    = "A common cortical metric for spatial, temporal, and social
              distance",
  author   = "Parkinson, C. and Liu, S. and Wheatley, T.",
  abstract = "Distance describes more than physical space: we speak of close
              friends and distant relatives, and of the near future and distant
              past. Did these ubiquitous spatial metaphors arise in language
              coincidentally or did they arise because they are rooted in a
              common neural computation? To address this question, we used
              statistical pattern recognition techniques to analyze human fMRI
              data. First, a machine learning algorithm was trained to
              discriminate patterns of fMRI responses based on relative
              egocentric distance within trials from one distance domain (e.g.,
              photographs of objects relatively close to or far away from the
              viewer in spatial distance trials). Next, we tested whether the
              decision boundary generated from this training could distinguish
              brain responses according to relative egocentric distance within
              each of two separate distance domains (e.g., phrases referring to
              the immediate or more remote future within temporal distance
              trials; photographs of participants' friends or acquaintances
              within social distance trials). This procedure was repeated using
              all possible combinations of distance domains for training and
              testing the classifier. In all cases, above-chance decoding
              across distance domains was possible in the right inferior
              parietal lobule (IPL). Furthermore, the representational
              similarity structure within this brain area reflected
              participants' own judgments of spatial distance, temporal
              soon-ness, and social familiarity. Thus, the right IPL may
              contain a parsimonious encoding of proximity to self in spatial,
              temporal, and social frames of reference.",
  journal  = "J. Neurosci.",
  volume   =  34,
  number   =  5,
  pages    = "1979--1987",
  year     =  "2014",
  keywords = "Adult; Algorithms; Analysis of Variance; Artificial Intelligence;
              Brain Mapping; Cerebral Cortex; Cerebral Cortex: blood supply;
              Cerebral Cortex: physiology; Computer-Assisted; Female; Humans;
              Image Processing; Judgment; Judgment: physiology; Magnetic
              Resonance Imaging; Male; Oxygen; Oxygen: blood; Questionnaires;
              Reaction Time; Social Distance; Space Perception; Space
              Perception: physiology; Young Adult",
  abbr     = "JNeuro",
  pdf      = "https://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/parkinson_etal_2014_jn.pdf",
  bibtex_show = true
}

@ARTICLE{LGF-2018,
  title    = "Worth the wait: Children trade off delay and reward in self- and
              other-benefiting decisions",
  author   = "Liu, S. and Gonzalez, G. and Warneken, F.",
  abstract = "Abstract Human prosocial behaviors are supported by
              early-emerging psychological processes that detect and fulfill
              the needs of others. However, little is known about the
              mechanisms that enable children to deliver benefits to others at
              costs to the self, which requires weighing other-regarding and
              self-serving preferences. We used an intertemporal choice
              paradigm to systematically study and compare these behaviors in
              5-year-old children. Our results show that other-benefiting and
              self-benefiting behavior share a common decision-making process
              that integrates delay and reward. Specifically, we found that
              children sought to minimize delay and maximize reward, and traded
              off delays against rewards, regardless of whether these rewards
              were for the children themselves or another child. However, we
              found that children were more willing to invest their time to
              benefit themselves than someone else. Together, these findings
              show that from childhood, other- and self-serving decisions are
              supported by a general mechanism that flexibly integrates
              information about the magnitude of rewards, and the opportunity
              costs of pursuing them. A video abstract of this article can be
              viewed at: https://youtu.be/r8S0DGe7f8Q",
  journal  = "Developmental Science",
  volume   =  6,
  pages    = "e12702",
  month    =  jul,
  year     =  2018,
  abbr     = "DevSci",
  pdf      = 'https://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/Liu_et_al-2018-Developmental_Science.pdf'
  materials = 'https://osf.io/k5twy/',
  supp = https://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/liu_etal_2018_devsci_sm.pdf,
  bibtex_show = true
}

@INPROCEEDINGS{Gjata2020-vj,
  title           = "Look before you leap: Quantitative tradeoffs between peril
                     and reward in action understanding",
  booktitle       = "Proceedings of the 42nd Annual Meeting of the Cognitive
                     Science Society",
  author          = "Gjata, N. and Ullman, T. D. and Spelke, E. S. and
                     Liu, S.",
  year            =  2020,
  conference      = "Cognitive Science Society",
  abbr            = "CogSci",
  pdf             = "https://www.shariliu.com/hubfs/shariliu.com/papers_and_docs/gjata_etal_clif_cogsci2020.pdf",
  materials       = "https://osf.io/u8b9s/",
  bibtex_show = true
}

@INPROCEEDINGS{Woo2021-py,
  title     = "Open-minded, not na{\"\i}ve: Three-month-old infants encode
               objects as the goals of other people's reaches",
  booktitle = "Proceedings of the 43rd Annual Meeting of the Cognitive Science
               Society",
  author    = "Woo, B. M. and Liu, S. and Spelke, E. S.",
  abstract  = "When people act on objects, their goals can depend on the
               objects' intrinsic properties and conventional uses (e.g., using
               forks, not knives, to eat spaghetti), locations (e.g., clearing
               the table, regardless of what is on it), or both (eating with
               the fork next to your plate, not your dining partner's). For
               adults, objects' intrinsic properties matter more than their
               locations in most action contexts. Whereas 5-month-old infants
               privilege objects' intrinsic properties in attributing goals to
               people reaching for objects, 3-month-old infants do not. Do
               younger infants fail to view reaching as goal-directed, or are
               they uncertain which properties of objects are relevant in
               different contexts? Here we show that 3-month-old infants
               attribute goals to others' reaching actions when given
               information that their actions depend on what, not where, an
               object is. Our findings suggest that 3-month-old infants can
               learn about others' object goals, before they reach for objects
               themselves.",
  publisher = "PsyArXiv",
  month     =  jul,
  year      =  2021,
  keywords  = "action understanding; cognitive development; infancy",
  abbr      = "CogSci",
  pdf       = "https://psyarxiv.com/qjvre",
  bibtex_show = true
}

@INPROCEEDINGS{Liu2019-yr,
  title           = "Hard choices: Children's understanding of the cost of
                     action selection",
  booktitle       = "Proceedings of the 41st Annual Meeting of the Cognitive
                     Science Society",
  author          = "Liu, S and Cushman, F. and Gershman, S. and Kool,
                     W. and Spelke, E. S.",
  year            =  2019,
  conference      = "Cognitive Science Society",
  location        = "Montreal, Canada",
  abbr            = "CogSci",
  pdf             = "https://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/phk_cogsci_2019_final.pdf",
  bibtex_show     = true
}

@INPROCEEDINGS{Liu2019-rb,
  title           = "People's perception of others' risk preferences",
  booktitle       = "Proceedings of the 41st Annual Meeting of the Cognitive
                     Science Society",
  author          = "Liu, S. and McCoy, J. and Ullman, T.",
  year            =  2019,
  conference      = "Cognitive Science Society",
  location        = "Montreal, Canada",
  abbr            = "CogSci",
  pdf             = "https://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/risk_cogsci_2019_final.pdf",
  bibtex_show     = true
}

@UNPUBLISHED{CTSL-pre,
  title    = "iCatcher+: Robust and automatic gaze classification of infant
              webcam videos",
  author   = "Cao, P. and Tan, X. and Scott, K. M. and Liu, S.",
  abstract = "Studies of human infants provide a window into the origins of the
              mind, and collecting and annotating behavioral data from them
              remains slow and laborious. Although online platforms enable
              families to participate in studies via webcam, it remains time-
              and energy- consuming to manually annotate gaze directions on the
              collected videos. Existing gaze coding algorithms on videos
              either suffer from low video quality or still require
              considerable manual effort. In this project, we built on a
              promising system for automatic gaze annotation in human infants,
              iCatcher (Erel et al., 2020), and added two key additional
              features: a more robust infant face detector, and a gaze
              estimator that takes into account not only the features of the
              selected face, but where and how far it is from the screen. In
              our framework, iCatcher+, all possible faces in a video frame are
              first extracted by a face extractor, and then the infant face is
              selected by a infant selector; finally, the gaze direction is
              classified by a gaze estimator based on both the selected face
              and features of its bounding box. We evaluated iCatcher+ on a
              large-scale infant video dataset collected via webcam. The
              experimental results show improvements in gaze estimation
              accuracy, compared to the baseline framework. We see iCatcher+ as
              a key tool for enabling rapid large-scale studies of infant
              behavior.",
  month    =  sep,
  year     =  2021,
  keywords = "eye-tracking; infancy; infant cognition; Lookit; online studies",
  abbr     =  {working paper},
  pdf      = "https://psyarxiv.com/s8c4m/",
  selected = true,
  bibtex_show = true
}

@UNPUBLISHED{LUTS-2019,
  title    = "Dangerous ground: Thirteen-month-old infants are sensitive to
              peril in other people's actions",
  author   = "Liu, S. and Ullman, T. D. and Tenenbaum, J. B. and Spelke,
              E. S.",
  abstract = "Do infants appreciate that other people's actions may fail, and
              that the possibility of failure endows risky actions with
              variable amounts of negative utility (hereafter, ``peril'')?
              Three experiments addressed this question by presenting 10- and
              13-month-old infants (N=124) with an agent who chose whether or
              not to jump over a trench of varying depth to reach two goals. At
              13 months, infants expected the agent to minimize the potential
              negative consequences of actions, even though they never observed
              the agent fail to complete its action successfully. Moreover,
              they learned which goal the agent preferred by observing how much
              peril it risked to reach each goal. Although findings at 10
              months were not clear, these findings provide evidence that
              13-month-old infants represent danger as a kind of cost, possibly
              in an integrated utility calculus. They invite further study of
              infants' understanding of mental states and of counterfactual
              aspects of action.",
  month    =  nov,
  year     =  2019,
  keywords = "action understanding; cognitive development; infant cognition;
              open data; open materials; pre-registration",
  abbr     =  {under revision},
  pdf     = {https://psyarxiv.com/rvydk/},
  materials       = "https://osf.io/kz7br/",
  bibtex_show = true
}

@inproceedings{Shu2021-kt,
  title         = "{AGENT}: A Benchmark for Core Psychological Reasoning",
  author        = "Shu, T. and Bhandwaldar, A. and Gan, C. and
                   Smith, K. A. and Liu, S. and Gutfreund, D. and Spelke,
                   E. and Tenenbaum, J. B. and Ullman, T. D.",
  abstract      = "For machine agents to successfully interact with humans in
                   real-world settings, they will need to develop an
                   understanding of human mental life. Intuitive psychology,
                   the ability to reason about hidden mental variables that
                   drive observable actions, comes naturally to people: even
                   pre-verbal infants can tell agents from objects, expecting
                   agents to act efficiently to achieve goals given
                   constraints. Despite recent interest in machine agents that
                   reason about other agents, it is not clear if such agents
                   learn or hold the core psychology principles that drive
                   human reasoning. Inspired by cognitive development studies
                   on intuitive psychology, we present a benchmark consisting
                   of a large dataset of procedurally generated 3D animations,
                   AGENT (Action, Goal, Efficiency, coNstraint, uTility),
                   structured around four scenarios (goal preferences, action
                   efficiency, unobserved constraints, and cost-reward
                   trade-offs) that probe key concepts of core intuitive
                   psychology. We validate AGENT with human-ratings, propose an
                   evaluation protocol emphasizing generalization, and compare
                   two strong baselines built on Bayesian inverse planning and
                   a Theory of Mind neural network. Our results suggest that to
                   pass the designed tests of core intuitive psychology at
                   human levels, a model must acquire or have built-in
                   representations of how agents plan, combining utility
                   computations and core knowledge of objects and physics.",
  month         =  feb,
  year          =  2021,
  booktitle     =  "Proceedings of the 38th International Conference on Machine Learning",
  abbr          = "ICML",
  pdf           = "http://arxiv.org/abs/2102.12321",
  html          = "https://www.tshu.io/AGENT/",
  bibtex_show = true
}

@ARTICLE{Liu2017-kl,
  title     = "Six-month-old infants expect agents to minimize the cost of
               their actions",
  author    = "Liu, S. and Spelke, E. S.",
  journal   = "Cognition",
  publisher = "Elsevier B.V.",
  volume    =  160,
  pages     = "35--42",
  year      =  2017,
  keywords  = "cognitive development; corresponding author; data; goal
               inference",
  abbr      = "Cognition",
  pdf       = "https://www.shariliu.com/hubfs/shariliu.com/papers_and_docs/liu_spelke_2017_cognition.pdf",
  materials       = "https://osf.io/6r9dd/",
  supp = https://cdn2.hubspot.net/hubfs/481197/shariliu.com/papers_and_docs/liu_spelke_2017_cognition_sm.pdf,
  bibtex_show = true
}

repository: shariliu/old-website

repo_name: shariliu/old-website

branch_name: refs/heads/master

extension: bib


text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: github.com/infobloxopen/feature-flag-service/pkg/pb/service.proto

package pb

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	_ "github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger/options"
	query "github.com/infobloxopen/atlas-app-toolkit/query"
	_ "github.com/lyft/protoc-gen-validate/validate"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type VersionResponse struct {
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VersionResponse) Reset()         { *m = VersionResponse{} }
func (m *VersionResponse) String() string { return proto.CompactTextString(m) }
func (*VersionResponse) ProtoMessage()    {}
func (*VersionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6544829dd69549ee, []int{0}
}

func (m *VersionResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VersionResponse.Unmarshal(m, b)
}
func (m *VersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VersionResponse.Marshal(b, m, deterministic)
}
func (m *VersionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VersionResponse.Merge(m, src)
}
func (m *VersionResponse) XXX_Size() int {
	return xxx_messageInfo_VersionResponse.Size(m)
}
func (m *VersionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_VersionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_VersionResponse proto.InternalMessageInfo

func (m *VersionResponse) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

type FeatureFlag struct {
	FeatureName          string   `protobuf:"bytes,1,opt,name=feature_name,json=featureName,proto3" json:"feature_name,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	Origin               string   `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FeatureFlag) Reset()         { *m = FeatureFlag{} }
func (m *FeatureFlag) String() string { return proto.CompactTextString(m) }
func (*FeatureFlag) ProtoMessage()    {}
func (*FeatureFlag) Descriptor() ([]byte, []int) {
	return fileDescriptor_6544829dd69549ee, []int{1}
}

func (m *FeatureFlag) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FeatureFlag.Unmarshal(m, b)
}
func (m *FeatureFlag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FeatureFlag.Marshal(b, m, deterministic)
}
func (m *FeatureFlag) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FeatureFlag.Merge(m, src)
}
func (m *FeatureFlag) XXX_Size() int {
	return xxx_messageInfo_FeatureFlag.Size(m)
}
func (m *FeatureFlag) XXX_DiscardUnknown() {
	xxx_messageInfo_FeatureFlag.DiscardUnknown(m)
}

var xxx_messageInfo_FeatureFlag proto.InternalMessageInfo

func (m *FeatureFlag) GetFeatureName() string {
	if m != nil {
		return m.FeatureName
	}
	return ""
}

func (m *FeatureFlag) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *FeatureFlag) GetOrigin() string {
	if m != nil {
		return m.Origin
	}
	return ""
}

type ListFeatureFlagsRequest struct {
	Filter               *query.Filtering  `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"`
	Labels               map[string]string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ListFeatureFlagsRequest) Reset()         { *m = ListFeatureFlagsRequest{} }
func (m *ListFeatureFlagsRequest) String() string { return proto.CompactTextString(m) }
func (*ListFeatureFlagsRequest) ProtoMessage()    {}
func (*ListFeatureFlagsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6544829dd69549ee, []int{2}
}

func (m *ListFeatureFlagsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFeatureFlagsRequest.Unmarshal(m, b)
}
func (m *ListFeatureFlagsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFeatureFlagsRequest.Marshal(b, m, deterministic)
}
func (m *ListFeatureFlagsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFeatureFlagsRequest.Merge(m, src)
}
func (m *ListFeatureFlagsRequest) XXX_Size() int {
	return xxx_messageInfo_ListFeatureFlagsRequest.Size(m)
}
func (m *ListFeatureFlagsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFeatureFlagsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListFeatureFlagsRequest proto.InternalMessageInfo

func (m *ListFeatureFlagsRequest) GetFilter() *query.Filtering {
	if m != nil {
		return m.Filter
	}
	return nil
}

func (m *ListFeatureFlagsRequest) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type ListFeatureFlagsResponse struct {
	Results              []*FeatureFlag  `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	Page                 *query.PageInfo `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ListFeatureFlagsResponse) Reset()         { *m = ListFeatureFlagsResponse{} }
func (m *ListFeatureFlagsResponse) String() string { return proto.CompactTextString(m) }
func (*ListFeatureFlagsResponse) ProtoMessage()    {}
func (*ListFeatureFlagsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6544829dd69549ee, []int{3}
}

func (m *ListFeatureFlagsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFeatureFlagsResponse.Unmarshal(m, b)
}
func (m *ListFeatureFlagsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFeatureFlagsResponse.Marshal(b, m, deterministic)
}
func (m *ListFeatureFlagsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFeatureFlagsResponse.Merge(m, src)
}
func (m *ListFeatureFlagsResponse) XXX_Size() int {
	return xxx_messageInfo_ListFeatureFlagsResponse.Size(m)
}
func (m *ListFeatureFlagsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFeatureFlagsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListFeatureFlagsResponse proto.InternalMessageInfo

func (m *ListFeatureFlagsResponse) GetResults() []*FeatureFlag {
	if m != nil {
		return m.Results
	}
	return nil
}

func (m *ListFeatureFlagsResponse) GetPage() *query.PageInfo {
	if m != nil {
		return m.Page
	}
	return nil
}

type ReadFeatureFlagRequest struct {
	FeatureName          string                `protobuf:"bytes,1,opt,name=feature_name,json=featureName,proto3" json:"feature_name,omitempty"`
	Fields               *query.FieldSelection `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"`
	Labels               map[string]string     `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ReadFeatureFlagRequest) Reset()         { *m = ReadFeatureFlagRequest{} }
func (m *ReadFeatureFlagRequest) String() string { return proto.CompactTextString(m) }
func (*ReadFeatureFlagRequest) ProtoMessage()    {}
func (*ReadFeatureFlagRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6544829dd69549ee, []int{4}
}

func (m *ReadFeatureFlagRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReadFeatureFlagRequest.Unmarshal(m, b)
}
func (m *ReadFeatureFlagRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReadFeatureFlagRequest.Marshal(b, m, deterministic)
}
func (m *ReadFeatureFlagRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadFeatureFlagRequest.Merge(m, src)
}
func (m *ReadFeatureFlagRequest) XXX_Size() int {
	return xxx_messageInfo_ReadFeatureFlagRequest.Size(m)
}
func (m *ReadFeatureFlagRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadFeatureFlagRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ReadFeatureFlagRequest proto.InternalMessageInfo

func (m *ReadFeatureFlagRequest) GetFeatureName() string {
	if m != nil {
		return m.FeatureName
	}
	return ""
}

func (m *ReadFeatureFlagRequest) GetFields() *query.FieldSelection {
	if m != nil {
		return m.Fields
	}
	return nil
}

func (m *ReadFeatureFlagRequest) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type ReadFeatureFlagResponse struct {
	Result               *FeatureFlag `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *ReadFeatureFlagResponse) Reset()         { *m = ReadFeatureFlagResponse{} }
func (m *ReadFeatureFlagResponse) String() string { return proto.CompactTextString(m) }
func (*ReadFeatureFlagResponse) ProtoMessage()    {}
func (*ReadFeatureFlagResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6544829dd69549ee, []int{5}
}

func (m *ReadFeatureFlagResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReadFeatureFlagResponse.Unmarshal(m, b)
}
func (m *ReadFeatureFlagResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReadFeatureFlagResponse.Marshal(b, m, deterministic)
}
func (m *ReadFeatureFlagResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadFeatureFlagResponse.Merge(m, src)
}
func (m *ReadFeatureFlagResponse) XXX_Size() int {
	return xxx_messageInfo_ReadFeatureFlagResponse.Size(m)
}
func (m *ReadFeatureFlagResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadFeatureFlagResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ReadFeatureFlagResponse proto.InternalMessageInfo

func (m *ReadFeatureFlagResponse) GetResult() *FeatureFlag {
	if m != nil {
		return m.Result
	}
	return nil
}

func init() {
	proto.RegisterType((*VersionResponse)(nil), "service.VersionResponse")
	proto.RegisterType((*FeatureFlag)(nil), "service.FeatureFlag")
	proto.RegisterType((*ListFeatureFlagsRequest)(nil), "service.ListFeatureFlagsRequest")
	proto.RegisterMapType((map[string]string)(nil), "service.ListFeatureFlagsRequest.LabelsEntry")
	proto.RegisterType((*ListFeatureFlagsResponse)(nil), "service.ListFeatureFlagsResponse")
	proto.RegisterType((*ReadFeatureFlagRequest)(nil), "service.ReadFeatureFlagRequest")
	proto.RegisterMapType((map[string]string)(nil), "service.ReadFeatureFlagRequest.LabelsEntry")
	proto.RegisterType((*ReadFeatureFlagResponse)(nil), "service.ReadFeatureFlagResponse")
}

func init() {
	proto.RegisterFile("github.com/infobloxopen/feature-flag-service/pkg/pb/service.proto", fileDescriptor_6544829dd69549ee)
}

var fileDescriptor_6544829dd69549ee = []byte{
	// 758 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xc1, 0x6e, 0x23, 0x35,
	0x18, 0xd6, 0x24, 0x21, 0x65, 0x1d, 0x24, 0x8a, 0xb5, 0x4a, 0x86, 0xb0, 0xd2, 0x7a, 0x73, 0x2a,
	0xbb, 0x8d, 0xbd, 0x1b, 0x7a, 0x00, 0x7a, 0x40, 0xa5, 0xb4, 0x15, 0xa8, 0x82, 0x6a, 0x5a, 0x71,
	0xe0, 0xd0, 0xca, 0x93, 0xf9, 0x33, 0x35, 0x75, 0xc6, 0xae, 0xed, 0x19, 0x88, 0x10, 0x17, 0x6e,
	0x5c, 0xe1, 0x45, 0xfa, 0x02, 0x3c, 0x01, 0x47, 0x5e, 0x81, 0x17, 0xe0, 0xc4, 0x15, 0xcd, 0x8c,
	0x13, 0x0d, 0x6d, 0x4a, 0x41, 0xe2, 0x36, 0xf6, 0xff, 0xf9, 0xfb, 0xfc, 0x7f, 0xfe, 0xec, 0x41,
	0x1f, 0xa5, 0xc2, 0x5d, 0xe6, 0x31, 0x9d, 0xaa, 0x39, 0xfb, 0x34, 0x9b, 0xa9, 0x58, 0xaa, 0x6f,
	0xc7, 0xfb, 0x67, 0x5f, 0x30, 0xee, 0x24, 0xb7, 0x74, 0x06, 0xdc, 0xe5, 0x06, 0xe8, 0x4c, 0xf2,
	0x94, 0xe9, 0xab, 0x94, 0xe9, 0x98, 0x59, 0x30, 0x85, 0x98, 0x02, 0xd5, 0x46, 0x39, 0x85, 0x37,
	0xfc, 0x70, 0xf8, 0x4e, 0xaa, 0x54, 0x2a, 0x81, 0x55, 0xd3, 0x71, 0x3e, 0x63, 0x30, 0xd7, 0x6e,
	0x51, 0xa3, 0x86, 0x4f, 0x7c, 0x91, 0x6b, 0xc1, 0x78, 0x96, 0x29, 0xc7, 0x9d, 0x50, 0x99, 0xf5,
	0xd5, 0xdd, 0xc6, 0x26, 0xe4, 0x62, 0xe6, 0x6a, 0x8e, 0xe9, 0x38, 0x85, 0x6c, 0x5c, 0x70, 0x29,
	0x12, 0xee, 0x80, 0xdd, 0xf9, 0xf0, 0x8b, 0xb7, 0x1b, 0x60, 0xfb, 0x0d, 0x4f, 0x53, 0x30, 0x4c,
	0xe9, 0x8a, 0x7e, 0x8d, 0xd4, 0x67, 0x0d, 0x29, 0xe1, 0xfb, 0x55, 0x1a, 0xb2, 0xba, 0xdf, 0x31,
	0xd7, 0x7a, 0xec, 0x94, 0x92, 0x57, 0xc2, 0xb1, 0xeb, 0x1c, 0xcc, 0x82, 0x4d, 0x95, 0x94, 0x30,
	0x2d, 0x29, 0x2e, 0x94, 0x06, 0xc3, 0x9d, 0x32, 0x9e, 0x6b, 0xf4, 0x02, 0xbd, 0xf9, 0x25, 0x18,
	0x2b, 0x54, 0x16, 0x81, 0xd5, 0x2a, 0xb3, 0x80, 0x43, 0xb4, 0x51, 0xd4, 0x53, 0x61, 0x40, 0x82,
	0xad, 0x47, 0xd1, 0x72, 0x38, 0x3a, 0x47, 0xbd, 0xc3, 0xda, 0xcc, 0x43, 0xc9, 0x53, 0xfc, 0x0c,
	0xbd, 0xe1, 0xbd, 0xbd, 0xc8, 0xf8, 0x1c, 0x3c, 0xba, 0xe7, 0xe7, 0x3e, 0xe7, 0x73, 0xc0, 0x8f,
	0xd1, 0x6b, 0x05, 0x97, 0x39, 0x84, 0xad, 0xaa, 0x56, 0x0f, 0x70, 0x1f, 0x75, 0x95, 0x11, 0xa9,
	0xc8, 0xc2, 0x76, 0x35, 0xed, 0x47, 0xa3, 0x5f, 0x03, 0x34, 0x38, 0x16, 0xd6, 0x35, 0x44, 0x6c,
	0x04, 0xd7, 0x39, 0x58, 0x87, 0x19, 0xea, 0xce, 0x84, 0x74, 0x60, 0x2a, 0x99, 0xde, 0x64, 0x40,
	0x97, 0xad, 0x53, 0xae, 0x05, 0x3d, 0xac, 0x6a, 0x22, 0x4b, 0x23, 0x0f, 0xc3, 0x9f, 0xa0, 0xae,
	0xe4, 0x31, 0x48, 0x1b, 0xb6, 0x48, 0x7b, 0xab, 0x37, 0xd9, 0xa6, 0xcb, 0x43, 0xbf, 0x47, 0x82,
	0x1e, 0x57, 0xf0, 0x83, 0xcc, 0x99, 0x45, 0xe4, 0xd7, 0x0e, 0x3f, 0x40, 0xbd, 0xc6, 0x34, 0xde,
	0x44, 0xed, 0x2b, 0x58, 0xf8, 0x4e, 0xcb, 0xcf, 0xf5, 0x1d, 0x7e, 0xd8, 0x7a, 0x3f, 0x18, 0x15,
	0x28, 0xbc, 0xab, 0xe4, 0x3d, 0xa6, 0x68, 0xc3, 0x80, 0xcd, 0xa5, 0xb3, 0x61, 0x50, 0xed, 0xee,
	0xf1, 0x6a, 0x77, 0x0d, 0x7c, 0xb4, 0x04, 0xe1, 0xe7, 0xa8, 0xa3, 0x79, 0x5a, 0x8b, 0xf4, 0x26,
	0xfd, 0xbf, 0xf7, 0x7e, 0xc2, 0x53, 0x28, 0x73, 0x1f, 0x55, 0x98, 0xd1, 0x1f, 0x01, 0xea, 0x47,
	0xc0, 0x93, 0x26, 0x91, 0x37, 0xf1, 0x5f, 0x9c, 0xd8, 0x4e, 0xe9, 0x33, 0xc8, 0xc4, 0x7a, 0xad,
	0x27, 0xb7, 0x7d, 0x06, 0x99, 0x9c, 0x82, 0x8f, 0x53, 0xe4, 0xb1, 0x78, 0x7f, 0x65, 0x76, 0xbb,
	0x6a, 0xe7, 0xc5, 0xaa, 0x9d, 0xf5, 0x3b, 0xf9, 0xbf, 0xbd, 0x3e, 0x42, 0x83, 0x3b, 0x42, 0xde,
	0xea, 0x6d, 0xd4, 0xad, 0x5d, 0xf4, 0xc1, 0x59, 0xef, 0xb4, 0xc7, 0x4c, 0x6e, 0x5a, 0x68, 0x73,
	0xaf, 0xbc, 0x46, 0xcd, 0xa0, 0x9f, 0x20, 0x74, 0x04, 0xce, 0xdf, 0x13, 0xdc, 0xa7, 0xf5, 0x43,
	0x40, 0x97, 0xaf, 0x04, 0x3d, 0x28, 0x5f, 0x89, 0x61, 0xb8, 0x22, 0xbe, 0x75, 0xa3, 0x46, 0x9b,
	0x3f, 0xfc, 0xf6, 0xfb, 0xcf, 0x2d, 0x84, 0x5f, 0x67, 0xfe, 0x26, 0xe1, 0x73, 0xd4, 0x29, 0xb3,
	0x81, 0xc9, 0x43, 0xa1, 0x1c, 0x3e, 0xfb, 0x07, 0x84, 0xa7, 0x7f, 0xab, 0xa2, 0xef, 0xe1, 0x47,
	0xcc, 0x1f, 0xa4, 0xc5, 0x5f, 0xa3, 0x4e, 0xe9, 0x07, 0x7e, 0xfa, 0xc0, 0x39, 0x0c, 0xc9, 0xfd,
	0x00, 0xcf, 0xfe, 0xb4, 0x62, 0x7f, 0x1b, 0x0f, 0x96, 0xec, 0xec, 0xbb, 0x66, 0x86, 0xbe, 0xff,
	0xf8, 0xcf, 0xe0, 0xa7, 0xbd, 0x5f, 0x02, 0x7c, 0x13, 0xa0, 0x61, 0xe5, 0x1c, 0xf1, 0x2c, 0xa4,
	0xa4, 0x21, 0xa7, 0x35, 0x3d, 0xfe, 0x31, 0x58, 0x53, 0xf4, 0xda, 0x64, 0xeb, 0x0c, 0xcc, 0x5c,
	0x64, 0xb9, 0x7d, 0x97, 0x68, 0xa3, 0x0a, 0x91, 0x80, 0x25, 0xee, 0x12, 0xc8, 0x94, 0x6b, 0x1e,
	0x0b, 0x29, 0xdc, 0x82, 0x38, 0x45, 0x44, 0xe6, 0x8c, 0x4a, 0xf2, 0x29, 0x2c, 0xd7, 0xd9, 0x55,
	0xc3, 0x65, 0x4d, 0x95, 0x6b, 0x93, 0xbc, 0x0a, 0x26, 0x51, 0x19, 0xe1, 0xc4, 0x19, 0x2e, 0x24,
	0x51, 0x86, 0x48, 0x31, 0x17, 0x0e, 0x12, 0x12, 0x73, 0x2b, 0x2c, 0x9d, 0x74, 0x8b, 0x57, 0xf4,
	0x25, 0x7d, 0x39, 0xea, 0xb0, 0xe2, 0x15, 0x7b, 0xde, 0x0a, 0x5a, 0x5f, 0xed, 0xfc, 0xe7, 0x5f,
	0xc8, 0xae, 0x8e, 0xe3, 0x6e, 0x95, 0x80, 0xf7, 0xfe, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x9a,
	0x6a, 0xf2, 0x81, 0x06, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// AtlasFeatureFlagClient is the client API for AtlasFeatureFlag service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AtlasFeatureFlagClient interface {
	GetVersion(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*VersionResponse, error)
	List(ctx context.Context, in *ListFeatureFlagsRequest, opts ...grpc.CallOption) (*ListFeatureFlagsResponse, error)
	Read(ctx context.Context, in *ReadFeatureFlagRequest, opts ...grpc.CallOption) (*ReadFeatureFlagResponse, error)
}

type atlasFeatureFlagClient struct {
	cc *grpc.ClientConn
}

func NewAtlasFeatureFlagClient(cc *grpc.ClientConn) AtlasFeatureFlagClient {
	return &atlasFeatureFlagClient{cc}
}

func (c *atlasFeatureFlagClient) GetVersion(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*VersionResponse, error) {
	out := new(VersionResponse)
	err := c.cc.Invoke(ctx, "/service.AtlasFeatureFlag/GetVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *atlasFeatureFlagClient) List(ctx context.Context, in *ListFeatureFlagsRequest, opts ...grpc.CallOption) (*ListFeatureFlagsResponse, error) {
	out := new(ListFeatureFlagsResponse)
	err := c.cc.Invoke(ctx, "/service.AtlasFeatureFlag/List", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *atlasFeatureFlagClient) Read(ctx context.Context, in *ReadFeatureFlagRequest, opts ...grpc.CallOption) (*ReadFeatureFlagResponse, error) {
	out := new(ReadFeatureFlagResponse)
	err := c.cc.Invoke(ctx, "/service.AtlasFeatureFlag/Read", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AtlasFeatureFlagServer is the server API for AtlasFeatureFlag service.
type AtlasFeatureFlagServer interface {
	GetVersion(context.Context, *empty.Empty) (*VersionResponse, error)
	List(context.Context, *ListFeatureFlagsRequest) (*ListFeatureFlagsResponse, error)
	Read(context.Context, *ReadFeatureFlagRequest) (*ReadFeatureFlagResponse, error)
}

func RegisterAtlasFeatureFlagServer(s *grpc.Server, srv AtlasFeatureFlagServer) {
	s.RegisterService(&_AtlasFeatureFlag_serviceDesc, srv)
}

func _AtlasFeatureFlag_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AtlasFeatureFlagServer).GetVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.AtlasFeatureFlag/GetVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AtlasFeatureFlagServer).GetVersion(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AtlasFeatureFlag_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListFeatureFlagsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AtlasFeatureFlagServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.AtlasFeatureFlag/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AtlasFeatureFlagServer).List(ctx, req.(*ListFeatureFlagsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AtlasFeatureFlag_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadFeatureFlagRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AtlasFeatureFlagServer).Read(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.AtlasFeatureFlag/Read",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AtlasFeatureFlagServer).Read(ctx, req.(*ReadFeatureFlagRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _AtlasFeatureFlag_serviceDesc = grpc.ServiceDesc{
	ServiceName: "service.AtlasFeatureFlag",
	HandlerType: (*AtlasFeatureFlagServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetVersion",
			Handler:    _AtlasFeatureFlag_GetVersion_Handler,
		},
		{
			MethodName: "List",
			Handler:    _AtlasFeatureFlag_List_Handler,
		},
		{
			MethodName: "Read",
			Handler:    _AtlasFeatureFlag_Read_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "github.com/infobloxopen/feature-flag-service/pkg/pb/service.proto",
}

repository: infobloxopen/feature-flag-service

repo_name: infobloxopen/feature-flag-service

extension: go


text:
require binutils.inc
LICENSE = "GPLv3"

PR = "${INC_PR}.4"

SRC_URI = "\
     ${GNU_MIRROR}/binutils/binutils-${PV}.tar.bz2 \
     file://binutils-uclibc-100-uclibc-conf.patch \
     file://110-arm-eabi-conf.patch \
     file://binutils-uclibc-300-001_ld_makefile_patch.patch \
     file://binutils-uclibc-300-006_better_file_error.patch \
     file://binutils-uclibc-300-012_check_ldrunpath_length.patch \
     file://binutils-uclibc-gas-needs-libm.patch \
     file://ld-stub-crash.patch;striplevel=0 \
     file://binutils-arm-non-empty-know.patch \
     file://binutils_unexport_LD_LIBRARY_PATH_for_CC_FOR_BUILD.patch \
     file://binutils-x86_64_i386_biarch.patch \
     "

# powerpc patches
SRC_URI += "\
     file://binutils-2.16.1-e300c2c3.patch \
     file://binutils-powerpc-pr11088.patch \
     "

SRC_URI[md5sum] = "ee2d3e996e9a2d669808713360fa96f8"
SRC_URI[sha256sum] = "e1df09f0aa3b50154ef93bfefe86d65d01c22cfb44d73299ad95e772133a75b0"


text:
@ARTICLE{richard2009online,
  author={Richard, C{\'e}dric and Bermudez, Jos{\'e} Carlos M and Honeine, Paul},
  journal=IEEE Transactions on Signal Processing},
  title={Online Prediction of Time Series Data With Kernels},
  year={2009},
  month=mar,
  volume={57},
  number={3},
  pages={1058--1067},
}


text:
// © Copyright IBM Corporation 2020. All rights reserved.
// SPDX-License-Identifier: Apache2.0
//
package listeners

import (
	"context"
	"encoding/json"
	"errors"
	"os"
	"sync"
	"time"

	"github.com/stellar/go/clients/horizon"
	"github.com/GFTN/gftn-services/gftn-models/model"
	global_environment "github.com/GFTN/gftn-services/utility/global-environment"
	"github.com/GFTN/gftn-services/utility/kafka"
)

// StellarAccountPaymentListener is listening for a new payments received by ReceivingAccount
type StellarAccountPaymentListener struct {
	horizon horizon.ClientInterface
	account model.Account
	cursor  horizon.Cursor
	//wg        sync.WaitGroup
	channel   chan string
	initFetch bool
}

// NewStellarAccountStellarAccountPaymentListener creates a new StellarAccountPaymentListener
func NewStellarAccountStellarAccountPaymentListener(
	horizon horizon.ClientInterface,
) (pl StellarAccountPaymentListener, err error) {
	pl.horizon = horizon
	pl.account = model.Account{}
	ch := make(chan string)
	pl.channel = ch
	pl.initFetch = true

	return pl, nil
}

//SetDistAccount - Save account ID in memory
func (pl *StellarAccountPaymentListener) SetDistAccount(account model.Account) {
	pl.account.Address = account.Address
	pl.account.Name = account.Name
	return
}

// Listen starts listening for new payments
func (pl *StellarAccountPaymentListener) Listen(ch chan string) (err error) {

	if *pl.account.Address == "" {
		err = errors.New("account ID is empty to listen")
		return
	}
	_, err = pl.horizon.LoadAccount(*pl.account.Address)
	if err != nil {
		LOGGER.Errorf("Account %v is invalid on Stellar NW", *pl.account.Address)
		return
	}
	ctx, cancel := context.WithCancel(context.Background())

	var wg sync.WaitGroup
	wg.Add(2)
	//defer cancel()

	//routine to listen on payments stream
	go pl.ListenLoop(ctx, ch, *pl.account.Address, cancel, &wg)

	//routine to receive signal from parent listener
	go func(ch chan string, cancelFunc context.CancelFunc, loopContext context.Context, wg *sync.WaitGroup) {
		defer wg.Done()
		for {
			select {
			case p := <-ch:
				LOGGER.Infof("Listener on account %v got signal: %v \n", pl.account.Address, p)
				cancelFunc()
				time.Sleep(1 * time.Second)

				return
			case <-loopContext.Done():
				LOGGER.Infof("Done: %v ", pl.account.Address)
				return
			}
		}
	}(ch, cancel, ctx, &wg)

	//routine to wait for wait group to end
	go func(ch chan string, wg *sync.WaitGroup) {
		wg.Wait()
		LOGGER.Debugf("*************** Restarting Listener %v ***************", pl.account.Address)
		time.Sleep(1 * time.Second)
		cursor, err := dynamoClient.GetAccountCursor(pl.account.Name)
		if err != nil {
			LOGGER.Errorf("Encounter error while updating new cursor for account: %v", pl.account.Name)
			return
		}
		pl.cursor = horizon.Cursor(cursor.Cursor)
		err = pl.Listen(ch)
	}(ch, &wg)
	return
}

func (pl *StellarAccountPaymentListener) ListenLoop(ctx context.Context, ch chan string, accountID string, cancelFunc context.CancelFunc, wg *sync.WaitGroup) {
	defer wg.Done()

	go func() {
		LOGGER.Debugf("Started listening for new payments: account: %v, cursor: %v\n", accountID, pl.cursor)
		err := pl.horizon.StreamPayments(ctx, accountID, &pl.cursor, pl.onPayment)
		if err != nil {
			LOGGER.Error("Error while streamining ", err.Error())
			go func() { cancelFunc() }()
		}
	}()

	select {
	case p := <-ch:
		LOGGER.Debugf("Got signal %v, account Name: %v", p, pl.account.Name)
	case <-ctx.Done():
		LOGGER.Debugf("ListenLoop Done: %v", pl.account.Name)
		return
	}
}

//onPayment - Callback onPayment method
func (pl *StellarAccountPaymentListener) onPayment(payment horizon.Payment) {

	LOGGER.Infof("onPayment called")
	transaction, err := pl.horizon.LoadTransaction(payment.TransactionHash)
	cursor := transaction.PagingToken()
	if err != nil {
		LOGGER.Errorf("Error while retrieving transaction %s: %s, cursor: %s, %s", payment.TransactionHash, err.Error(),
			cursor, transaction.Memo)
		return
	}

	LOGGER.Infof("id %s New received payment %s, Cursor:%s, %s ", payment.ID, payment.TransactionHash,
		cursor, transaction.Memo)

	//paging token is the last read cursor, save it
	pl.cursor = horizon.Cursor(cursor)

	//send notification to gateway
	pNotification := model.Receive{}
	pNotification.TransactionID = &payment.TransactionHash
	pNotification.TransactionMemo = payment.Memo.Value
	pNotification.TransactionReference = &cursor
	pNotification.AccountName = &pl.account.Name

	if !pl.initFetch {

		/*
			sending message to Kafka
		*/

		ofiId := os.Getenv(global_environment.ENV_KEY_HOME_DOMAIN_NAME)

		b, _ := json.Marshal(pNotification)
		err = kafkaOperations.Produce(ofiId+"_"+kafka.PAYMENT_TOPIC, b)
		if err != nil {
			LOGGER.Errorf("Kafka producer failed")
			return
		}
		/*
			write to dynamo
		*/

		err = dynamoClient.UpdateAccountCursor(pl.account.Name, string(cursor))
		if err != nil {
			LOGGER.Error("Error updating cursor to Dynamo DB: %v", err.Error())
		}
	}
	pl.initFetch = false
}

repository: yu-jeffy/ibm-world-wire

repo_name: yu-jeffy/ibm-world-wire

branch_name: refs/heads/main


text:
%% This BibTeX bibliography file was created using BibDesk.
%% http://bibdesk.sourceforge.net/

%% Created for Jesse Harris at 2021-08-30 07:56:38 -0700

%% Saved with string encoding Unicode (UTF-8)

@article{RasekhiHarris2021:PersianEllipsis,
	Author = {Vahideh Rasekhi and Jesse A. Harris},
	Date-Modified = {2021-08-30 07:56:34 -0700},
	Journal = {Glossa: A journal of general linguistics},
	Keywords = {Persian, ellipsis, locality},
	Title = {Processing ambiguous stripping ellipsis structures in Persian},
	Year = {2021}}


text:
package caesar

import (
	"sort"
	"strings"
)

type transpositionBlock struct {
	data []string
	seq  []int
}

type element struct {
	value rune
	index int
}

type byRune []element

func (a byRune) Len() int           { return len(a) }
func (a byRune) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a byRune) Less(i, j int) bool { return a[i].value < a[j].value }

func newTranspositionBlock(key string) *transpositionBlock {
	tb := new(transpositionBlock)
	tb.data = make([]string, len(key))
	tb.seq = computeKeySeq(key)

	return tb
}

// loads text into block and then returns text as if it were read
// by column in alphabetic order of the original keyword
func (tb *transpositionBlock) transpose(text string) string {
	for i := 0; i < len(tb.seq); i++ {
		var column strings.Builder
		for j := i; j < len(text); j += len(tb.seq) {
			column.WriteByte(text[j])
		}
		tb.data[i] = column.String()
	}

	var out strings.Builder
	for _, colIdx := range tb.seq {
		out.WriteString(tb.data[colIdx])
	}
	return out.String()
}

// loads already transformed text into the block and returns
// text as if it were read by column in original order of key letters
func (tb *transpositionBlock) detranspose(text string) string {
	chunk := (len(text) / len(tb.seq)) + 1
	incompleteColumns := (chunk * len(tb.seq)) - len(text)
	fullColumns := len(tb.seq) - incompleteColumns

	// associate seq with size of destination columns
	colSizes := make([]int, len(tb.seq))
	for i, seq := range tb.seq {
		if seq < fullColumns {
			colSizes[i] = chunk
		} else {
			colSizes[i] = chunk - 1
		}
	}

	// iterate through text, adding letters to appropriate columns
	// based on sequence number
	textIdx := 0
	for i, colIdx := range tb.seq {
		var column strings.Builder
		start := textIdx
		textIdx += colSizes[i]
		for start < textIdx {
			column.WriteByte(text[start])
			start++
		}
		tb.data[colIdx] = column.String()
	}
	// return value is data read off by row
	var out strings.Builder
	for row := 0; row < chunk; row++ {
		for _, col := range tb.data {
			if len(col) <= row {
				continue
			}
			out.WriteByte(col[row])
		}
	}
	return out.String()
}

func computeKeySeq(key string) []int {
	seq := make([]int, len(key))
	elements := make([]element, len(key))
	for idx, r := range key {
		elements[idx] = element{value: r, index: idx}
	}
	sort.Sort(byRune(elements))
	for idx, el := range elements {
		seq[idx] = el.index
	}

	return seq
}

repository: stripedpajamas/caesar

repo_name: stripedpajamas/caesar


text:
package tpl

const TextareaTpl = `<textarea placeholder="{{.Placeholder}}" name="{{.Name}}" id="{{.Id}}" class="layui-textarea">{{if .Content}}{{.Content}}{{end}}</textarea>`


text:
@misc{sbl.jl,
	author  = {Andreas Hildebrandt <andreas.hildebrandt@uni-mainz.de> and contributors},
	title   = {sbl.jl},
	url     = {https://github.com/hildebrandtlab/sbl.jl},
	version = {v0.1.0},
	year    = {2020},
	month   = {10}
}

gha_license_id: MIT

gha_language: Julia


text:
@InProceedings{kontorovich15,
  title = {{A Bayes consistent 1-NN classifier}},
  author = {Kontorovich, Aryeh and Weiss, Roi},
  pages = {480-488},
  abstract = {We show that a simple modification of the 1-nearest neighbor classifier yields a strongly Bayes consistent learner. Prior to this work, the only strongly Bayes consistent proximity-based method was the k-nearest neighbor classifier, for k growing appropriately with sample size. We will argue that a margin-regularized 1-NN enjoys considerable statistical and algorithmic advantages over the k-NN classifier. These include user-friendly finite-sample error bounds, as well as time- and memory-efficient learning and test-point evaluation algorithms with a principled speed-accuracy tradeoff. Encouraging empirical results are reported.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
% Encoding: UTF-8

@book{book_key,
  author  = {First Last},
  title   = {test_title},
  publisher = {test_publisher},
  year    = {test_year},
}

@article{article_key,
  author = {First1 Last1 and First2 von Last2},
  title = {\lambda and \'{o}},
  year = {1965}
}

@article{article_key2,
  author = {First1 Last1 and First2 d'Last2},
  title = {It's all \alpha \beta about the {\lambda}{JAZZ}!},
  year = {2011}
}

repository: piotrbajger/bibtexmagic

repo_name: piotrbajger/bibtexmagic


text:
// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	strfmt "github.com/go-openapi/strfmt"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// Instrument Tradeable Contracts, Indices, and History
// swagger:model Instrument
type Instrument struct {

	// ask price
	AskPrice float64 `json:"askPrice,omitempty"`

	// bankrupt limit down price
	BankruptLimitDownPrice float64 `json:"bankruptLimitDownPrice,omitempty"`

	// bankrupt limit up price
	BankruptLimitUpPrice float64 `json:"bankruptLimitUpPrice,omitempty"`

	// bid price
	BidPrice float64 `json:"bidPrice,omitempty"`

	// buy leg
	BuyLeg string `json:"buyLeg,omitempty"`

	// calc interval
	// Format: date-time
	CalcInterval strfmt.DateTime `json:"calcInterval,omitempty"`

	// capped
	Capped bool `json:"capped,omitempty"`

	// closing timestamp
	// Format: date-time
	ClosingTimestamp strfmt.DateTime `json:"closingTimestamp,omitempty"`

	// deleverage
	Deleverage bool `json:"deleverage,omitempty"`

	// expiry
	// Format: date-time
	Expiry strfmt.DateTime `json:"expiry,omitempty"`

	// fair basis
	FairBasis float64 `json:"fairBasis,omitempty"`

	// fair basis rate
	FairBasisRate float64 `json:"fairBasisRate,omitempty"`

	// fair method
	FairMethod string `json:"fairMethod,omitempty"`

	// fair price
	FairPrice float64 `json:"fairPrice,omitempty"`

	// front
	// Format: date-time
	Front strfmt.DateTime `json:"front,omitempty"`

	// funding base symbol
	FundingBaseSymbol string `json:"fundingBaseSymbol,omitempty"`

	// funding interval
	// Format: date-time
	FundingInterval strfmt.DateTime `json:"fundingInterval,omitempty"`

	// funding premium symbol
	FundingPremiumSymbol string `json:"fundingPremiumSymbol,omitempty"`

	// funding quote symbol
	FundingQuoteSymbol string `json:"fundingQuoteSymbol,omitempty"`

	// funding rate
	FundingRate float64 `json:"fundingRate,omitempty"`

	// funding timestamp
	// Format: date-time
	FundingTimestamp strfmt.DateTime `json:"fundingTimestamp,omitempty"`

	// has liquidity
	HasLiquidity bool `json:"hasLiquidity,omitempty"`

	// high price
	HighPrice float64 `json:"highPrice,omitempty"`

	// impact ask price
	ImpactAskPrice float64 `json:"impactAskPrice,omitempty"`

	// impact bid price
	ImpactBidPrice float64 `json:"impactBidPrice,omitempty"`

	// impact mid price
	ImpactMidPrice float64 `json:"impactMidPrice,omitempty"`

	// indicative funding rate
	IndicativeFundingRate float64 `json:"indicativeFundingRate,omitempty"`

	// indicative settle price
	IndicativeSettlePrice float64 `json:"indicativeSettlePrice,omitempty"`

	// indicative tax rate
	IndicativeTaxRate float64 `json:"indicativeTaxRate,omitempty"`

	// init margin
	InitMargin float64 `json:"initMargin,omitempty"`

	// insurance fee
	InsuranceFee float64 `json:"insuranceFee,omitempty"`

	// inverse leg
	InverseLeg string `json:"inverseLeg,omitempty"`

	// is inverse
	IsInverse bool `json:"isInverse,omitempty"`

	// is quanto
	IsQuanto bool `json:"isQuanto,omitempty"`

	// last change pcnt
	LastChangePcnt float64 `json:"lastChangePcnt,omitempty"`

	// last price
	LastPrice float64 `json:"lastPrice,omitempty"`

	// last price protected
	LastPriceProtected float64 `json:"lastPriceProtected,omitempty"`

	// last tick direction
	LastTickDirection string `json:"lastTickDirection,omitempty"`

	// limit
	Limit float64 `json:"limit,omitempty"`

	// limit down price
	LimitDownPrice float64 `json:"limitDownPrice,omitempty"`

	// limit up price
	LimitUpPrice float64 `json:"limitUpPrice,omitempty"`

	// listing
	// Format: date-time
	Listing strfmt.DateTime `json:"listing,omitempty"`

	// lot size
	LotSize int64 `json:"lotSize,omitempty"`

	// low price
	LowPrice float64 `json:"lowPrice,omitempty"`

	// maint margin
	MaintMargin float64 `json:"maintMargin,omitempty"`

	// maker fee
	MakerFee float64 `json:"makerFee,omitempty"`

	// mark method
	MarkMethod string `json:"markMethod,omitempty"`

	// mark price
	MarkPrice float64 `json:"markPrice,omitempty"`

	// max order qty
	MaxOrderQty int64 `json:"maxOrderQty,omitempty"`

	// max price
	MaxPrice float64 `json:"maxPrice,omitempty"`

	// mid price
	MidPrice float64 `json:"midPrice,omitempty"`

	// multiplier
	Multiplier int64 `json:"multiplier,omitempty"`

	// open interest
	OpenInterest int64 `json:"openInterest,omitempty"`

	// open value
	OpenValue int64 `json:"openValue,omitempty"`

	// opening timestamp
	// Format: date-time
	OpeningTimestamp strfmt.DateTime `json:"openingTimestamp,omitempty"`

	// option multiplier
	OptionMultiplier float64 `json:"optionMultiplier,omitempty"`

	// option strike pcnt
	OptionStrikePcnt float64 `json:"optionStrikePcnt,omitempty"`

	// option strike price
	OptionStrikePrice float64 `json:"optionStrikePrice,omitempty"`

	// option strike round
	OptionStrikeRound float64 `json:"optionStrikeRound,omitempty"`

	// option underlying price
	OptionUnderlyingPrice float64 `json:"optionUnderlyingPrice,omitempty"`

	// position currency
	PositionCurrency string `json:"positionCurrency,omitempty"`

	// prev close price
	PrevClosePrice float64 `json:"prevClosePrice,omitempty"`

	// prev price24h
	PrevPrice24h float64 `json:"prevPrice24h,omitempty"`

	// prev total turnover
	PrevTotalTurnover int64 `json:"prevTotalTurnover,omitempty"`

	// prev total volume
	PrevTotalVolume int64 `json:"prevTotalVolume,omitempty"`

	// publish interval
	// Format: date-time
	PublishInterval strfmt.DateTime `json:"publishInterval,omitempty"`

	// publish time
	// Format: date-time
	PublishTime strfmt.DateTime `json:"publishTime,omitempty"`

	// quote currency
	QuoteCurrency string `json:"quoteCurrency,omitempty"`

	// quote to settle multiplier
	QuoteToSettleMultiplier int64 `json:"quoteToSettleMultiplier,omitempty"`

	// rebalance interval
	// Format: date-time
	RebalanceInterval strfmt.DateTime `json:"rebalanceInterval,omitempty"`

	// rebalance timestamp
	// Format: date-time
	RebalanceTimestamp strfmt.DateTime `json:"rebalanceTimestamp,omitempty"`

	// reference
	Reference string `json:"reference,omitempty"`

	// reference symbol
	ReferenceSymbol string `json:"referenceSymbol,omitempty"`

	// relist interval
	// Format: date-time
	RelistInterval strfmt.DateTime `json:"relistInterval,omitempty"`

	// risk limit
	RiskLimit int64 `json:"riskLimit,omitempty"`

	// risk step
	RiskStep int64 `json:"riskStep,omitempty"`

	// root symbol
	RootSymbol string `json:"rootSymbol,omitempty"`

	// sell leg
	SellLeg string `json:"sellLeg,omitempty"`

	// session interval
	// Format: date-time
	SessionInterval strfmt.DateTime `json:"sessionInterval,omitempty"`

	// settl currency
	SettlCurrency string `json:"settlCurrency,omitempty"`

	// settle
	// Format: date-time
	Settle strfmt.DateTime `json:"settle,omitempty"`

	// settled price
	SettledPrice float64 `json:"settledPrice,omitempty"`

	// settlement fee
	SettlementFee float64 `json:"settlementFee,omitempty"`

	// state
	State string `json:"state,omitempty"`

	// symbol
	// Required: true
	Symbol *string `json:"symbol"`

	// taker fee
	TakerFee float64 `json:"takerFee,omitempty"`

	// taxed
	Taxed bool `json:"taxed,omitempty"`

	// tick size
	TickSize float64 `json:"tickSize,omitempty"`

	// timestamp
	// Format: date-time
	Timestamp strfmt.DateTime `json:"timestamp,omitempty"`

	// total turnover
	TotalTurnover int64 `json:"totalTurnover,omitempty"`

	// total volume
	TotalVolume int64 `json:"totalVolume,omitempty"`

	// turnover
	Turnover int64 `json:"turnover,omitempty"`

	// turnover24h
	Turnover24h int64 `json:"turnover24h,omitempty"`

	// typ
	Typ string `json:"typ,omitempty"`

	// underlying
	Underlying string `json:"underlying,omitempty"`

	// underlying symbol
	UnderlyingSymbol string `json:"underlyingSymbol,omitempty"`

	// underlying to position multiplier
	UnderlyingToPositionMultiplier int64 `json:"underlyingToPositionMultiplier,omitempty"`

	// underlying to settle multiplier
	UnderlyingToSettleMultiplier int64 `json:"underlyingToSettleMultiplier,omitempty"`

	// volume
	Volume int64 `json:"volume,omitempty"`

	// volume24h
	Volume24h int64 `json:"volume24h,omitempty"`

	// vwap
	Vwap float64 `json:"vwap,omitempty"`
}

// Validate validates this instrument
func (m *Instrument) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateCalcInterval(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateClosingTimestamp(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateExpiry(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateFront(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateFundingInterval(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateFundingTimestamp(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateListing(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateOpeningTimestamp(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePublishInterval(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePublishTime(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateRebalanceInterval(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateRebalanceTimestamp(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateRelistInterval(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSessionInterval(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSettle(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSymbol(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTimestamp(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *Instrument) validateCalcInterval(formats strfmt.Registry) error {

	if swag.IsZero(m.CalcInterval) { // not required
		return nil
	}

	if err := validate.FormatOf("calcInterval", "body", "date-time", m.CalcInterval.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateClosingTimestamp(formats strfmt.Registry) error {

	if swag.IsZero(m.ClosingTimestamp) { // not required
		return nil
	}

	if err := validate.FormatOf("closingTimestamp", "body", "date-time", m.ClosingTimestamp.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateExpiry(formats strfmt.Registry) error {

	if swag.IsZero(m.Expiry) { // not required
		return nil
	}

	if err := validate.FormatOf("expiry", "body", "date-time", m.Expiry.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateFront(formats strfmt.Registry) error {

	if swag.IsZero(m.Front) { // not required
		return nil
	}

	if err := validate.FormatOf("front", "body", "date-time", m.Front.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateFundingInterval(formats strfmt.Registry) error {

	if swag.IsZero(m.FundingInterval) { // not required
		return nil
	}

	if err := validate.FormatOf("fundingInterval", "body", "date-time", m.FundingInterval.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateFundingTimestamp(formats strfmt.Registry) error {

	if swag.IsZero(m.FundingTimestamp) { // not required
		return nil
	}

	if err := validate.FormatOf("fundingTimestamp", "body", "date-time", m.FundingTimestamp.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateListing(formats strfmt.Registry) error {

	if swag.IsZero(m.Listing) { // not required
		return nil
	}

	if err := validate.FormatOf("listing", "body", "date-time", m.Listing.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateOpeningTimestamp(formats strfmt.Registry) error {

	if swag.IsZero(m.OpeningTimestamp) { // not required
		return nil
	}

	if err := validate.FormatOf("openingTimestamp", "body", "date-time", m.OpeningTimestamp.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validatePublishInterval(formats strfmt.Registry) error {

	if swag.IsZero(m.PublishInterval) { // not required
		return nil
	}

	if err := validate.FormatOf("publishInterval", "body", "date-time", m.PublishInterval.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validatePublishTime(formats strfmt.Registry) error {

	if swag.IsZero(m.PublishTime) { // not required
		return nil
	}

	if err := validate.FormatOf("publishTime", "body", "date-time", m.PublishTime.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateRebalanceInterval(formats strfmt.Registry) error {

	if swag.IsZero(m.RebalanceInterval) { // not required
		return nil
	}

	if err := validate.FormatOf("rebalanceInterval", "body", "date-time", m.RebalanceInterval.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateRebalanceTimestamp(formats strfmt.Registry) error {

	if swag.IsZero(m.RebalanceTimestamp) { // not required
		return nil
	}

	if err := validate.FormatOf("rebalanceTimestamp", "body", "date-time", m.RebalanceTimestamp.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateRelistInterval(formats strfmt.Registry) error {

	if swag.IsZero(m.RelistInterval) { // not required
		return nil
	}

	if err := validate.FormatOf("relistInterval", "body", "date-time", m.RelistInterval.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateSessionInterval(formats strfmt.Registry) error {

	if swag.IsZero(m.SessionInterval) { // not required
		return nil
	}

	if err := validate.FormatOf("sessionInterval", "body", "date-time", m.SessionInterval.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateSettle(formats strfmt.Registry) error {

	if swag.IsZero(m.Settle) { // not required
		return nil
	}

	if err := validate.FormatOf("settle", "body", "date-time", m.Settle.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateSymbol(formats strfmt.Registry) error {

	if err := validate.Required("symbol", "body", m.Symbol); err != nil {
		return err
	}

	return nil
}

func (m *Instrument) validateTimestamp(formats strfmt.Registry) error {

	if swag.IsZero(m.Timestamp) { // not required
		return nil
	}

	if err := validate.FormatOf("timestamp", "body", "date-time", m.Timestamp.String(), formats); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *Instrument) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *Instrument) UnmarshalBinary(b []byte) error {
	var res Instrument
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

repository: adampointer/go-bitmex

repo_name: adampointer/go-bitmex

gha_language: Go


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:
#   Black_Pearl_5.lv2/License.pdf
#   AVL_Drumkits_Perc.lv2/License.pdf
#   Red_Zeppelin_4.lv2/License.pdf
#   Black_Pearl_4B.lv2/License.pdf
#   Black_Pearl_4A.lv2/License.pdf
#   Red_Zeppelin_5.lv2/License.pdf
SUMMARY = "FluidPlug - SoundFonts as LV2 plugins via FluidSynth"
SECTION = "multimedia"
LICENSE = "CC-BY-SA-3.0"
LIC_FILES_CHKSUM = " \
		    file://Black_Pearl_5.lv2/License.pdf;md5=db54d5d5fcba6e9ca3f61185eec10a43 \
                    file://AVL_Drumkits_Perc.lv2/License.pdf;md5=db54d5d5fcba6e9ca3f61185eec10a43 \
                    file://Red_Zeppelin_4.lv2/License.pdf;md5=db54d5d5fcba6e9ca3f61185eec10a43 \
                    file://Black_Pearl_4B.lv2/License.pdf;md5=db54d5d5fcba6e9ca3f61185eec10a43 \
                    file://Black_Pearl_4A.lv2/License.pdf;md5=db54d5d5fcba6e9ca3f61185eec10a43 \
                    file://Red_Zeppelin_5.lv2/License.pdf;md5=db54d5d5fcba6e9ca3f61185eec10a43 \
"

SRC_URI = "git://github.com/falkTX/FluidPlug;protocol=https"

PV = "1.0+git${SRCPV}"

SRCREV = "8457f1036c5f7d4437febe2a4ea4f0ad263e0f88"

S = "${WORKDIR}/git"

FILES_${PN} = "${libdir}/lv2"

inherit pkgconfig

DEPENDS = "lv2 fluidsynth p7zip-native"

EXTRA_OEMAKE = " DESTDIR=${D} LINK_OPTS= "

do_compile () {
	export GUI_LDFLAGS="${LDFLAGS}"
	oe_runmake BASE_OPTS="-O2 -ffast-math -fdata-sections -ffunction-sections" STRIP=echo
}

do_install () {
	oe_runmake install ${EXTRA_OEMAKE}
}

repository: Rezzonics/meta-pedalpi

repo_name: Rezzonics/meta-pedalpi


text:
SUMMARY     = "AGL Launcher Application"
DESCRIPTION = "AGL Launcher Application build with recipe method"
HOMEPAGE    = "https://gerrit.automotivelinux.org/gerrit/apps/launcher"
SECTION     = "apps"
LICENSE     = "Apache-2.0"
LIC_FILES_CHKSUM = "file://launcher/LICENSE;md5=ae6497158920d9524cf208c09cc4c984"

DEPENDS = "\
        qtbase \
        qtdeclarative \
        qtquickcontrols2 \
        qtwebsockets \
        qlibwindowmanager \
        qlibhomescreen \
"

inherit qmake5 systemd pkgconfig aglwgt

SRC_URI = "git://gerrit.automotivelinux.org/gerrit/apps/launcher;protocol=https;branch=${AGL_BRANCH}"
SRCREV  = "${AGL_APP_REVISION}"

PV      = "1.0+git${SRCPV}"
S       = "${WORKDIR}/git/"

PATH_prepend = "${STAGING_DIR_NATIVE}${OE_QMAKE_PATH_QT_BINS}:"

repository: EvgeniiDidin/meta-agl-devel

repo_name: EvgeniiDidin/meta-agl-devel


text:
@article{ISI:000183729600013,
Author = {Savvides, A and Park, H and Srivastava, MB},
Title = {{The n-hop multilateration primitive for node localization problems}},
Journal = {{MOBILE NETWORKS \& APPLICATIONS}},
Year = {{2003}},
Volume = {{8}},
Number = {{4}},
Pages = {{443-451}},
Month = {{AUG}},
Note = {{1st International Workshop on Wireless Sensor Networks and Applications
   (WSNA 2002), ATLANTA, GA, SEP 28, 2002}},
Abstract = {{The recent advances in MEMS, embedded systems and wireless communication
   technologies are making the realization and deployment of networked
   wireless microsensors a tangible task. In this paper we study node
   localization, a component technology that would enhance the
   effectiveness and capabilities of this new class of networks. The n-hop
   multilateration primitive presented here, enables ad-hoc deployed sensor
   nodes to accurately estimate their locations by using known beacon
   locations that are several hops away and distance measurements to
   neighboring nodes. To prevent error accumulation in the network, node
   locations are computed by setting up and solving a global non-linear
   optimization problem. The solution is presented in two computation
   models, centralized and a fully distributed approximation of the
   centralized model. Our simulation results show that using the fully
   distributed model, resource constrained sensor nodes can collectively
   solve a large non-linear optimization problem that none of the nodes can
   solve individually. This approach results in significant savings in
   computation and communication, that allows fine-grained localization to
   run on a low cost sensor node we have developed.}},
Publisher = {{SPRINGER}},
Address = {{233 SPRING ST, NEW YORK, NY 10013 USA}},
Type = {{Article; Proceedings Paper}},
Language = {{English}},
Affiliation = {{Savvides, A (Reprint Author), Univ Calif Los Angeles, Dept Elect Engn, Networked \& Embedded Syst Lab, 6731-H Boelter Hall,Box 951594, Los Angeles, CA 90095 USA.
   Univ Calif Los Angeles, Dept Elect Engn, Networked \& Embedded Syst Lab, Los Angeles, CA 90095 USA.}},
DOI = {{10.1023/A:1024544032357}},
ISSN = {{1383-469X}},
EISSN = {{1572-8153}},
Keywords = {{ad-hoc localization; distributed localization; sensor networks}},
Research-Areas = {{Computer Science; Telecommunications}},
Web-of-Science-Categories  = {{Computer Science, Hardware \& Architecture; Computer Science,
   Information Systems; Telecommunications}},
Author-Email = {{asavvide@ee.ucla.edu
   hmpark@ee.ucla.edu
   mbs@ee.ucla.edu}},
Number-of-Cited-References = {{21}},
Times-Cited = {{102}},
Usage-Count-Last-180-days = {{1}},
Usage-Count-Since-2013 = {{9}},
Journal-ISO = {{Mobile Netw. Appl.}},
Doc-Delivery-Number = {{693QJ}},
Unique-ID = {{ISI:000183729600013}},
DA = {{2019-01-21}},
}
@ARTICLE{ISI:01,
  author =       {Norgaard, R.},
  title =        {Ecosystem services: From eye-opening metaphor to complexity blinder},
  journal =      {Ecological Economics},
  year =         {2010},
  volume =       {69},
  number =       {6},
  pages =        {{1219-1227}},
  month =        {4},
}
@ARTICLE{ISI:02,
  author =       {Chee,Y.},
  title =        {An ecological perspective on the valuation of ecosystem services.},
  journal =      {Biological Conservation},
  year =         {2004},
  volume =       {120},
  number =       {6},
  pages =        {549-565},
  month =        {3}
}
@ARTICLE{ISI:03,
  author =       {Guo Dongxu, Hou Falin},
  title =        {Evaluation Method for Operational Availability of Self-propelled Mine Based on Expert Scoring Method},
  journal =      {Digital Ocean and Underwater Warfare},
  year =         {2018},
  volume =       {1},
  number =       {3},
  pages =        {41-44},
  month =        {12}
}
@ARTICLE{ISI:04,
  author =       {He Deju, Fang Jinwu},
  title =        {Market valuation method in the application of environment economic efficiency analysis},
  journal =      {Journal of Anhui Polytechnic University},
  year =         {2008},
  volume =       {24},
  number =       {3},
  pages =        {68-70},
  month =        {},
}
@ARTICLE{ISI:05,
  author =       {Han Meiqing, Wang Luguang},
  title =        {Based on shadow engineering method and shadow price method,research on economic loss of water environment pollution in HeBei province
},
  journal =      {China Water Transport},
  year =         {2009},
  volume =       {9},
  number =       {2},
  pages =        {76-78},
  month =        {2}
}
@ARTICLE{ISI:06,
  author =       {Hu Qingling},
  title =        {Evaluation of ecosystem service value of LuYang lake wetland},
  journal =      {Journal of Weinan Normal University},
  year =         {2018},
  volume =       {33},
  number =       {8},
  pages =        {22-27},
  month =        {4},
}
@ARTICLE{ISI:07,
  author =       {Teng Weiling, Li Xiaofang},
  title =        {The profit and loss analysis of expressway environmental economy based on the achievement reference method},
  journal =      {Engineering science and technology},
  year =         {2014},
  volume =       {10},
  number =       {24},
  pages =        {178},
  month =        {8},
}
@ARTICLE{ISI:08,
  author =       {Huang Zaisheng},
  title =        {Analysis on the influencing factors of carbon sink cost benefit based on afforestation cost method},
  journal =      {Resoures Science},
  year =         {2016},
  volume =       {38},
  number =       {3},
  pages =        {485-492},
  month =        {3},
}
@ARTICLE{ISI:09,
  author =       {Song Qing},
  title =        {Optimizing the travel cost method to evaluate the recreation value of Shanghai urban parks},
  journal =      {Planning and Design Theory and Practice},
  year =         {2018},
  volume =       {34},
  number =       {S1},
  pages =        {46-49},
  month =        {}
}
@ARTICLE{ISI:10,
  author =       {Jin Rongxue},
  title =        {Performance evaluation of higher vocational education in China based on AHP and entropy weight method},
  journal =      {The Accounting Issue},
  year =         {2017},
  volume =       {36},
  number =       {8},
  pages =        {59-66},
  month =        {},
}
@ARTICLE{ISI:11,
  author =       {TanXue},
  title =        {Coat analysis of the municipal wasterater treatment plant operation based on 227 samples in China},
  journal =      {Water Wastewater Eng},
  year =         {2015},
  volume =       {41},
  number =       {5},
  pages =        {30-34},
  month =        {},
}
@ARTICLE{ISI:12,
  author =       {Shao Xuexin},
  title =        {Nutrient retention in plant biomass and sediments from the salt marsh in Hangzhou Bay estuary,Chin},
  journal =      {Environ Sci Pollut Res Int},
  year =         {2013},
  volume =       {20},
  number =       {9},
  pages =        {6382-6391},
  month =        {},
}
@ARTICLE{ISI:13,
  author =       {Li Nan},
  title =        {Changes in the value of ecosystem services for wet land in hangzhou bay},
  journal =      {Journal of Zhejiang  Agriculture  and  Forestry University},
  year =         {2019},
  volume =       {36},
  number =       {1},
  pages =        {118-129},
  month =        {1},
}


text:
@article{2015thiry,
 abstract = {In this work, we report on the Kirkendall-induced hollowing process occurring upon thermal oxidation of gold?copper (Au?Cu) alloy nanowires and nanodots. Contrary to elemental metals, the oxidation reaction results in the formation of gold nanostructures trapped inside hollow copper oxide nanoshells. We particularly focus on the thermally activated reshaping mechanism of the gold phase forming the core. Using scanning transmission electron microscopy coupled to energy dispersive X-ray spectroscopy mapping, we show that such a reshaping is a consequence to the reorganization of gold at the atomic level. The gold nanostructures forming the core were found to be strongly dependent on the chemical composition of the alloy and the oxidation temperature. By selecting the appropriate annealing conditions (i.e., duration, temperature), one can easily synthesize various heteronanostructures: wire-in-tube, yolk?shell, oxide nanotubes embedding or decorated by Au nanospheres. The advanced understanding of the Kirkendall effect in binary alloy nanostructures that we have achieved in this work will open a new door for the fabrication and the design of novel multifunctional heteronanostructures for potential applications in different research fields including nano-optics/photonics, biomedicine, and catalysis.},
 author = {Damien Thiry and Leopoldo Molina-Luna and Eric Gautron and Nicolas Stephant and Adrien Chauvin and Ke Du and Junjun Ding and Chang-Hwan Choi and Pierre-Yves Tessier and Abdel-Aziz El Mel},
 date = {2015-01-01},
 doi = {10.1021/acs.chemmater.5b02391},
 journal = {Chemistry of Materials},
 keywords = {nanomanufacturing},
 number = {18},
 pages = {6374-6384},
 pubstate = {published},
 title = {The Kirkendall Effect in Binary Alloys: Trapping Gold in Copper Oxide Nanoshells},
 tppubtype = {article},
 url = {http://dx.doi.org/10.1021/acs.chemmater.5b02391},
 volume = {27},
 year = {2015}
}

repository: JunjunDing/jding-academic-kickstart

repo_name: JunjunDing/jding-academic-kickstart


text:
package policy

import (
	"context"

	"capact.io/capact/pkg/engine/k8s/policy"
	apierrors "k8s.io/apimachinery/pkg/api/errors"

	"github.com/pkg/errors"
	"go.uber.org/zap"
	corev1 "k8s.io/api/core/v1"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

const policyConfigMapKey = "cluster-policy.yaml"

// Service provides functionality to manage Capact Policy configuration.
type Service struct {
	log          *zap.Logger
	k8sCli       client.Client
	policyObjKey client.ObjectKey
}

// NewService returns a new Service instance.
func NewService(log *zap.Logger, actionCli client.Client, cfg Config) *Service {
	return &Service{
		log:    log.With(zap.String("module", "policyService")),
		k8sCli: actionCli,
		policyObjKey: client.ObjectKey{
			Namespace: cfg.Namespace,
			Name:      cfg.Name,
		},
	}
}

// Get returns current Capact Policy configuration.
func (s *Service) Get(ctx context.Context) (policy.Policy, error) {
	cfgMap, err := s.getConfigMap(ctx)
	if err != nil {
		return policy.Policy{}, err
	}

	p, err := policy.FromYAMLString(cfgMap.Data[policyConfigMapKey])
	if err != nil {
		return policy.Policy{},
			errors.Wrapf(err, "while unmarshaling policy from ConfigMap '%s/%s' from %q key",
				s.policyObjKey.Namespace,
				s.policyObjKey.Name,
				policyConfigMapKey,
			)
	}

	return p, nil
}

// Update updates current Capact Policy configuration with a given input.
func (s *Service) Update(ctx context.Context, in policy.Policy) (policy.Policy, error) {
	cfgMap, err := s.getConfigMap(ctx)
	if err != nil {
		return policy.Policy{}, err
	}

	policyStr, err := in.ToYAMLString()
	if err != nil {
		return policy.Policy{}, errors.Wrap(err, "while marshaling Policy")
	}

	cfgMap.Data[policyConfigMapKey] = policyStr

	s.log.Info("Updating Policy")
	err = s.k8sCli.Update(ctx, cfgMap)
	if err != nil {
		errContext := "while updating Policy ConfigMap"
		s.log.Error(errContext, zap.Error(err))
		return policy.Policy{}, errors.Wrap(err, errContext)
	}

	return in, nil
}

func (s *Service) getConfigMap(ctx context.Context) (*corev1.ConfigMap, error) {
	s.log.Info("Getting Policy")

	policyCfgMap := &corev1.ConfigMap{}

	err := s.k8sCli.Get(ctx, s.policyObjKey, policyCfgMap)
	if err != nil {
		errContext := "while getting ConfigMap from K8s"
		switch {
		case apierrors.IsNotFound(err):
			s.log.Debug(errContext, zap.Error(ErrPolicyConfigMapNotFound))
			return nil, errors.Wrap(ErrPolicyConfigMapNotFound, errContext)
		default:
			s.log.Error(errContext, zap.Error(err))
			return nil, errors.Wrap(err, errContext)
		}
	}

	return policyCfgMap, nil
}


text:
SUMMARY = "SPDM Emulator"
DESCRIPTION = "DMTF SPDM emulator"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE.md;md5=cd2c281a3048799e5ed6d1ad8be1ebe1"

inherit cmake

EXTRA_OECMAKE = "-DARCH=aarch64 -DTOOLCHAIN=YOCTO -DTARGET=Release -DCRYPTO=mbedtls"
#EXTRA_OECMAKE = "-DARCH=aarch64 -DTOOLCHAIN=YOCTO -DTARGET=Release -DCRYPTO=openssl"
SRCREV = "c8ac4ca68137127596ff59d065bfaa046718a56b"

PV = "1.0+git${SRCPV}"
PR = "r1"
S = "${WORKDIR}/git"
KEY_DIR = "${S}/libspdm/unit_test/sample_key"
FILES:${PN}:append = " ${datadir}/spdm-emu"

SRC_URI = "gitsm://github.com/DMTF/spdm-emu;protocol=https;branch=main \
           file://0001-support-yocto-build.patch \
           file://0002-use-spdm-over-mctp-kernel-socket.patch \
           file://0003-libspdm-openssl-support-hwaes.patch;patchdir=libspdm \
           "

do_install:append () {
	install -d ${D}${datadir}/spdm-emu
	cp -r ${KEY_DIR}/ecp384 ${D}${datadir}/spdm-emu/
	cp -r ${KEY_DIR}/rsa3072 ${D}${datadir}/spdm-emu/
}

repository: Nuvoton-Israel/openbmc

repo_name: Nuvoton-Israel/openbmc

branch_name: refs/heads/npcm-master

gha_license_id: NOASSERTION

gha_language: Python


text:
package authz

import (
	"fmt"

	authzv1beta1 "cosmossdk.io/api/cosmos/authz/v1beta1"
	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"

	"github.com/cosmos/cosmos-sdk/version"
	bank "github.com/cosmos/cosmos-sdk/x/bank/types"
)

// AutoCLIOptions implements the autocli.HasAutoCLIConfig interface.
func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions {
	return &autocliv1.ModuleOptions{
		Query: &autocliv1.ServiceCommandDescriptor{
			Service: authzv1beta1.Query_ServiceDesc.ServiceName,
			RpcCommandOptions: []*autocliv1.RpcCommandOptions{
				{
					RpcMethod: "Grants",
					Use:       "grants [granter-addr] [grantee-addr] <msg-type-url>",
					Short:     "Query grants for a granter-grantee pair and optionally a msg-type-url",
					Long:      "Query authorization grants for a granter-grantee pair. If msg-type-url is set, it will select grants only for that msg type.",
					Example:   fmt.Sprintf("%s query authz grants cosmos1skj.. cosmos1skjwj.. %s", version.AppName, bank.SendAuthorization{}.MsgTypeURL()),
					PositionalArgs: []*autocliv1.PositionalArgDescriptor{
						{ProtoField: "granter"},
						{ProtoField: "grantee"},
						{ProtoField: "msg_type_url", Optional: true},
					},
				},
				{
					RpcMethod: "GranterGrants",
					Use:       "grants-by-granter [granter-addr]",
					Short:     "Query authorization grants granted by granter",
					PositionalArgs: []*autocliv1.PositionalArgDescriptor{
						{ProtoField: "granter"},
					},
				},
				{
					RpcMethod: "GranteeGrants",
					Use:       "grants-by-grantee [grantee-addr]",
					Short:     "Query authorization grants granted to a grantee",
					PositionalArgs: []*autocliv1.PositionalArgDescriptor{
						{ProtoField: "grantee"},
					},
				},
			},
		},
		Tx: &autocliv1.ServiceCommandDescriptor{
			Service: authzv1beta1.Msg_ServiceDesc.ServiceName,
		},
	}
}

repository: cosmos/cosmos-sdk

repo_name: cosmos/cosmos-sdk