text:
@inproceedings{pytorch,
      title = {{PyTorch: An Imperative Style, High-Performance Deep Learning Library}},
     author = {Paszke, Adam and Gross, Sam and Massa, Francisco and Lerer, Adam and Bradbury, James and Chanan, Gregory and Killeen, Trevor and Lin, Zeming and Gimelshein, Natalia and Antiga, Luca and Desmaison, Alban and Kopf, Andreas and Yang, Edward and DeVito, Zachary and Raison, Martin and Tejani, Alykhan and Chilamkurthy, Sasank and Steiner, Benoit and Fang, Lu and Bai, Junjie and Chintala, Soumith},
     editor = {H. Wallach and H. Larochelle and A. Beygelzimer and F. d\textquotesingle Alch\'{e}-Buc and E. Fox and R. Garnett},
  booktitle = {{Advances in Neural Information Processing Systems}},
   location = {{Vancouver, BC, Canada}},
  articleno = {721},
   numpages = {12},
     volume = {32},
      pages = {8024--8035},
       year = {2019},
  publisher = {{Curran Associates, Inc.}},
    address = {{Red Hook, NY, USA}}
}
@article{torch_ecg_paper,
      title = {{A Novel Deep Learning Package for Electrocardiography Research}},
     author = {Hao Wen and Jingsu Kang},
    journal = {{Physiological Measurement}},
        doi = {10.1088/1361-6579/ac9451},
       year = {2022},
      month = {11},
  publisher = {{IOP Publishing}},
     volume = {43},
     number = {11},
      pages = {115006}
}
@article{Kang_2022_cinc2021_iop,
      title = {{A Study on Several Critical Problems on Arrhythmia Detection using Varying-Dimensional Electrocardiography}},
     author = {Jingsu Kang and Hao Wen},
    journal = {{Physiological Measurement}},
        doi = {10.1088/1361-6579/ac6aa3},
       year = {2022},
      month = {6},
  publisher = {{IOP Publishing}},
     volume = {43},
     number = {6},
      pages = {064007}
}
@inproceedings{resnet,
      title = {{Deep Residual Learning for Image Recognition}},
     author = {He, Kaiming and Zhang, Xiangyu and Ren, Shaoqing and Sun, Jian},
  booktitle = {{2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}},
      pages = {770--778},
       year = {2016},
      month = {6},
  publisher = {{Institute of Electrical and Electronics Engineers (IEEE)}},
        doi = {10.1109/cvpr.2016.90}
}
@article{awni2019stanford_ecg,
      title = {{Cardiologist-Level Arrhythmia Detection and Classification in Ambulatory Electrocardiograms using a Deep Neural Network}},
     author = {Hannun, Awni Y and Rajpurkar, Pranav and Haghpanahi, Masoumeh and Tison, Geoffrey H and Bourn, Codie and Turakhia, Mintu P and Ng, Andrew Y},
    journal = {{Nature Medicine}},
        doi = {10.1038/s41591-018-0268-3},
       year = {2019},
      month = {1},
  publisher = {{Springer Science and Business Media LLC}},
     volume = {25},
     number = {1},
      pages = {65--69}
}
@article{cai2020rpeak_seq_lab_net,
      title = {{QRS Complex Detection using Novel Deep Learning Neural Networks}},
     author = {Cai, Wenjie and Hu, Danqin},
    journal = {{IEEE Access}},
     volume = {8},
        doi = {10.1109/access.2020.2997473},
      pages = {97082--97089},
       year = {2020},
  publisher = {{Institute of Electrical and Electronics Engineers (IEEE)}}
}
@article{hu2020senet,
     title = {{Squeeze-and-Excitation Networks}},
    author = {Jie Hu and Li Shen and Samuel Albanie and Gang Sun and Enhua Wu},
   journal = {{IEEE Transactions on Pattern Analysis and Machine Intelligence}},
      year = {2020},
    volume = {42},
    number = {8},
     pages = {2011-2023},
 publisher = {{Institute of Electrical and Electronics Engineers (IEEE)}},
       doi = {10.1109/tpami.2019.2913372}
}


text:
@inproceedings{naicken2006p2psimsurvey,
 abstract = {As scientists, our research must be tested and evaluated in order for it to be shown to be valid. Part of this process includes providing reproducible results so that peers are able to confirm any findings. The techniques used to achieve this include analytical solutions, simulators and experiments with the actual system, however in the area of Peer-to-Peer (P2P) computing, this gives rise to a number of challenges. In this paper, we focus on P2P simulators by surveying a number of P2P simulators with respect to important criteria when simulating a P2P system. Simulators are compared, usage experiences are given and limitations are discussed. The survey shows that while there are a plethora of simulators, there are many issues such as poor scalability, little or no documentation, steep learning curves, and system limitations that makes using these simulators a convoluted process.},
 address = {Liverpool, UK},
 author = {Naicken, Stephen and Basu, Anirban and Livingston, Barnaby and Rodhetbhai, Sethalat},
 booktitle = {Proceedings of the Annual Postgraduate Symposium (PGNet)},
 title = {A Survey of Peer-to-Peer Network Simulators},
 url = {?doi=10.1.1.136.7073&rep=rep1&type=pdf},
 volume = {2},
 year = {2006}
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: TeX

extension: bib


text:
// nolint: unused
package gocb

import (
	"context"
	"time"
)

type bulkOp struct {
	finishFn func()
}

func (op *bulkOp) finish() {
	op.finishFn()
}

// BulkOp represents a single operation that can be submitted (within a list of more operations) to .Do()
// You can create a bulk operation by instantiating one of the implementations of BulkOp,
// such as GetOp, UpsertOp, ReplaceOp, and more.
// UNCOMMITTED: This API may change in the future.
type BulkOp interface {
	isBulkOp()
	finish()
}

// BulkOpOptions are the set of options available when performing BulkOps using Do.
type BulkOpOptions struct {
	Timeout       time.Duration
	Transcoder    Transcoder
	RetryStrategy RetryStrategy
	ParentSpan    RequestSpan

	// Using a deadlined Context alongside a Timeout will cause the shorter of the two to cause cancellation, this
	// also applies to global level timeouts.
	// UNCOMMITTED: This API may change in the future.
	Context context.Context
}

// Do execute one or more `BulkOp` items in parallel.
// UNCOMMITTED: This API may change in the future.
func (c *Collection) Do(ops []BulkOp, opts *BulkOpOptions) error {
	if opts == nil {
		opts = &BulkOpOptions{}
	}

	agent, err := c.getKvBulkProvider()
	if err != nil {
		return err
	}

	return agent.Do(c, ops, opts)
}

// GetOp represents a type of `BulkOp` used for Get operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type GetOp struct {
	bulkOp

	ID     string
	Result *GetResult
	Err    error
}

func (item *GetOp) isBulkOp() {}

// GetAndTouchOp represents a type of `BulkOp` used for GetAndTouch operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type GetAndTouchOp struct {
	bulkOp

	ID     string
	Expiry time.Duration
	Result *GetResult
	Err    error
}

func (item *GetAndTouchOp) isBulkOp() {}

// TouchOp represents a type of `BulkOp` used for Touch operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type TouchOp struct {
	bulkOp

	ID     string
	Expiry time.Duration
	Result *MutationResult
	Err    error
}

func (item *TouchOp) isBulkOp() {}

// RemoveOp represents a type of `BulkOp` used for Remove operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type RemoveOp struct {
	bulkOp

	ID     string
	Cas    Cas
	Result *MutationResult
	Err    error
}

func (item *RemoveOp) isBulkOp() {}

// UpsertOp represents a type of `BulkOp` used for Upsert operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type UpsertOp struct {
	bulkOp

	ID     string
	Value  interface{}
	Expiry time.Duration
	Cas    Cas
	Result *MutationResult
	Err    error
}

func (item *UpsertOp) isBulkOp() {}

// InsertOp represents a type of `BulkOp` used for Insert operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type InsertOp struct {
	bulkOp

	ID     string
	Value  interface{}
	Expiry time.Duration
	Result *MutationResult
	Err    error
}

func (item *InsertOp) isBulkOp() {}

// ReplaceOp represents a type of `BulkOp` used for Replace operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type ReplaceOp struct {
	bulkOp

	ID     string
	Value  interface{}
	Expiry time.Duration
	Cas    Cas
	Result *MutationResult
	Err    error
}

func (item *ReplaceOp) isBulkOp() {}

// AppendOp represents a type of `BulkOp` used for Append operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type AppendOp struct {
	bulkOp

	ID     string
	Value  string
	Result *MutationResult
	Err    error
}

func (item *AppendOp) isBulkOp() {}

// PrependOp represents a type of `BulkOp` used for Prepend operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type PrependOp struct {
	bulkOp

	ID     string
	Value  string
	Result *MutationResult
	Err    error
}

func (item *PrependOp) isBulkOp() {}

// IncrementOp represents a type of `BulkOp` used for Increment operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type IncrementOp struct {
	bulkOp

	ID      string
	Delta   int64
	Initial int64
	Expiry  time.Duration

	Result *CounterResult
	Err    error
}

func (item *IncrementOp) isBulkOp() {}

// DecrementOp represents a type of `BulkOp` used for Decrement operations. See BulkOp.
// UNCOMMITTED: This API may change in the future.
type DecrementOp struct {
	bulkOp

	ID      string
	Delta   int64
	Initial int64
	Expiry  time.Duration

	Result *CounterResult
	Err    error
}

func (item *DecrementOp) isBulkOp() {}

repository: couchbase/gocb

repo_name: couchbase/gocb

gha_language: Go

extension: go


text:
@article{kris2019imitation,
  title={Imitation Learning from Imperfect Demonstration},
  author={Wu, Y. and Charoenphakdee, N. and Bao, H. and Tangkaratt, V. and Sugiyama, M.},
  journal={In Proceedings of 36th International Conference on Machine Learning (ICML2019), Proceedings of Machine Learning Research, Long Beach, California, USA, Jun. 9-15, 2019.},
  year={2019},
  order={4},
  arxiv={1901.09387}
}
@article{nontawat2019symloss,
  title={On Symmetric Losses for Learning from Corrupted Labels},
  author={Charoenphakdee, N. and Lee, J. and Sugiyama, M.},
  journal={In Proceedings of 36th International Conference on Machine Learning (ICML2019), Proceedings of Machine Learning Research, Long Beach, California, USA, Jun. 9-15, 2019.},
  year={2019},
  order={3},
  arxiv={1901.09314}
}
@article{charoenphakdee2018positive,
  title={Positive-Unlabeled Classification under Class Prior Shift and Asymmetric Error},
  author={Charoenphakdee, N. and Sugiyama, M.},
  journal={In Proceedings of the SIAM International Conference on Data Mining (SDM2019), Calgary, Alberta, Canada, May 2-4, 2019.},
  year={2019},
  order={2},
  arxiv={1809.07011}
}
@article{kuroki2018unsupervised,
  title={Unsupervised Domain Adaptation Based on Source-guided Discrepancy},
  author={Kuroki, S. and Charoenphakdee, N. and Bao, H. and Honda, J. and Sato, I. and Sugiyama, M.},
  journal={In Proceedings of the Thirty-Third AAAI Conference on Artificial Intelligence (AAAI2019), Honolulu, Hawaii, USA, Jan. 27-Feb. 1, 2019.},
  year={2019},
  order={1},
  arxiv={1809.03839}
}

repository: nolfwin/al-folio

repo_name: nolfwin/al-folio


text:
include(vcpkg_common_functions)

vcpkg_from_github(
    OUT_SOURCE_PATH SOURCE_PATH
    REPO CaptainCrowbar/rs-core-lib
    REF fda88535dff2193e75bb9d306e4aa38a957b2c91
    SHA512 e1842e2d92b5e935a8d867797d26f998cec628b3030077b8694cc3932546efeac81634e7f6d14189248a945fceb329e24aa39cf830384c04c0d67d2aa6255e57
    HEAD_REF master
)

file(INSTALL ${SOURCE_PATH}/rs-core DESTINATION ${CURRENT_PACKAGES_DIR}/include FILES_MATCHING PATTERN "*.hpp")

# Handle copyright
file(INSTALL ${SOURCE_PATH}/LICENSE.txt DESTINATION ${CURRENT_PACKAGES_DIR}/share/rs-core-lib RENAME copyright)

repository: JackBoos/vcpkg

repo_name: JackBoos/vcpkg

gha_license_id: NOASSERTION

extension: cmake


text:
.skin-blue .main-header .logo {
  background-color: #367fa9;
  color: #ffffff;
  border-bottom: 0 solid transparent;
}
.skin-blue .main-header .navbar {
    background-color: #3c8dbc;
}

repository: daywrite/wph

repo_name: daywrite/wph

extension: css


text:
SUMMARY = "Hello world kernel module"
DESCRIPTION = "Hello world kernel module"
LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/BSD-3-Clause;md5=550794465ba0ec5312d6919e203a55f9"
SECTION = "examples"

inherit module

SRC_URI = "file://hello-module.tar.bz2"

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

repository: s-vincent/meta-softwares-sv

repo_name: s-vincent/meta-softwares-sv

extension: bb


text:
@ARTICLE{Cano_SPM19
author={E. {Cano} and D. {FitzGerald} and A. {Liutkus} and M. D. {Plumbley} and F. {Stöter}},
journal={IEEE Signal Processing Magazine},
title={Musical Source Separation: An Introduction},
year={2019},
volume={36},
number={1},
pages={31-40},
keywords={acoustic signal processing;audio signal processing;music;source separation;sound channels;musical source separation;musical audio object;musical instrument;5.1-channel surround sound system;two-channel stereo recording;vocals;compact discs;Music;Harmonic analysis;Multiple signal classification;Instruments;Spectrogram;Power harmonic filters;Source separation},
doi={10.1109/MSP.2018.2874719},
ISSN={1053-5888},
month={Jan},}

repository: ecanoc/academic-kickstart

repo_name: ecanoc/academic-kickstart


text:
SUMMARY = "Expression parser"
HOMEPAGE = "https://github.com/ArashPartow/exprtk"
SECTION = "libs"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"
SRCREV = "f46bffcd6966d38a09023fb37ba9335214c9b959"

SRC_URI = "git://github.com/ArashPartow/exprtk.git;branch=release;protocol=https"

S = "${WORKDIR}/git"

# other packages commonly reference the file directly as "exprtk.hpp"
# create symlink to allow this usage
do_install() {
    install -d ${D}/${includedir}
    install -m 0644 ${S}/exprtk.hpp ${D}/${includedir}/exprtk.hpp
}

# exprtk is a header only C++ library, so the main package will be empty.
RDEPENDS:${PN}-dev = ""

BBCLASSEXTEND = "native nativesdk"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

gha_language: BitBake


text:
require vala.inc
inherit native

DEPENDS = "glib-2.0-native"
# vala from git always needs the latest released version to compile itself
DEPENDS += "vala-bootstrap-native"
PV = "0.6.0-fso1-gitr${SRCREV}"

SRC_URI = "\
  ${FREESMARTPHONE_GIT}/vala-lang;protocol=git;branch=mickey/0.6/posix \
  file://static-dbus-methods.patch;patch=1 \
"
S = "${WORKDIR}/git"


text:
@MISC{dacefit,
    author       = "H. B. Nielsen and S. N. Lophaven and J. S{\o}ndergaard",
    title        = "{DACE} - A Matlab Kriging Toolbox",
    year         = "2002",
    keywords     = "Kriging, function approximation, Matlab toolbox",
    publisher    = "Informatics and Mathematical Modelling, Technical University of Denmark, {DTU}",
    address      = "Richard Petersens Plads, Building 321, {DK-}2800 Kgs. Lyngby",
    url          = "http://www2.imm.dtu.dk/pubdb/p.php?1460",
    abstract     = "{DACE,} Design and Analysis of Computer Experiments, is a Matlab toolbox for working with kriging approximations to computer models."
}

repository: msu-coinlab/pydacefit

repo_name: msu-coinlab/pydacefit


text:
@article{donhauser2018imaging,
  title={Imaging of neural oscillations with embedded inferential and group prevalence statistics},
  author={Donhauser, Peter W and Florin, Esther and Baillet, Sylvain},
  journal={PLoS computational biology},
  volume={14},
  number={2},
  pages={e1005990},
  year={2018},
  publisher={Public Library of Science}
}

repository: pwdonh/starter-academic

repo_name: pwdonh/starter-academic


text:
@article{RN1120,
 author = {Zaman, F. Y. and Nagalingam, V. and Wong, C. and Khu, Y. L. and Teng, H. W. G. and Janardan, J. and Ritchie, E. and Cheng, A. C. and Aung, A. K.},
 doi = {10.1111/imj.14275},
 issn = {1445-5994 (Electronic)
1444-0903 (Linking)},
 journal = {Intern Med J},
 number = {5},
 pages = {662-665},
 title = {Opportunities to improve influenza vaccination rates in general medical inpatients},
 type = {Journal Article},
 url = {https://www.ncbi.nlm.nih.gov/pubmed/31083800},
 volume = {49},
 year = {2019}
}


text:
@misc{Gonz2018,
 author = {Rafael C. Gonzales, Richard E. Woods},
 title = {Digital Image Processing},
pages = {1061--1062},
 year = 2018
}

@misc{Craig2018,
 author = {John Craig},
 title = {Introduction to Robotics Mechanics and Control},
pages = {70--79},
 year = 2018
}

@misc{Ziss2008,
 author = {Richard Hartley, Andrew Zisserman},
 title = {Multiple View Geometry in Computer Vison},
pages = {178--182},
 year = 2008
}

@manual{2014opencv,
    title = {The OpenCV Reference Manual},
    organization = {OpenCV},
    edition = {4.1.1},
    month = {July},
    year = {2019},
    notes = {See \url{http://docs.opencv.org/}}
}

@misc{Robotis2019,
  author = {ROBOTIS-GIT.},
  title = {DynamixelSDK},
  year = {2019},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = "\url{github.com/ROBOTIS-GIT/DynamixelSDK/tree/master/c}",
  commit = {8a53309}
  note = "[Online; accessed 23-Dec-2019]"
}

@ARTICLE{ParkHandEye,
author={F. C. {Park} and B. J. {Martin}},
journal={IEEE Transactions on Robotics and Automation},
title={{Robot sensor calibration: solving AX=XB on the Euclidean group}},
year={1994},
volume={10},
number={5},
pages={717-721},
keywords={calibration;Lie groups;Lie algebras;matrix algebra;minimisation;least squares approximations;robots;detectors;robot sensor calibration;Euclidean group;wrist-mounted robotic sensors;Lie theory;closed-form exact solution;closed-form least squares solution;Robot sensing systems;Calibration;Equations;Robot kinematics;Visualization;Noise measurement;Wrist;Sensor phenomena and characterization;Least squares methods;Robot vision systems},
doi={10.1109/70.326576},
ISSN={2374-958X},
month={Oct},
}


text:
@proceedings{acl-2015-acl-ijcnlp,
    title = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    editor = "Chen, Hsin-Hsi  and
      Markert, Katja",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4000",
    doi = "10.3115/v1/P15-4",
}
@inproceedings{ai-xu-2015-system,
    title = "A System Demonstration of a Framework for Computer Assisted Pronunciation Training",
    author = "Ai, Renlong  and
      Xu, Feiyu",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4001",
    doi = "10.3115/v1/P15-4001",
    pages = "1--6",
}
@inproceedings{bond-etal-2015-imi,
    title = "{IMI} {---} A Multilingual Semantic Annotation Environment",
    author = "Bond, Francis  and
      Morgado da Costa, Lu{\'\i}s  and
      L{\^e}, Tuấn Anh",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4002",
    doi = "10.3115/v1/P15-4002",
    pages = "7--12",
}
@inproceedings{do-dinh-etal-2015-tool,
    title = "In-tool Learning for Selective Manual Annotation in Large Corpora",
    author = "Do Dinh, Erik-L{\^a}n  and
      Eckart de Castilho, Richard  and
      Gurevych, Iryna",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4003",
    doi = "10.3115/v1/P15-4003",
    pages = "13--18",
}
@inproceedings{filice-etal-2015-kelp,
    title = "{K}e{LP}: a Kernel-based Learning Platform for Natural Language Processing",
    author = "Filice, Simone  and
      Castellucci, Giuseppe  and
      Croce, Danilo  and
      Basili, Roberto",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4004",
    doi = "10.3115/v1/P15-4004",
    pages = "19--24",
}
@inproceedings{gartner-etal-2015-multi,
    title = "Multi-modal Visualization and Search for Text and Prosody Annotations",
    author = {G{\"a}rtner, Markus  and
      Schweitzer, Katrin  and
      Eckart, Kerstin  and
      Kuhn, Jonas},
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4005",
    doi = "10.3115/v1/P15-4005",
    pages = "25--30",
}
@inproceedings{habib-van-keulen-2015-need4tweet,
    title = "{NEED}4{T}weet: A Twitterbot for Tweets Named Entity Extraction and Disambiguation",
    author = "Habib, Mena  and
      van Keulen, Maurice",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4006",
    doi = "10.3115/v1/P15-4006",
    pages = "31--36",
}
@inproceedings{heinzerling-strube-2015-visual,
    title = "Visual Error Analysis for Entity Linking",
    author = "Heinzerling, Benjamin  and
      Strube, Michael",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4007",
    doi = "10.3115/v1/P15-4007",
    pages = "37--42",
}
@inproceedings{hennig-etal-2015-web,
    title = "A Web-based Collaborative Evaluation Tool for Automatically Learned Relation Extraction Patterns",
    author = "Hennig, Leonhard  and
      Li, Hong  and
      Krause, Sebastian  and
      Xu, Feiyu  and
      Uszkoreit, Hans",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4008",
    doi = "10.3115/v1/P15-4008",
    pages = "43--48",
}
@inproceedings{ku-etal-2015-dual,
    title = "A Dual-Layer Semantic Role Labeling System",
    author = "Ku, Lun-Wei  and
      Virk, Shafqat Mumtaz  and
      Lee, Yann-Huei",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4009",
    doi = "10.3115/v1/P15-4009",
    pages = "49--54",
}
@inproceedings{lipenkova-2015-system,
    title = "A system for fine-grained aspect-based sentiment analysis of {C}hinese",
    author = "Lipenkova, Janna",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4010",
    doi = "10.3115/v1/P15-4010",
    pages = "55--60",
}
@inproceedings{martschat-etal-2015-plug,
    title = "Plug Latent Structures and Play Coreference Resolution",
    author = "Martschat, Sebastian  and
      Claus, Patrick  and
      Strube, Michael",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4011",
    doi = "10.3115/v1/P15-4011",
    pages = "61--66",
}
@inproceedings{michael-akbik-2015-schnapper,
    title = {{SCHN{\"A}PPER}: A Web Toolkit for Exploratory Relation Extraction},
    author = "Michael, Thilo  and
      Akbik, Alan",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4012",
    doi = "10.3115/v1/P15-4012",
    pages = "67--72",
}
@inproceedings{morgado-da-costa-bond-2015-omwedit,
    title = "{OMWE}dit - The Integrated Open Multilingual {W}ordnet Editing System",
    author = "Morgado da Costa, Lu{\'\i}s  and
      Bond, Francis",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4013",
    doi = "10.3115/v1/P15-4013",
    pages = "73--78",
}
@inproceedings{moschitti-etal-2015-sacry,
    title = "{SACRY}: Syntax-based Automatic Crossword puzzle Resolution s{Y}stem",
    author = "Moschitti, Alessandro  and
      Nicosia, Massimo  and
      Barlacchi, Gianni",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4014",
    doi = "10.3115/v1/P15-4014",
    pages = "79--84",
}
@inproceedings{paetzold-specia-2015-lexenstein,
    title = "{LEX}enstein: A Framework for Lexical Simplification",
    author = "Paetzold, Gustavo  and
      Specia, Lucia",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4015",
    doi = "10.3115/v1/P15-4015",
    pages = "85--90",
}
@inproceedings{pyysalo-etal-2015-sharing,
    title = "Sharing annotations better: {REST}ful Open Annotation",
    author = "Pyysalo, Sampo  and
      Campos, Jorge  and
      Cejuela, Juan Miguel  and
      Ginter, Filip  and
      Hakala, Kai  and
      Li, Chen  and
      Stenetorp, Pontus  and
      Jensen, Lars Juhl",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4016",
    doi = "10.3115/v1/P15-4016",
    pages = "91--96",
}
@inproceedings{piperidis-etal-2015-data,
    title = "A Data Sharing and Annotation Service Infrastructure",
    author = "Piperidis, Stelios  and
      Galanis, Dimitrios  and
      Bakagianni, Juli  and
      Sofianopoulos, Sokratis",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4017",
    doi = "10.3115/v1/P15-4017",
    pages = "97--102",
}
@inproceedings{ruppert-etal-2015-jobimviz,
    title = "{J}o{B}im{V}iz: A Web-based Visualization for Graph-based Distributional Semantic Models",
    author = "Ruppert, Eugen  and
      Kaufmann, Manuel  and
      Riedl, Martin  and
      Biemann, Chris",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4018",
    doi = "10.3115/v1/P15-4018",
    pages = "103--108",
}
@inproceedings{sato-etal-2015-end,
    title = "End-to-end Argument Generation System in Debating",
    author = "Sato, Misa  and
      Yanai, Kohsuke  and
      Miyoshi, Toshinori  and
      Yanase, Toshihiko  and
      Iwayama, Makoto  and
      Sun, Qinghua  and
      Niwa, Yoshiki",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4019",
    doi = "10.3115/v1/P15-4019",
    pages = "109--114",
}
@inproceedings{specia-etal-2015-multi,
    title = "Multi-level Translation Quality Prediction with {Q}u{E}st++",
    author = "Specia, Lucia  and
      Paetzold, Gustavo  and
      Scarton, Carolina",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4020",
    doi = "10.3115/v1/P15-4020",
    pages = "115--120",
}
@inproceedings{steele-specia-2015-wa,
    title = "{WA}-Continuum: Visualising Word Alignments across Multiple Parallel Sentences Simultaneously",
    author = "Steele, David  and
      Specia, Lucia",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4021",
    doi = "10.3115/v1/P15-4021",
    pages = "121--126",
}
@inproceedings{valenzuela-escarcega-etal-2015-domain,
    title = "A Domain-independent Rule-based Framework for Event Extraction",
    author = "Valenzuela-Esc{\'a}rcega, Marco A.  and
      Hahn-Powell, Gus  and
      Surdeanu, Mihai  and
      Hicks, Thomas",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4022",
    doi = "10.3115/v1/P15-4022",
    pages = "127--132",
}
@inproceedings{wu-etal-2015-storybase,
    title = "{S}torybase: Towards Building a Knowledge Base for News Events",
    author = "Wu, Zhaohui  and
      Liang, Chen  and
      Giles, C. Lee",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4023",
    doi = "10.3115/v1/P15-4023",
    pages = "133--138",
}
@inproceedings{yen-etal-2015-writeahead,
    title = "{W}rite{A}head: Mining Grammar Patterns in Corpora for Assisted Writing",
    author = "Yen, Tzu-Hsi  and
      Wu, Jian-Cheng  and
      Chang, Jim  and
      Boisson, Joanne  and
      Chang, Jason",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4024",
    doi = "10.3115/v1/P15-4024",
    pages = "139--144",
}
@inproceedings{zhu-etal-2015-niuparser,
    title = "{N}iu{P}arser: A {C}hinese Syntactic and Semantic Parsing Toolkit",
    author = "Zhu, Jingbo  and
      Zhu, Muhua  and
      Wang, Qiang  and
      Xiao, Tong",
    booktitle = "Proceedings of {ACL}-{IJCNLP} 2015 System Demonstrations",
    month = jul,
    year = "2015",
    address = "Beijing, China",
    publisher = "Association for Computational Linguistics and The Asian Federation of Natural Language Processing",
    url = "https://www.aclweb.org/anthology/P15-4025",
    doi = "10.3115/v1/P15-4025",
    pages = "145--150",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings


text:
require cog.inc
require conf/include/devupstream.inc

SRC_URI = "https://github.com/Igalia/cog/releases/download/v${PV}/cog-${PV}.tar.xz \
           file://0001-platform-add-a-common-EGL-proc-address-loader-with-d.patch \
           file://0002-egl-proc-address.h-add-a-license-header.patch \
           "

SRC_URI[sha256sum] = "181b1f4963cdf264b8068460a64d14c92a627f7138ebecc0f36fce085f4e92dd"

SRC_URI_class-devupstream = "git://github.com/Igalia/cog.git;protocol=https;branch=master"
SRCREV_class-devupstream = "fcffa7a82b960dd514a2fee5edcce660acce73e7"

RDEPENDS_${PN} += "wpewebkit (>= 2.28)"

repository: oceanicsystems/meta-webkit

repo_name: oceanicsystems/meta-webkit


text:
package rsa

type PrivateKeyInfo struct {
	BitLen int
	Size   int
	Error  string
}

type PublicKeyInfo struct {
	BitLen int
	Size   int
	E      int
}

func (r *FastRSA) MetadataPrivateKey(privateKey string) (*PrivateKeyInfo, error) {

	private, err := r.readPrivateKey(privateKey)
	if err != nil {
		return nil, err
	}
	validate := ""
	err = private.Validate()
	if err != nil {
		validate = err.Error()
	}

	info := &PrivateKeyInfo{
		BitLen: private.D.BitLen(),
		Size:   private.Size(),
		Error:  validate,
	}

	return info, nil
}

func (r *FastRSA) MetadataPublicKey(publicKey string) (*PublicKeyInfo, error) {

	public, err := r.readPublicKey(publicKey)
	if err != nil {
		return nil, err
	}

	info := &PublicKeyInfo{
		BitLen: public.N.BitLen(),
		Size:   public.Size(),
		E:      public.E,
	}

	return info, nil
}

repository: jerson/rsa-mobile

repo_name: jerson/rsa-mobile

gha_language: TypeScript


text:
package plot

import (
	"fmt"
	"math"
)

// Ticks represents an approach to calculating tick position and label.
type Ticks interface {
	Ticks(axis *Axis) []Tick
}

// Tick represents a division on plot.
type Tick struct {
	Minor bool
	Label string
	Value float64
}

// AutomaticTicks tries to automatically figure out which ticks to use.
type AutomaticTicks struct{}

// logarithmicTicks calculates ticks for logarithmic axis.
func (at AutomaticTicks) logarithmicTicks(axis *Axis, transform *Log1pTransform) []Tick {
	//TODO: fix, we don't properly assign labels for logarithmic axis

	ticks := make([]Tick, 0)

	low, high := axis.Min, axis.Max
	if low > high {
		low, high = high, low
	}

	previous := math.NaN()

	inRange := func(value float64) bool {
		return low < value && value < high
	}

	if inRange(0) {
		ticks = append(ticks, Tick{Value: 0, Label: "0"})
		previous = 0
	}

	for power := 0; power < 10; power++ {
		value := math.Pow(transform.base, float64(power))
		if inRange(value) {
			ticks = append(ticks, Tick{
				Value: value,
				Label: fmt.Sprintf("%.0f", value),
			})
		}
		if inRange(-value) {
			ticks = append(ticks, Tick{
				Value: -value,
				Label: fmt.Sprintf("%.0f", -value),
			})
		}

		if !math.IsNaN(previous) && axis.MinorTicks > 0 {
			minorSpacing := (value - previous) / float64(axis.MinorTicks)
			minor := previous
			for i := 0; i < axis.MinorTicks; i++ {
				if inRange(minor) {
					ticks = append(ticks, Tick{Minor: true, Value: minor})
				}
				if inRange(-minor) {
					ticks = append(ticks, Tick{Minor: true, Value: -minor})
				}
				minor += minorSpacing
			}
		}
		previous = value
	}

	return ticks
}

// linearTicks calculates ticks on linear axis.
func (AutomaticTicks) linearTicks(axis *Axis) []Tick {
	majorSpacing := (axis.Max - axis.Min) / float64(axis.MajorTicks)
	minorSpacing := majorSpacing / float64(axis.MinorTicks)

	frac := -int(math.Floor(math.Log10(majorSpacing)))
	if frac < 0 {
		frac = 0
	}

	ticks := make([]Tick, 0, axis.MajorTicks*axis.MinorTicks)

	major := axis.Min
	hasZero := false
	for i := 0; i < axis.MajorTicks; i++ {
		if major == 0 {
			hasZero = true
		}
		ticks = append(ticks, Tick{
			Value: major,
			Label: fmt.Sprintf("%.[2]*[1]f", major, frac),
		})

		minor := major
		for k := 0; k < axis.MinorTicks; k++ {
			if minor == 0 {
				minor += minorSpacing
				continue
			}
			ticks = append(ticks, Tick{
				Minor: true,
				Value: minor,
			})
			minor += minorSpacing
		}

		major += majorSpacing
	}

	if !hasZero && (axis.Min <= 0) == (0 <= axis.Max) {
		ticks = append(ticks, Tick{
			Value: 0,
			Label: "0",
		})
	}

	return ticks
}

// Ticks automatically calculates appropriate ticks for an axis.
func (ticks AutomaticTicks) Ticks(axis *Axis) []Tick {
	// if transform, ok := axis.Transform.(*Log1pTransform); ok {
	// 	return ticks.logarithmicTicks(axis, transform)
	// }
	return ticks.linearTicks(axis)
}

// ManualTicks allows to manually place and label ticks.
type ManualTicks []Tick

// Ticks calculates ticks for specified axis.
func (ticks ManualTicks) Ticks(axis *Axis) []Tick { return []Tick(ticks) }

repository: loov/plot

repo_name: loov/plot


text:
package rotonde

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"

	log "github.com/Sirupsen/logrus"
	"github.com/mitchellh/mapstructure"
)

// wrapper for json serialized connections
type Packet struct {
	Type    string      `json:"type"`
	Payload interface{} `json:"payload"`
}

// Definitions is a slice of Definition, adds findBy
type Definitions []*Definition

// GetDefinitionForIdentifier _
func (definitions Definitions) GetDefinitionForIdentifier(identifier string) (*Definition, error) {
	for _, definition := range definitions {
		if definition.Identifier == identifier {
			return definition, nil
		}
	}
	return nil, errors.New(fmt.Sprint(identifier, " Not found"))
}

func PushDefinition(definitions Definitions, def *Definition) Definitions {
	if _, err := definitions.GetDefinitionForIdentifier(def.Identifier); err == nil {
		return definitions
	}
	return append(definitions, def)
}

func RemoveDefinition(definitions Definitions, identifier string) Definitions {
	for i, definition := range definitions {
		if definition.Identifier == identifier {
			if i < len(definitions)-1 {
				copy(definitions[i:], definitions[i+1:])
			}
			definitions = definitions[0 : len(definitions)-1]
			return definitions
		}
	}
	return definitions
}

// Fields sortable slice of fields
type FieldDefinitions []*FieldDefinition

// FieldDefinition _
type FieldDefinition struct {
	Name  string `json:"name"`
	Type  string `json:"type"` // string, number or boolean
	Units string `json:"units"`
}

// Definition, used to expose an action or event
type Definition struct {
	Identifier string `json:"identifier"`
	Type       string `json:"type"` // action or event
	IsArray    bool   `json:"isarray"`

	Fields FieldDefinitions `json:"fields"`
}

func (d *Definition) PushField(n, t, u string) {
	field := FieldDefinition{n, t, u}
	d.Fields = append(d.Fields, &field)
}

type UnDefinition Definition

// Object native representation of an event or action, just a map
type Object map[string]interface{}

type Event struct {
	Identifier string `json:"identifier"`
	Data       Object `json:"data"`
}

type Action struct {
	Identifier string `json:"identifier"`
	Data       Object `json:"data"`
}

// Subscription adds an objectID to the subscriptions of the sending connection
type Subscription struct {
	Identifier string `json:"identifier"`
}

// Unsubscription removes an objectID from the subscriptions of the sending connection
type Unsubscription struct {
	Identifier string `json:"identifier"`
}

func ToJSON(object interface{}) ([]byte, error) {
	var packet Packet
	switch data := object.(type) {
	case Event:
		packet = Packet{Type: "event", Payload: data}
	case Action:
		packet = Packet{Type: "action", Payload: data}
	case Subscription:
		packet = Packet{Type: "sub", Payload: data}
	case Unsubscription:
		packet = Packet{Type: "unsub", Payload: data}
	case Definition:
		packet = Packet{Type: "def", Payload: data}
	case UnDefinition:
		packet = Packet{Type: "undef", Payload: data}
	default:
		log.Fatal("Oops unknown packet: ", object)
	}

	jsonPacket, err := json.Marshal(packet)
	if err != nil {
		return nil, err
	}

	return jsonPacket, nil
}

func FromJSON(reader io.Reader) (interface{}, error) {
	packet := Packet{}
	decoder := json.NewDecoder(reader)
	if err := decoder.Decode(&packet); err != nil {
		return nil, err
	}

	switch packet.Type {
	case "event":
		event := Event{}
		mapstructure.Decode(packet.Payload, &event)
		return event, nil
	case "action":
		action := Action{}
		mapstructure.Decode(packet.Payload, &action)
		return action, nil
	case "sub":
		subscription := Subscription{}
		mapstructure.Decode(packet.Payload, &subscription)
		return subscription, nil
	case "unsub":
		unsubscription := Unsubscription{}
		mapstructure.Decode(packet.Payload, &unsubscription)
		return unsubscription, nil
	case "def":
		definition := Definition{}
		mapstructure.Decode(packet.Payload, &definition)
		return definition, nil
	case "undef":
		unDefinition := UnDefinition{}
		mapstructure.Decode(packet.Payload, &unDefinition)
		return unDefinition, nil
	}
	return nil, fmt.Errorf("%s not found", packet.Type)
}


text:
/*
API for the OpenDNS Security Graph / Investigate.

To use it, use your Investigate API key to build an Investigate object.

	key := "f29be9cc-f833-4a9a-b984-19dc4d5186ac"
	inv, err := goinvestigate.New(key)

	if err != nil {
		log.Fatal(err)
	}

Then you can call any API method, e.g.:
	data, err := inv.DomainRRHistory("www.test.com")
which returns a DomainRRHistory object.

Be sure to set runtime.GOMAXPROCS() in the init() function of your program to enable
concurrency.

The official OpenDNS Investigate Documentation can be found at:
https://sgraph.opendns.com/docs/api
*/
package goinvestigate

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"net/url"
	"os"
)

const (
	baseUrl    = "https://investigate.api.opendns.com"
	maxTries   = 5
	timeLayout = "2006/01/02/15"
)

// format strings for API URIs
var urls map[string]string = map[string]string{
	"ip":             "/dnsdb/ip/%s/%s.json",
	"domain":         "/dnsdb/name/%s/%s.json",
	"categorization": "/domains/categorization/%s",
	"related":        "/links/name/%s.json",
	"cooccurrences":  "/recommendations/name/%s.json",
	"security":       "/security/name/%s.json",
	"tags":           "/domains/%s/latest_tags",
	"latest_domains": "/ips/%s/latest_domains",
}

var supportedQueryTypes map[string]int = map[string]int{
	"A":     1,
	"NS":    1,
	"MX":    1,
	"TXT":   1,
	"CNAME": 1,
}

type Investigate struct {
	client  *http.Client
	key     string
	log     *log.Logger
	verbose bool
}

// Build a new Investigate client using an Investigate API key.
func New(key string) *Investigate {
	return &Investigate{
		&http.Client{},
		key,
		log.New(os.Stdout, `[Investigate] `, 0),
		false,
	}
}

// A generic Request method which makes the given request.
// Will retry up to 5 times on failure.
func (inv *Investigate) Request(req *http.Request) (*http.Response, error) {
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", inv.key))
	resp := new(http.Response)
	var err error
	tries := 0

	for ; resp.Body == nil && tries <= maxTries; tries++ {
		inv.Logf("%s %s\n", req.Method, req.URL.String())
		resp, err = inv.client.Do(req)
		if err != nil || (resp.StatusCode >= 400 && resp.StatusCode < 600) {
			// if it's a 400 error code, just return an error.
			// otherwise, if it's a server error, retry
			if resp.StatusCode >= 400 && resp.StatusCode < 500 {
				errStr := fmt.Sprintf("error: %v", err)
				inv.Log(errStr)
				inv.LogHTTPResponseBody(resp.Body)
				return nil, errors.New(errStr)
			}

			if tries == maxTries {
				errStr := fmt.Sprintf("error: %v\nFailed all attempts. Skipping.", err)
				log.Print(errStr)
				return nil, errors.New(errStr)
			}

			log.Printf("\nerror: %v\nTrying again: Attempt %d/%d\n", err, tries+1, maxTries)
			resp = new(http.Response)
		}
	}

	return resp, err
}

// A generic GET call to the Investigate API.
// Will make an HTTP request to: https://investigate.api.opendns.com{subUri}
func (inv *Investigate) Get(subUri string) (*http.Response, error) {
	req, err := http.NewRequest("GET", baseUrl+subUri, nil)

	if err != nil {
		return nil, errors.New(fmt.Sprintf("Error processing GET request: %v", err))
	}

	return inv.Request(req)
}

// A generic POST call, which forms a request with the given body
func (inv *Investigate) Post(subUri string, body io.Reader) (*http.Response, error) {
	req, err := http.NewRequest("POST", baseUrl+subUri, body)

	if err != nil {
		return nil, errors.New(fmt.Sprintf("Error processing POST request: %v", err))
	}

	return inv.Request(req)
}

func catUri(domain string, labels bool) (string, error) {
	uri, err := url.Parse(fmt.Sprintf(urls["categorization"], domain))

	if err != nil {
		return "", err
	}

	v := url.Values{}

	if labels {
		v.Set("showLabels", "true")
	}

	uri.RawQuery = v.Encode()
	return uri.String(), nil
}

// Get the domain status and categorization of a domain.
// Setting 'labels' to true will give back categorizations in human-readable form.
//
// For more detail, see https://sgraph.opendns.com/docs/api#categorization
func (inv *Investigate) Categorization(domain string, labels bool) (*DomainCategorization, error) {
	uri, err := catUri(domain, labels)
	if err != nil {
		inv.Logf("%v", err)
		return nil, err
	}
	resp := make(map[string]DomainCategorization)
	err = inv.GetParse(uri, resp)
	if err != nil {
		return nil, err
	}
	if cat, ok := resp[domain]; !ok {
		return nil, errors.New("received a malformed response body")
	} else {
		return &cat, nil
	}
}

// Get the status and categorization of a list of domains
// Setting 'labels' to true will give back categorizations in human-readable form.
//
// For more detail, see https://sgraph.opendns.com/docs/api#categorization
func (inv *Investigate) Categorizations(domains []string, labels bool) (map[string]DomainCategorization, error) {
	uri, err := catUri("", labels)
	if err != nil {
		inv.Logf("%v", err)
		return nil, err
	}
	body, err := json.Marshal(domains)

	if err != nil {
		inv.Logf("Error marshalling domain slice into JSON: %v", err)
		return nil, err
	}

	resp := make(map[string]DomainCategorization)
	err = inv.PostParse(uri, bytes.NewReader(body), resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Use domain to make the HTTP request: /links/name/{domain}.json
// Get the related domains of the given domain.
//
// For details, see https://sgraph.opendns.com/docs/api#relatedDomains
func (inv *Investigate) RelatedDomains(domain string) ([]RelatedDomain, error) {
	var resp RelatedDomainList
	err := inv.GetParse(fmt.Sprintf(urls["related"], domain), &resp)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

// Get the cooccurrences of the given domain.
//
// For details, see https://sgraph.opendns.com/docs/api#co-occurrences
func (inv *Investigate) Cooccurrences(domain string) ([]Cooccurrence, error) {
	var resp CooccurrenceList
	err := inv.GetParse(fmt.Sprintf(urls["cooccurrences"], domain), &resp)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

// Get the Security Information for the given domain.
//
// For details, see https://sgraph.opendns.com/docs/api#securityInfo
func (inv *Investigate) Security(domain string) (*SecurityFeatures, error) {
	resp := new(SecurityFeatures)
	err := inv.GetParse(fmt.Sprintf(urls["security"], domain), resp)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

// Get the domain tagging dates for the given domain.
//
// For details, see https://sgraph.opendns.com/docs/api#latest_tags
func (inv *Investigate) DomainTags(domain string) ([]DomainTag, error) {
	var resp []DomainTag
	err := inv.GetParse(fmt.Sprintf(urls["tags"], domain), &resp)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

func queryTypeSupported(qType string) bool {
	_, ok := supportedQueryTypes[qType]
	return ok
}

// Get the RR (Resource Record) History of the given IP.
// queryType is the type of DNS query to perform on the database.
// The following query types are supported:
//
// A, NS, MX, TXT, CNAME
//
// For details, see https://sgraph.opendns.com/docs/api#dnsrr_ip
func (inv *Investigate) IpRRHistory(ip string, queryType string) (*IPRRHistory, error) {
	// If the user tried an unsupported query type, return an error
	if !queryTypeSupported(queryType) {
		return nil, errors.New("unsupported query type")
	}
	resp := new(IPRRHistory)
	err := inv.GetParse(fmt.Sprintf(urls["ip"], queryType, ip), resp)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

// Get the RR (Resource Record) History of the given domain.
// queryType is the type of DNS query to perform on the database.
// The following query types are supported:
//
// A, NS, MX, TXT, CNAME
//
// For details, see https://sgraph.opendns.com/docs/api#dnsrr_domain
func (inv *Investigate) DomainRRHistory(domain string, queryType string) (*DomainRRHistory, error) {
	// If the user tried an unsupported query type, return an error
	if !queryTypeSupported(queryType) {
		return nil, errors.New("unsupported query type")
	}
	resp := new(DomainRRHistory)
	err := inv.GetParse(fmt.Sprintf(urls["domain"], queryType, domain), resp)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

func extractDomains(respList []MaliciousDomain) []string {
	var domainList []string
	for _, entry := range respList {
		domainList = append(domainList, entry.Domain)
	}
	return domainList
}

// Gets the latest known malicious domains associated with the given
// IP address, if any. Returns the list of malicious domains.
//
// For details, see https://sgraph.opendns.com/docs/api#latest_domains
func (inv *Investigate) LatestDomains(ip string) ([]string, error) {
	var resp []MaliciousDomain
	err := inv.GetParse(fmt.Sprintf(urls["latest_domains"], ip), &resp)

	if err != nil {
		return nil, err
	}

	return extractDomains(resp), nil
}

// Converts the given list of items (domains or IPs)
// to a list of their appropriate URIs for the Investigate API
func convertToSubUris(items []string, queryType string) []string {
	subUris := make([]string, len(items))
	for i, item := range items {
		subUris[i] = fmt.Sprintf(urls[queryType], item)
	}
	return subUris
}

// Convenience function to perform Get and parse the response body.
// Parses the response into the value pointed to by v.
func (inv *Investigate) GetParse(subUri string, v interface{}) error {
	resp, err := inv.Get(subUri)

	if err != nil {
		inv.Log(err.Error())
		return err
	}

	err = inv.parseBody(resp.Body, v)

	if err != nil && inv.verbose {
		inv.Log(err.Error())
	}

	return err
}

// Convenience function to perform Post and parse the response body.
// Parses the response into the value pointed to by v.
func (inv *Investigate) PostParse(subUri string, body io.Reader, v interface{}) error {
	resp, err := inv.Post(subUri, body)

	if err != nil {
		inv.Log(err.Error())
		return err
	}

	err = inv.parseBody(resp.Body, v)

	if err != nil {
		inv.Log(err.Error())
	}

	return err
}

// Parse an HTTP JSON response into a map
func (inv *Investigate) parseBody(respBody io.ReadCloser, v interface{}) (err error) {
	defer respBody.Close()
	body, err := ioutil.ReadAll(respBody)
	if err != nil {
		log.Printf("error reading body: %v", err)
		return err
	}

	switch unpackedValue := v.(type) {
	case *CooccurrenceList:
		err = json.Unmarshal(body, unpackedValue)
	case *RelatedDomainList:
		err = json.Unmarshal(body, unpackedValue)
	case *[]MaliciousDomain:
		err = json.Unmarshal(body, unpackedValue)
	case map[string]DomainCategorization:
		err = json.Unmarshal(body, &unpackedValue)
	case *SecurityFeatures:
		err = json.Unmarshal(body, unpackedValue)
	case *[]DomainTag:
		err = json.Unmarshal(body, unpackedValue)
	case *DomainRRHistory:
		err = json.Unmarshal(body, unpackedValue)
	case *IPRRHistory:
		err = json.Unmarshal(body, unpackedValue)
	default:
		err = errors.New("type of v is unsupported")
	}

	if err != nil {
		inv.Logf("error unmarshaling JSON response: %v\nbody: %s", err, body)
	}

	return err
}

// Log something to stdout
func (inv *Investigate) Log(s string) {
	if inv.verbose {
		inv.log.Println(s)
	}
}

// Log something to stdout with a format string
func (inv *Investigate) Logf(fs string, args ...interface{}) {
	if inv.verbose {
		inv.log.Printf(fs, args...)
	}
}

// Log the response body
func (inv *Investigate) LogHTTPResponseBody(respBody io.ReadCloser) {
	if inv.verbose {
		bytes, err := ioutil.ReadAll(respBody)
		if err != nil {
			inv.Logf("error reading response body: %v", err)
		}
		inv.Logf("response body:\n%s", bytes)
	}
}

// Sets verbose messages to the given boolean value.
func (inv *Investigate) SetVerbose(verbose bool) {
	inv.verbose = verbose
}


text:
@Manual{2020language,
  title = {R: A Language and Environment for Statistical Computing},
  author = {{R Core Team}},
  organization = {R Foundation for Statistical Computing},
  address = {Vienna, Austria},
  year = {2020},
  url = {https://www.R-project.org/},
}

@Manual{allaire2020rmarkdown,
  title = {rmarkdown: Dynamic Documents for R},
  author = {JJ Allaire and Yihui Xie and Jonathan McPherson and Javier Luraschi and Kevin Ushey and Aron Atkins and Hadley Wickham and Joe Cheng and Winston Chang and Richard Iannone},
  year = {2020},
  note = {R package version 2.5},
  url = {https://github.com/rstudio/rmarkdown},
}

@Manual{boettiger2019knitcitations,
  title = {knitcitations: Citations for 'Knitr' Markdown Files},
  author = {Carl Boettiger},
  year = {2019},
  note = {R package version 1.0.10},
  url = {https://CRAN.R-project.org/package=knitcitations},
}

@Article{colladotorres2017recount,
  title = {recount workflow: Accessing over 70,000 human RNA-seq samples with Bioconductor [version 1; referees: 1 approved, 2 approved with reservations]},
  author = {Leonardo Collado-Torres and Abhinav Nellore and Andrew E. Jaffe},
  year = {2017},
  journal = {F1000Research},
  doi = {10.12688/f1000research.12223.1},
  url = {https://f1000research.com/articles/6-1558/v1},
}

@Article{colladotorres2017reproducible,
  title = {Reproducible RNA-seq analysis using recount2},
  author = {Leonardo Collado-Torres and Abhinav Nellore and Kai Kammers and Shannon E. Ellis and Margaret A. Taub and Kasper D. Hansen and Andrew E. Jaffe and Ben Langmead and Jeffrey T. Leek},
  year = {2017},
  journal = {Nature Biotechnology},
  doi = {10.1038/nbt.3838},
  url = {http://www.nature.com/nbt/journal/v35/n4/full/nbt.3838.html},
}

@Manual{colladotorres2019jaffelab,
  title = {jaffelab: Commonly used functions by the Jaffe lab},
  author = {Leonardo Collado-Torres and Andrew E. Jaffe and Emily E. Burke},
  year = {2019},
  note = {R package version 0.99.30},
  url = {https://github.com/LieberInstitute/jaffelab},
}

@Article{ellis2018improving,
  title = {Improving the value of public RNA-seq expression data by phenotype prediction},
  author = {Shannon E. Ellis and Leonardo Collado-Torres and Andrew E. Jaffe and Jeffrey T. Leek},
  year = {2018},
  journal = {Nucl. Acids Res.},
  doi = {10.1093/nar/gky102},
  url = {https://doi.org/10.1093/nar/gky102},
}

@Article{Ferreira_2018,
  doi = {10.1038/s41467-017-02772-x},
  url = {https://doi.org/10.1038/s41467-017-02772-x},
  year = {2018},
  month = {feb},
  publisher = {Springer Science and Business Media {LLC}},
  volume = {9},
  number = {1},
  author = {Pedro G. Ferreira and Manuel Mu{\~n}oz-Aguirre and Ferran Reverter and Caio P. S{\a'a} Godinho and Abel Sousa and Alicia Amadoz and Reza Sodaei and Marta R. Hidalgo and Dmitri Pervouchine and Jose Carbonell-Caballero and Ramil Nurtdinov and Alessandra Breschi and Raziel Amador and Patr\'\icia Oliveira and Cankut {\c C}ubuk and Jo{\~a}o Curado and Fran{\c c}ois Aguet and Carla Oliveira and Joaquin Dopazo and Michael Sammeth and Kristin G. Ardlie and Roderic Gui {\a'o}},
  title = {The effects of death and post-mortem cold ischemia on human tissue transcriptomes},
  journal = {Nature Communications},
}

@Manual{ole2020biocstyle,
  title = {BiocStyle: Standard styles for vignettes and other Bioconductor documents},
  author = {Andrzej Ole{\a's} and Martin Morgan and Wolfgang Huber},
  year = {2020},
  note = {R package version 2.16.1},
  url = {https://github.com/Bioconductor/BiocStyle},
}

@Book{wickham2016ggplot2,
  author = {Hadley Wickham},
  title = {ggplot2: Elegant Graphics for Data Analysis},
  publisher = {Springer-Verlag New York},
  year = {2016},
  isbn = {978-3-319-24277-4},
  url = {https://ggplot2.tidyverse.org},
}

@Manual{wickham2020devtools,
  title = {devtools: Tools to Make Developing R Packages Easier},
  author = {Hadley Wickham and Jim Hester and Winston Chang},
  year = {2020},
  note = {R package version 2.3.2},
  url = {https://CRAN.R-project.org/package=devtools},
}

@InCollection{xie2014knitr,
  booktitle = {Implementing Reproducible Computational Research},
  editor = {Victoria Stodden and Friedrich Leisch and Roger D. Peng},
  title = {knitr: A Comprehensive Tool for Reproducible Research in {R}},
  author = {Yihui Xie},
  publisher = {Chapman and Hall/CRC},
  year = {2014},
  note = {ISBN 978-1466561595},
  url = {http://www.crcpress.com/product/isbn/9781466561595},
}

repository: LieberInstitute/recount-brain

repo_name: LieberInstitute/recount-brain

gha_language: HTML


text:
# base recipe: meta/recipes-devtools/python/python3-dbus_1.2.8.bb
# base branch: warrior
# base commit: ec9ad3648bd9882fd2004bf5fcb0e0f55e160cc8

SUMMARY = "Python bindings for the DBus inter-process communication system"
SECTION = "devel/python"
HOMEPAGE = "http://www.freedesktop.org/Software/dbus"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://COPYING;md5=b03240518994df6d8c974675675e5ca4"
DEPENDS = "expat dbus dbus-glib virtual/libintl"

inherit debian-package
require recipes-debian/sources/dbus-python.inc

DEBIAN_UNPACK_DIR = "${WORKDIR}/dbus-python-${PV}"

inherit distutils3-base autotools pkgconfig

# documentation needs python3-sphinx, which is not in oe-core or meta-python for now
# change to use PACKAGECONFIG when python3-sphinx is added to oe-core
EXTRA_OECONF += "--disable-documentation"

RDEPENDS_${PN} = "python3-io python3-logging python3-stringold python3-threading python3-xml"

FILES_${PN}-dev += "${libdir}/pkgconfig"

repository: miraclelinux/meta-debian-extended

repo_name: miraclelinux/meta-debian-extended

branch_name: refs/heads/warrior


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.)

SUMMARY = "Python binding to the Brotli library"
HOMEPAGE = "https://github.com/python-hyper/brotlipy/"
# 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.
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=ae57d8a09fc8b6b164d7357339619045 \
                    file://libbrotli/LICENSE;md5=941ee9cd1609382f946352712a319b4b"

SRC_URI[md5sum] = "300a63158cec5b74082625dd9a2ae4d2"
SRC_URI[sha256sum] = "36def0b859beaf21910157b4c33eb3b06d8ce459c942102f16988cca6ea164df"

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

DEPENDS += " python3-cffi-native "

inherit pypi setuptools3

# The following configs & dependencies are from setuptools extras_require.
# These dependencies are optional, hence can be controlled via PACKAGECONFIG.
# The upstream names may not correspond exactly to bitbake package names.
#
# Uncomment this line to enable all the optional features.
#PACKAGECONFIG ?= ":python_version == "2.7" or python_version == "3.3""

# WARNING: the following rdepends are from setuptools install_requires. These
# upstream names may not correspond exactly to bitbake package names.
RDEPENDS:${PN} += "python3-cffi"

# WARNING: the following rdepends are determined through basic analysis of the
# python sources, and might not be 100% accurate.
RDEPENDS:${PN} += "python3-core"

repository: kedder/openvario-ppa

repo_name: kedder/openvario-ppa


text:
SUMMARY = "Plugin based library to create window decorations"
LICENSE = "LGPLv2"
LIC_FILES_CHKSUM = "file://COPYING.LIB;md5=2d5025d4aa3495befef8f17206a5b0a1"

inherit kde-plasma cmake-lib

PV = "${PLASMA_VERSION}"
SRC_URI[md5sum] = "d72584ff8363c903ea58b2d56cab965f"
SRC_URI[sha256sum] = "2c51ee6d2ddce21ba10ab15bc6f57ee3e453c943e64f7861443ba3dbece940cc"

# cross libs / headers
CMAKE_ALIGN_SYSROOT[1] = "KDecoration2, -S${libdir}/lib, -S${STAGING_LIBDIR}/lib"
CMAKE_ALIGN_SYSROOT[2] = "KDecoration2, -S${includedir}, -S${STAGING_INCDIR}"


text:
package main

import (
	"fmt"
	"github.com/koofr/envigo"
)

type Config struct {
	Http    ConfigHttp
	Logging ConfigLogging
	Debug   bool
}

type ConfigHttp struct {
	Port int
}

type ConfigLogging struct {
	Level string
}

func main() {
	config := &Config{}

	_ = envigo.Envigo(config, "", envigo.EnvironGetter())

	fmt.Println(config)
}

repository: koofr/envigo

repo_name: koofr/envigo


text:
package main

import (
	"flag"
	"fmt"
	"log"

	"github.com/couchbase/gomemcached/client"
	"github.com/couchbaselabs/go-couchbase"
)

var poolName = flag.String("pool", "default", "Pool name")
var back = flag.Uint64("backfill", memcached.TapNoBackfill, "List historical values starting from here")
var dump = flag.Bool("dump", false, "Stop after backfill")
var raw = flag.Bool("raw", false, "Show raw event contents")
var ack = flag.Bool("ack", false, "Request ACKs from server")
var keysOnly = flag.Bool("keysOnly", false, "Send only keys, no values")
var checkpoint = flag.Bool("checkpoint", false, "Send checkpoint events")

func main() {
	flag.Parse()

	if len(flag.Args()) < 2 {
		log.Fatalf("Server URL and bucket name required")
	}

	c, err := couchbase.Connect(flag.Arg(0))
	if err != nil {
		log.Fatalf("Error connecting:  %v", err)
	}
	fmt.Printf("Connected to ver=%s\n", c.Info.ImplementationVersion)

	pool, err := c.GetPool(*poolName)
	if err != nil {
		log.Fatalf("Can't get pool %q:  %v", *poolName, err)
	}

	bucket, err := pool.GetBucket(flag.Arg(1))
	if err != nil {
		log.Fatalf("Can't get bucket %q:  %v", flag.Arg(1), err)
	}

	args := memcached.DefaultTapArguments()
	args.Backfill = uint64(*back)
	args.Dump = *dump
	args.SupportAck = *ack
	args.KeysOnly = *keysOnly
	args.Checkpoint = *checkpoint
	feed, err := bucket.StartTapFeed(&args)
	if err != nil {
		log.Fatalf("Error starting tap feed: %v", err)
	}
	for op := range feed.C {
		if *raw {
			log.Printf("Received %#v\n", op)
		} else {
			log.Printf("Received %s\n", op.String())
			if len(op.Value) > 0 && len(op.Value) < 500 {
				log.Printf("\tValue: %s", op.Value)
			}
		}
	}
}


text:
/*
Copyright 2018 Scaleway

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package scaleway

import (
	"context"
	"net"
	"strings"
	"testing"

	scwbaremetal "github.com/scaleway/scaleway-sdk-go/api/baremetal/v1"
	"github.com/scaleway/scaleway-sdk-go/scw"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	cloudprovider "k8s.io/cloud-provider"
)

type fakeBaremetalAPI struct {
	Servers map[string]*scwbaremetal.Server
	Offers  map[string]*scwbaremetal.Offer
}

func newFakeBaremetalAPI() *fakeBaremetalAPI {
	offerID := "778f24b8-a506-49b5-b847-4506a23df695"
	return &fakeBaremetalAPI{
		Offers: map[string]*scwbaremetal.Offer{
			offerID: {
				Name: "TEST1-L",
			},
		},
		Servers: map[string]*scwbaremetal.Server{
			// a ready server with tags
			"53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed": {
				Zone:    "fr-par-2",
				Name:    "bm-keen-feistel",
				Status:  scwbaremetal.ServerStatusReady,
				Tags:    []string{"baremetal", "something"},
				OfferID: offerID,
				IPs: []*scwbaremetal.IP{
					{
						Address: net.ParseIP("62.210.16.2"),
						Reverse: "53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed.fr-par-2.baremetal.scw.cloud",
						Version: scwbaremetal.IPVersionIPv4,
					},
					{
						Address: net.ParseIP("2001:bc8:4::5"),
						Reverse: "53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed.fr-par-2.baremetal.scw.cloud",
						Version: scwbaremetal.IPVersionIPv6,
					},
				},
				Domain: "53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed.fr-par-2.baremetal.scw.cloud",
			},
			// a ready server
			"7c9877e0-4415-447a-819f-12cc0047e3fe": {
				Zone:    "fr-par-2",
				Name:    "bm-laughing-ritchie",
				Status:  scwbaremetal.ServerStatusReady,
				OfferID: offerID,
				IPs: []*scwbaremetal.IP{
					{
						Address: net.ParseIP("62.210.16.2"),
						Reverse: "7c9877e0-4415-447a-819f-12cc0047e3fe.fr-par-2.baremetal.scw.cloud",
						Version: scwbaremetal.IPVersionIPv4,
					},
					{
						Address: net.ParseIP("2001:bc8:4::5"),
						Reverse: "7c9877e0-4415-447a-819f-12cc0047e3fe.fr-par-2.baremetal.scw.cloud",
						Version: scwbaremetal.IPVersionIPv6,
					},
				},
				Domain: "7c9877e0-4415-447a-819f-12cc0047e3fe.fr-par-2.baremetal.scw.cloud",
			},
			// a stopped server
			"42d74979-992e-4650-9d05-31b834547d69": {
				Zone:    "fr-par-2",
				Name:    "bm-optimistic-cohen",
				Status:  scwbaremetal.ServerStatusStopped,
				OfferID: offerID,
				IPs: []*scwbaremetal.IP{
					{
						Address: net.ParseIP("62.210.16.2"),
						Reverse: "42d74979-992e-4650-9d05-31b834547d69.fr-par-2.baremetal.scw.cloud",
						Version: scwbaremetal.IPVersionIPv4,
					},
					{
						Address: net.ParseIP("2001:bc8:4::5"),
						Reverse: "42d74979-992e-4650-9d05-31b834547d69.fr-par-2.baremetal.scw.cloud",
						Version: scwbaremetal.IPVersionIPv6,
					},
				},
				Domain: "42d74979-992e-4650-9d05-31b834547d69.fr-par-2.baremetal.scw.cloud",
			},
			// a server in a transiant state (deleting)
			"0d4656bf-53e0-4762-9b63-2fbc6a83d5b4": {
				Zone:    "fr-par-2",
				Name:    "bm-jovial-raman",
				Status:  scwbaremetal.ServerStatusDeleting,
				OfferID: offerID,
				IPs: []*scwbaremetal.IP{
					{
						Address: net.ParseIP("62.210.16.2"),
						Reverse: "0d4656bf-53e0-4762-9b63-2fbc6a83d5b4.fr-par-2.baremetal.scw.cloud",
						Version: scwbaremetal.IPVersionIPv4,
					},
					{
						Address: net.ParseIP("2001:bc8:4::5"),
						Reverse: "0d4656bf-53e0-4762-9b63-2fbc6a83d5b4.fr-par-2.baremetal.scw.cloud",
						Version: scwbaremetal.IPVersionIPv6,
					},
				},
				Domain: "0d4656bf-53e0-4762-9b63-2fbc6a83d5b4.fr-par-2.baremetal.scw.cloud",
			},
		},
	}
}

func newFakeBaremetal() *baremetal {
	return &baremetal{
		api: newFakeBaremetalAPI(),
	}
}

func (f *fakeBaremetalAPI) ListServers(req *scwbaremetal.ListServersRequest, opts ...scw.RequestOption) (*scwbaremetal.ListServersResponse, error) {
	servers := make([]*scwbaremetal.Server, 0)
	for id, server := range f.Servers {
		if req.Zone != server.Zone {
			continue
		}

		if req.Name == nil || strings.Contains(server.Name, *req.Name) {
			server.ID = id
			servers = append(servers, server)
		}
	}

	return &scwbaremetal.ListServersResponse{
		Servers:    servers,
		TotalCount: uint32(len(servers)),
	}, nil
}

func (f *fakeBaremetalAPI) GetServer(req *scwbaremetal.GetServerRequest, opts ...scw.RequestOption) (*scwbaremetal.Server, error) {
	server, ok := f.Servers[req.ServerID]
	if !ok {
		return nil, &scw.ResourceNotFoundError{}
	}

	server.ID = req.ServerID
	return server, nil
}

func (f *fakeBaremetalAPI) GetOffer(req *scwbaremetal.GetOfferRequest, opts ...scw.RequestOption) (*scwbaremetal.Offer, error) {
	offer, ok := f.Offers[req.OfferID]
	if !ok {
		return nil, &scw.ResourceNotFoundError{}
	}

	offer.ID = req.OfferID
	return offer, nil
}

func TestBaremetal_NodeAddresses(t *testing.T) {
	baremetal := newFakeBaremetal()

	expectedAddresses := []v1.NodeAddress{
		{Type: v1.NodeHostName, Address: "bm-keen-feistel"},
		{Type: v1.NodeExternalIP, Address: "62.210.16.2"},
		{Type: v1.NodeExternalDNS, Address: "53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed.fr-par-2.baremetal.scw.cloud"},
	}

	returnedAddresses, err := baremetal.NodeAddresses(context.TODO(), "bm-keen-feistel")
	AssertNoError(t, err)
	Equals(t, expectedAddresses, returnedAddresses)
}

func TestBaremetal_NodeAddressesByProviderID(t *testing.T) {
	baremetal := newFakeBaremetal()

	expectedAddresses := []v1.NodeAddress{
		{Type: v1.NodeHostName, Address: "bm-keen-feistel"},
		{Type: v1.NodeExternalIP, Address: "62.210.16.2"},
		{Type: v1.NodeExternalDNS, Address: "53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed.fr-par-2.baremetal.scw.cloud"},
	}

	returnedAddresses, err := baremetal.NodeAddressesByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed")
	AssertNoError(t, err)
	Equals(t, expectedAddresses, returnedAddresses)
}

func TestBaremetal_InstanceID(t *testing.T) {
	baremetal := newFakeBaremetal()

	t.Run("Found", func(t *testing.T) {
		result, err := baremetal.InstanceID(context.TODO(), "bm-keen-feistel")
		AssertNoError(t, err)
		Equals(t, "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed", result)
	})

	t.Run("NotFound", func(t *testing.T) {
		_, err := baremetal.InstanceID(context.TODO(), "bm-not-found")
		Equals(t, err, cloudprovider.InstanceNotFound)
	})
}

func TestBaremetal_InstanceType(t *testing.T) {
	baremetal := newFakeBaremetal()

	result, err := baremetal.InstanceType(context.TODO(), "bm-keen-feistel")
	AssertNoError(t, err)
	Equals(t, "TEST1-L", result)
}

func TestBaremetal_InstanceTypeByProviderID(t *testing.T) {
	baremetal := newFakeBaremetal()

	result, err := baremetal.InstanceTypeByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed")
	AssertNoError(t, err)
	Equals(t, "TEST1-L", result)
}

func TestBaremetal_InstanceExistsByProviderID(t *testing.T) {
	baremetal := newFakeBaremetal()

	t.Run("Running", func(t *testing.T) {
		result, err := baremetal.InstanceExistsByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed")
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("Stopped", func(t *testing.T) {
		result, err := baremetal.InstanceExistsByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/42d74979-992e-4650-9d05-31b834547d69")
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("NotFound", func(t *testing.T) {
		result, err := baremetal.InstanceExistsByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/4d17aad4-c77e-4d95-a6e8-d7bf3f02d345")
		AssertNoError(t, err)
		AssertFalse(t, result)
	})
}

func TestBaremetal_InstanceShutdownByProviderID(t *testing.T) {
	baremetal := newFakeBaremetal()

	t.Run("Running", func(t *testing.T) {
		result, err := baremetal.InstanceShutdownByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed")
		AssertNoError(t, err)
		AssertFalse(t, result)
	})

	t.Run("Deleting", func(t *testing.T) {
		result, err := baremetal.InstanceShutdownByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/42d74979-992e-4650-9d05-31b834547d69")
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("Stopped", func(t *testing.T) {
		result, err := baremetal.InstanceShutdownByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/42d74979-992e-4650-9d05-31b834547d69")
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("NotFound", func(t *testing.T) {
		result, err := baremetal.InstanceShutdownByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/4d17aad4-c77e-4d95-a6e8-d7bf3f02d345")
		Equals(t, err, cloudprovider.InstanceNotFound)
		AssertFalse(t, result)
	})
}

func TestBaremetal_GetZoneByNodeName(t *testing.T) {
	baremetal := newFakeBaremetal()

	// scaleway baremeral is hard allocated
	expected := cloudprovider.Zone{Region: "fr-par-2", FailureDomain: "unavailable"}
	result, err := baremetal.GetZoneByNodeName(context.TODO(), "bm-keen-feistel")
	AssertNoError(t, err)
	Equals(t, expected, result)
}

func TestBaremetal_GetZoneByProviderID(t *testing.T) {
	baremetal := newFakeBaremetal()

	// scaleway baremeral is hard allocated
	expected := cloudprovider.Zone{Region: "fr-par-2", FailureDomain: "unavailable"}
	result, err := baremetal.GetZoneByProviderID(context.TODO(), "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed")
	AssertNoError(t, err)
	Equals(t, expected, result)
}

func TestBaremetal_InstanceExists(t *testing.T) {
	baremetal := newFakeBaremetal()

	t.Run("Running by ID", func(t *testing.T) {
		result, err := baremetal.InstanceExists(context.TODO(), &v1.Node{
			Spec: v1.NodeSpec{
				ProviderID: "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed",
			},
		})
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("Stopped by ID", func(t *testing.T) {
		result, err := baremetal.InstanceExists(context.TODO(), &v1.Node{
			Spec: v1.NodeSpec{
				ProviderID: "scaleway://baremetal/fr-par-2/42d74979-992e-4650-9d05-31b834547d69",
			},
		})
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("NotFound by ID", func(t *testing.T) {
		result, err := baremetal.InstanceExists(context.TODO(), &v1.Node{
			Spec: v1.NodeSpec{
				ProviderID: "scaleway://baremetal/fr-par-2/4d17aad4-c77e-4d95-a6e8-d7bf3f02d345",
			},
		})
		AssertNoError(t, err)
		AssertFalse(t, result)
	})
	t.Run("Running by name", func(t *testing.T) {
		result, err := baremetal.InstanceExists(context.TODO(), &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: "bm-keen-feistel",
			},
		})
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("Stopped by name", func(t *testing.T) {
		result, err := baremetal.InstanceExists(context.TODO(), &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: "bm-optimistic-cohen",
			},
		})
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("NotFound by name", func(t *testing.T) {
		result, err := baremetal.InstanceExists(context.TODO(), &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: "dummy-name",
			},
		})
		AssertNoError(t, err)
		AssertFalse(t, result)
	})

}

func TestBaremetal_InstanceShutdown(t *testing.T) {
	baremetal := newFakeBaremetal()

	t.Run("Running by ID", func(t *testing.T) {
		result, err := baremetal.InstanceShutdown(context.TODO(), &v1.Node{
			Spec: v1.NodeSpec{
				ProviderID: "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed",
			},
		})
		AssertNoError(t, err)
		AssertFalse(t, result)
	})

	t.Run("Stopped by ID", func(t *testing.T) {
		result, err := baremetal.InstanceShutdown(context.TODO(), &v1.Node{
			Spec: v1.NodeSpec{
				ProviderID: "scaleway://baremetal/fr-par-2/42d74979-992e-4650-9d05-31b834547d69",
			},
		})
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("NotFound by ID", func(t *testing.T) {
		_, err := baremetal.InstanceShutdown(context.TODO(), &v1.Node{
			Spec: v1.NodeSpec{
				ProviderID: "scaleway://baremetal/fr-par-2/4d17aad4-c77e-4d95-a6e8-d7bf3f02d345",
			},
		})
		AssertTrue(t, err == cloudprovider.InstanceNotFound)
	})

	t.Run("Running by name", func(t *testing.T) {
		result, err := baremetal.InstanceShutdown(context.TODO(), &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: "bm-keen-feistel",
			},
		})
		AssertNoError(t, err)
		AssertFalse(t, result)
	})

	t.Run("Stopped by name", func(t *testing.T) {
		result, err := baremetal.InstanceShutdown(context.TODO(), &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: "bm-optimistic-cohen",
			},
		})
		AssertNoError(t, err)
		AssertTrue(t, result)
	})

	t.Run("NotFound by name", func(t *testing.T) {
		_, err := baremetal.InstanceShutdown(context.TODO(), &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: "dummy-name",
			},
		})
		AssertTrue(t, err == cloudprovider.InstanceNotFound)
	})
}

func TestBaremetal_InstanceMetadata(t *testing.T) {
	baremetal := newFakeBaremetal()

	expectedAddresses := []v1.NodeAddress{
		{Type: v1.NodeHostName, Address: "bm-keen-feistel"},
		{Type: v1.NodeExternalIP, Address: "62.210.16.2"},
		{Type: v1.NodeExternalDNS, Address: "53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed.fr-par-2.baremetal.scw.cloud"},
	}

	providerID := "scaleway://baremetal/fr-par-2/53a6ca14-0d8d-4f2e-9887-2f1bcfba58ed"
	offerName := "TEST1-L"

	t.Run("By ID", func(t *testing.T) {
		metadata, err := baremetal.InstanceMetadata(context.TODO(), &v1.Node{
			Spec: v1.NodeSpec{
				ProviderID: providerID,
			},
		})
		AssertNoError(t, err)
		Equals(t, expectedAddresses, metadata.NodeAddresses)
		Equals(t, offerName, metadata.InstanceType)
		Equals(t, providerID, metadata.ProviderID)
	})

	t.Run("By Name", func(t *testing.T) {
		metadata, err := baremetal.InstanceMetadata(context.TODO(), &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: "bm-keen-feistel",
			},
		})
		AssertNoError(t, err)
		Equals(t, expectedAddresses, metadata.NodeAddresses)
		Equals(t, offerName, metadata.InstanceType)
		Equals(t, providerID, metadata.ProviderID)
	})
}


text:
SUMMARY = "Library for building powerful interactive command lines in Python"
HOMEPAGE = "https://python-prompt-toolkit.readthedocs.io/"
LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://LICENSE;md5=b2cde7da89f0c1f3e49bf968d00d554f"

SRC_URI[sha256sum] = "3e163f254bef5a03b146397d7c1963bd3e2812f0964bb9a24e6ec761fd28db63"

inherit pypi setuptools3

PYPI_PACKAGE = "prompt_toolkit"

RDEPENDS:${PN} += " \
    ${PYTHON_PN}-core \
    ${PYTHON_PN}-six \
    ${PYTHON_PN}-terminal \
    ${PYTHON_PN}-threading \
    ${PYTHON_PN}-wcwidth \
    ${PYTHON_PN}-datetime \
    ${PYTHON_PN}-shell \
    ${PYTHON_PN}-image \
    ${PYTHON_PN}-asyncio \
    ${PYTHON_PN}-xml \
"

BBCLASSEXTEND = "native nativesdk"


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

package customer_segments

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

import (
	"context"
	"net/http"
	"time"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/runtime"
	cr "github.com/go-openapi/runtime/client"
	"github.com/go-openapi/strfmt"
)

// NewListCustomerSegmentsParams creates a new ListCustomerSegmentsParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewListCustomerSegmentsParams() *ListCustomerSegmentsParams {
	return &ListCustomerSegmentsParams{
		timeout: cr.DefaultTimeout,
	}
}

// NewListCustomerSegmentsParamsWithTimeout creates a new ListCustomerSegmentsParams object
// with the ability to set a timeout on a request.
func NewListCustomerSegmentsParamsWithTimeout(timeout time.Duration) *ListCustomerSegmentsParams {
	return &ListCustomerSegmentsParams{
		timeout: timeout,
	}
}

// NewListCustomerSegmentsParamsWithContext creates a new ListCustomerSegmentsParams object
// with the ability to set a context for a request.
func NewListCustomerSegmentsParamsWithContext(ctx context.Context) *ListCustomerSegmentsParams {
	return &ListCustomerSegmentsParams{
		Context: ctx,
	}
}

// NewListCustomerSegmentsParamsWithHTTPClient creates a new ListCustomerSegmentsParams object
// with the ability to set a custom HTTPClient for a request.
func NewListCustomerSegmentsParamsWithHTTPClient(client *http.Client) *ListCustomerSegmentsParams {
	return &ListCustomerSegmentsParams{
		HTTPClient: client,
	}
}

/* ListCustomerSegmentsParams contains all the parameters to send to the API endpoint
   for the list customer segments operation.

   Typically these are written to a http.Request.
*/
type ListCustomerSegmentsParams struct {

	/* Cursor.

	     A pagination cursor returned by previous calls to __ListCustomerSegments__.
	Used to retrieve the next set of query results.

	See the [Pagination guide](https://developer.squareup.com/docs/docs/working-with-apis/pagination) for more information.
	*/
	Cursor *string

	timeout    time.Duration
	Context    context.Context
	HTTPClient *http.Client
}

// WithDefaults hydrates default values in the list customer segments params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ListCustomerSegmentsParams) WithDefaults() *ListCustomerSegmentsParams {
	o.SetDefaults()
	return o
}

// SetDefaults hydrates default values in the list customer segments params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ListCustomerSegmentsParams) SetDefaults() {
	// no default values defined for this parameter
}

// WithTimeout adds the timeout to the list customer segments params
func (o *ListCustomerSegmentsParams) WithTimeout(timeout time.Duration) *ListCustomerSegmentsParams {
	o.SetTimeout(timeout)
	return o
}

// SetTimeout adds the timeout to the list customer segments params
func (o *ListCustomerSegmentsParams) SetTimeout(timeout time.Duration) {
	o.timeout = timeout
}

// WithContext adds the context to the list customer segments params
func (o *ListCustomerSegmentsParams) WithContext(ctx context.Context) *ListCustomerSegmentsParams {
	o.SetContext(ctx)
	return o
}

// SetContext adds the context to the list customer segments params
func (o *ListCustomerSegmentsParams) SetContext(ctx context.Context) {
	o.Context = ctx
}

// WithHTTPClient adds the HTTPClient to the list customer segments params
func (o *ListCustomerSegmentsParams) WithHTTPClient(client *http.Client) *ListCustomerSegmentsParams {
	o.SetHTTPClient(client)
	return o
}

// SetHTTPClient adds the HTTPClient to the list customer segments params
func (o *ListCustomerSegmentsParams) SetHTTPClient(client *http.Client) {
	o.HTTPClient = client
}

// WithCursor adds the cursor to the list customer segments params
func (o *ListCustomerSegmentsParams) WithCursor(cursor *string) *ListCustomerSegmentsParams {
	o.SetCursor(cursor)
	return o
}

// SetCursor adds the cursor to the list customer segments params
func (o *ListCustomerSegmentsParams) SetCursor(cursor *string) {
	o.Cursor = cursor
}

// WriteToRequest writes these params to a swagger request
func (o *ListCustomerSegmentsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {

	if err := r.SetTimeout(o.timeout); err != nil {
		return err
	}
	var res []error

	if o.Cursor != nil {

		// query param cursor
		var qrCursor string

		if o.Cursor != nil {
			qrCursor = *o.Cursor
		}
		qCursor := qrCursor
		if qCursor != "" {

			if err := r.SetQueryParam("cursor", qCursor); err != nil {
				return err
			}
		}
	}

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

repository: jefflinse/square-connect

repo_name: jefflinse/square-connect

gha_language: Makefile


text:
package netroutine

import (
	"context"
	"encoding/json"
)

const idMathMultiply = "MathMultiply"

func init() {
	blocks[idMathMultiply] = &MathMultiply{}
}

type MathMultiply struct {
	Source1Key string
	Source2Key string
	ToKey      string
}

func (b *MathMultiply) toBytes() ([]byte, error) {
	return json.Marshal(b)
}

func (b *MathMultiply) fromBytes(bytes []byte) error {
	return json.Unmarshal(bytes, b)
}

func (b *MathMultiply) kind() string {
	return idMathMultiply
}

func (b *MathMultiply) Run(ctx context.Context, wce *Environment) (string, Status) {

	s1, ok := wce.getData(b.Source1Key)
	if !ok {
		return log(b, missingWorkingData(b.Source1Key), Error)
	}

	s1f, err := toFloat64(s1)
	if err != nil {
		return log(b, reportWrongType(b.Source1Key), Error)
	}

	s2, ok := wce.getData(b.Source2Key)
	if !ok {
		return log(b, missingWorkingData(b.Source2Key), Error)
	}

	s2f, err := toFloat64(s2)
	if err != nil {
		return log(b, reportWrongType(b.Source2Key), Error)
	}

	v := s1f * s2f

	wce.setData(b.ToKey, v)

	return log(b, setWorkingData(b.ToKey, v), Success)
}

license: Unlicense

repository: aidenesco/netroutine

repo_name: aidenesco/netroutine


text:
package listener

import (
	"fgame/fgame/core/event"
	arenaeventtypes "fgame/fgame/cross/arena/event/types"
	arenalogic "fgame/fgame/cross/arena/logic"
	"fgame/fgame/cross/arena/pbutil"
	arenascene "fgame/fgame/cross/arena/scene"
	gameevent "fgame/fgame/game/event"
)

//竞技场场景开始
func arenaSceneStart(target event.EventTarget, data event.EventData) (err error) {
	sd := target.(arenascene.ArenaSceneData)
	scArenaSceneStart := pbutil.BuildSCArenaSceneStart()
	arenalogic.BroadcastArenaTeam(sd.GetTeam1(), scArenaSceneStart)
	arenalogic.BroadcastArenaTeam(sd.GetTeam2(), scArenaSceneStart)

	//TODO 机器人开始
	return
}

func init() {
	gameevent.AddEventListener(arenaeventtypes.EventTypeArenaSceneStart, event.EventListenerFunc(arenaSceneStart))
}

repository: rebider/Fgame

repo_name: rebider/Fgame


text:
require avahi.inc

PR = "r1"

DEPENDS += "intltool-native"

PACKAGES =+ "libavahi-gobject"


text:
# Copyright (C) 2020 Maik Otto <m.otto@phytec.de>
# Released under the MIT license (see COPYING.MIT for the terms)

require phytec-dev-ca.inc

SRC_URI[tarball.md5sum] = "2dc3fe8eb55c39c1435a942e5b7cd11f"
SRC_URI[tarball.sha256sum] = "000e54175ff34254f521b097ec98961658cc9c8338e72f78d93c4cb0f20c8e7c"


text:
# Copyright (c) 2012-2013 LG Electronics, Inc.
# Copyright (c) 2016 Herman van Hazendonk <github.com@herrie.org>

SECTION = "libs"
DESCRIPTION = "Hunspell spell checker and morphological analyzer"
LICENSE = "LGPL-2.1 & MPL-1.1"

LIC_FILES_CHKSUM = "file://COPYING.LGPL;md5=d8045f3b8f929c1cb29a1e3fd737b499 \
    file://COPYING.MPL;md5=bfe1f75d606912a4111c90743d6c7325 \
"

inherit autotools-brokensep gettext

SRCREV = "6aae365af685822a61241cbb09cfcc11fda3e1c1"

SRC_URI = "git://github.com/hunspell/hunspell.git;protocol=git;branch=master"
S = "${WORKDIR}/git"

PACKAGES =+ "${PN}-perl"
RDEPENDS_${PN}-perl = "perl"
FILES_${PN}-perl = "${bindir}/ispellaff2myspell"

repository: DougReeder/meta-webos-ports

repo_name: DougReeder/meta-webos-ports


text:
SUMMARY = "Some simple examples to get you started on developing with IOTA using Go."
DESCRIPTION = "Simple examples interacting with the tangle using the iota.go client library."
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

# go-iota-workshop repository
SRC_URI = "git://github.com/iota-community/go-iota-workshop.git;protocol=https;name=go-iota-workshop;destsuffix=${PN}-${PV}/src/github.com/iota-community/go-iota-workshop"

# Go dependencies
SRC_URI += "\
	   git://github.com/davecgh/go-spew.git;protocol=https;name=go-spew;destsuffix=${PN}-${PV}/src/github.com/davecgh/go-spew \
	   git://github.com/pebbe/zmq4.git;protocol=https;name=zmq4;destsuffix=${PN}-${PV}/src/github.com/pebbe/zmq4 \
"

SRCREV_go-iota-workshop = "${AUTOREV}"
SRCREV_go-spew = "v1.1.1"
SRCREV_zmq4 = "v1.0.0"

SRCREV_FORMAT = "go-iota-workshop_go-spew-zmq4"

DEPENDS = "iota.go zeromq"
RDEPENDS_${PN} = "ca-certificates"

inherit go pkgconfig
GO_IMPORT = "github.com/iota-community/go-iota-workshop"
GO_LINKSHARED = ""


text:
# CMake generated Testfile for
# Source directory: /home/intel/opencv-3.2.0/modules/cudalegacy
# Build directory: /home/intel/opencv-3.2.0/cmake-build-debug/modules/cudalegacy
#
# This file includes the relevant testing commands required for
# testing this directory and lists subdirectories to be tested as well.
add_test(opencv_test_cudalegacy "/home/intel/opencv-3.2.0/cmake-build-debug/bin/opencv_test_cudalegacy" "--gtest_output=xml:opencv_test_cudalegacy.xml")
set_tests_properties(opencv_test_cudalegacy PROPERTIES  LABELS "Main;opencv_cudalegacy;Accuracy" WORKING_DIRECTORY "/home/intel/opencv-3.2.0/cmake-build-debug/test-reports/accuracy")
add_test(opencv_perf_cudalegacy "/home/intel/opencv-3.2.0/cmake-build-debug/bin/opencv_perf_cudalegacy" "--gtest_output=xml:opencv_perf_cudalegacy.xml")
set_tests_properties(opencv_perf_cudalegacy PROPERTIES  LABELS "Main;opencv_cudalegacy;Performance" WORKING_DIRECTORY "/home/intel/opencv-3.2.0/cmake-build-debug/test-reports/performance")
add_test(opencv_sanity_cudalegacy "/home/intel/opencv-3.2.0/cmake-build-debug/bin/opencv_perf_cudalegacy" "--gtest_output=xml:opencv_perf_cudalegacy.xml" "--perf_min_samples=1" "--perf_force_samples=1" "--perf_verify_sanity")
set_tests_properties(opencv_sanity_cudalegacy PROPERTIES  LABELS "Main;opencv_cudalegacy;Sanity" WORKING_DIRECTORY "/home/intel/opencv-3.2.0/cmake-build-debug/test-reports/sanity")

repository: ZebulonJiang/opencv-fpga

repo_name: ZebulonJiang/opencv-fpga


text:
@proceedings{ws-2012-approaches-subjectivity,
    title = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    editor = "Balahur, Alexandra  and
      Montoyo, Andres  and
      Barco, Patricio Martinez  and
      Boldrini, Ester",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3700",
}
@inproceedings{mihalcea-2012-multimodal,
    title = "Multimodal Sentiment Analysis",
    author = "Mihalcea, Rada",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3701",
    pages = "1",
}
@inproceedings{wiebe-2012-subjectivity,
    title = "Subjectivity Word Sense Disambiguation",
    author = "Wiebe, Janyce",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3702",
    pages = "2",
}
@inproceedings{montejo-raez-etal-2012-random,
    title = "Random Walk Weighting over {S}enti{W}ord{N}et for Sentiment Polarity Detection on Twitter",
    author = "Montejo-R{\'a}ez, Arturo  and
      Mart{\'\i}nez-C{\'a}mara, Eugenio  and
      Mart{\'\i}n-Valdivia, M. Teresa  and
      Ure{\~n}a-L{\'o}pez, L. Alfonso",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3703",
    pages = "3--10",
}
@inproceedings{bakliwal-etal-2012-mining,
    title = "Mining Sentiments from Tweets",
    author = "Bakliwal, Akshat  and
      Arora, Piyush  and
      Madhappan, Senthil  and
      Kapre, Nikhil  and
      Singh, Mukesh  and
      Varma, Vasudeva",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3704",
    pages = "11--18",
}
@inproceedings{abdul-mageed-etal-2012-samar,
    title = "{SAMAR}: A System for Subjectivity and Sentiment Analysis of {A}rabic Social Media",
    author = "Abdul-Mageed, Muhammad  and
      Kuebler, Sandra  and
      Diab, Mona",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3705",
    pages = "19--28",
}
@inproceedings{bonev-etal-2012-opinum,
    title = "{O}pinum: statistical sentiment analysis for opinion classification",
    author = "Bonev, Boyan  and
      Ram{\'\i}rez-S{\'a}nchez, Gema  and
      Ortiz Rojas, Sergio",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3706",
    pages = "29--37",
}
@inproceedings{das-gamback-2012-sentimantics,
    title = "{S}entimantics: Conceptual Spaces for Lexical Sentiment Polarity Representation with Contextuality",
    author = {Das, Amitava  and
      Gamb{\"a}ck, Bj{\"o}rn},
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3707",
    pages = "38--46",
}
@inproceedings{ando-ishizaki-2012-analysis,
    title = "Analysis of Travel Review Data from Reader{'}s Point of View",
    author = "Ando, Maya  and
      Ishizaki, Shun",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3708",
    pages = "47--51",
}
@inproceedings{balahur-turchi-2012-multilingual,
    title = "Multilingual Sentiment Analysis using Machine Translation?",
    author = "Balahur, Alexandra  and
      Turchi, Marco",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3709",
    pages = "52--60",
}
@inproceedings{yin-etal-2012-unifying,
    title = "Unifying Local and Global Agreement and Disagreement Classification in Online Debates",
    author = "Yin, Jie  and
      Narang, Nalin  and
      Thomas, Paul  and
      Paris, Cecile",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3710",
    pages = "61--69",
}
@inproceedings{ghazi-etal-2012-prior,
    title = "Prior versus Contextual Emotion of a Word in a Sentence",
    author = "Ghazi, Diman  and
      Inkpen, Diana  and
      Szpakowicz, Stan",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3711",
    pages = "70--78",
}
@inproceedings{smith-lee-2012-cross,
    title = "Cross-discourse Development of Supervised Sentiment Analysis in the Clinical Domain",
    author = "Smith, Phillip  and
      Lee, Mark",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3712",
    pages = "79--83",
}
@inproceedings{reschke-anand-2012-political,
    title = "{POLITICAL}-{ADS}: An annotated corpus for modeling event-level evaluativity",
    author = "Reschke, Kevin  and
      Anand, Pranav",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3713",
    pages = "84--88",
}
@inproceedings{ptaszynski-etal-2012-automatically,
    title = "Automatically Annotating A Five-Billion-Word Corpus of {J}apanese Blogs for Affect and Sentiment Analysis",
    author = "Ptaszynski, Michal  and
      Rzepka, Rafal  and
      Araki, Kenji  and
      Momouchi, Yoshio",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3714",
    pages = "89--98",
}
@inproceedings{berend-vincze-2012-evaluate,
    title = "How to Evaluate Opinionated Keyphrase Extraction?",
    author = "Berend, G{\'a}bor  and
      Vincze, Veronika",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3715",
    pages = "99--103",
}
@inproceedings{ruppenhofer-rehbein-2012-semantic,
    title = "Semantic frames as an anchor representation for sentiment analysis",
    author = "Ruppenhofer, Josef  and
      Rehbein, Ines",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3716",
    pages = "104--109",
}
@inproceedings{bogdanova-etal-2012-impact,
    title = "On the Impact of Sentiment and Emotion Based Features in Detecting Online Sexual Predators",
    author = "Bogdanova, Dasha  and
      Rosso, Paolo  and
      Solorio, Thamar",
    booktitle = "Proceedings of the 3rd Workshop in Computational Approaches to Subjectivity and Sentiment Analysis",
    month = jul,
    year = "2012",
    address = "Jeju, Korea",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W12-3717",
    pages = "110--118",
}


text:
---
---
References
==========

@book{cormen2009,
author = {Cormen, Thomas H and Leiserson, Charles E and Rivest, Ronald L and Stein, Clifford},
title = {{Introduction to Algorithms, 3rd Edition}},
publisher = {MIT Press},
year = {2009}
}

repository: erikbeerepoot/slickrickco

repo_name: erikbeerepoot/slickrickco