text:
/pdf}
}

@article{boyaci_sample_2015-3,
	title = {Sample preparation with solid phase microextraction and exhaustive extraction approaches: Comparison for challenging cases},
	volume = {873},
	issn = {00032670},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0003267014014895},
	doi = {10.1016/j.aca.2014.12.051},
	shorttitle = {Sample preparation with solid phase microextraction and exhaustive extraction approaches},
	pages = {14--30},
	journaltitle = {Analytica Chimica Acta},
	author = {Boyacı, Ezel and Rodríguez-Lafuente, Ángel and Gorynski, Krzysztof and Mirnaghi, Fatemeh and Souza-Silva, Érica A. and Hein, Dietmar and Pawliszyn, Janusz},
	urldate = {2017-08-02},
	date = {2015-05},
	langid = {english},
	file = {Boyaci_2015_Analytica-Chimica-Acta.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\AF3GI3R8\\Boyaci_2015_Analytica-Chimica-Acta.pdf:application/pdf}
}

@article{jiang_thin-film_2012-1,
	title = {Thin-film microextraction offers another geometry for solid-phase microextraction},
	volume = {39},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0165993612001999},
	doi = {10.1016/j.trac.2012.07.005},
	pages = {245--253},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Jiang, Ruifen and Pawliszyn, Janusz},
	urldate = {2017-08-02},
	date = {2012-10},
	langid = {english},
	file = {Jiang-2012-Thin film microextraction offer.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\HVSWKJPP\\Jiang-2012-Thin film microextraction offer.pdf:application/pdf}
}

@article{li_advances_2015-3,
	title = {Advances in different configurations of solid-phase microextraction and their applications in food and environmental analysis},
	volume = {72},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0165993615001892},
	doi = {10.1016/j.trac.2015.04.023},
	pages = {141--152},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Li, Jia and Wang, Yan-Bin and Li, Ke-Yao and Cao, Yuan-Qi and Wu, Shang and Wu, Lan},
	urldate = {2017-08-02},
	date = {2015-10},
	langid = {english},
	file = {Li_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\XTJ2K5KE\\Li_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:application/pdf}
}

@article{moein_solid_2014-1,
	title = {Solid Phase Microextraction and Related Techniques for Drugs in Biological Samples},
	volume = {2014},
	issn = {2090-8865, 2090-8873},
	url = {http://www.hindawi.com/journals/jamc/2014/921350/},
	doi = {10.1155/2014/921350},
	pages = {1--24},
	journaltitle = {Journal of Analytical Methods in Chemistry},
	author = {Moein, Mohammad Mahdi and Said, Rana and Bassyouni, Fatma and Abdel-Rehim, Mohamed},
	urldate = {2017-08-02},
	date = {2014},
	langid = {english},
	file = {Moein_2014_Journal-of-Analytical-Methods-in-Chemistry.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\UG2GJA29\\Moein_2014_Journal-of-Analytical-Methods-in-Chemistry.pdf:application/pdf}
}

@article{moein_microextraction_2015-1,
	title = {Microextraction by packed sorbent ({MEPS})},
	volume = {67},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0165993615000230},
	doi = {10.1016/j.trac.2014.12.003},
	pages = {34--44},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Moein, Mohammad Mahdi and Abdel-Rehim, Abbi and Abdel-Rehim, Mohamed},
	urldate = {2017-08-02},
	date = {2015-04},
	langid = {english},
	file = {Moein_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\N36QP6BT\\Moein_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:application/pdf}
}

@article{mohamed_green_2015-1,
	title = {Green, environment-friendly, analytical tools give insights in pharmaceuticals and cosmetics analysis},
	volume = {66},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0165993615000047},
	doi = {10.1016/j.trac.2014.11.010},
	pages = {176--192},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Mohamed, Heba M.},
	urldate = {2017-08-02},
	date = {2015-03},
	langid = {english},
	file = {Mohamed_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\N9NBCFFK\\Mohamed_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:application/pdf}
}

@article{moliner-martinez_recent_2015-1,
	title = {Recent advances of in-tube solid-phase microextraction},
	volume = {71},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0165993615001338},
	doi = {10.1016/j.trac.2015.02.020},
	pages = {205--213},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Moliner-Martinez, Y. and Herráez-Hernández, R. and Verdú-Andrés, J. and Molins-Legua, C. and Campíns-Falcó, P.},
	urldate = {2017-08-02},
	date = {2015-09},
	langid = {english},
	file = {Moliner-Martinez_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\E6CCVJ4M\\Moliner-Martinez_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:application/pdf}
}

@article{moreda-pineiro_recent_2015-1,
	title = {Recent advances in combining microextraction techniques for sample pre-treatment},
	volume = {71},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0165993615001405},
	doi = {10.1016/j.trac.2015.02.025},
	pages = {265--274},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Moreda-Piñeiro, Jorge and Moreda-Piñeiro, Antonio},
	urldate = {2017-08-02},
	date = {2015-09},
	langid = {english},
	file = {Moreda-Piñeiro_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\VTQUU2EE\\Moreda-Piñeiro_2015_TrAC---Trends-in-Analytical-Chemistry.pdf:application/pdf}
}

@article{ouyang_critical_2008-2,
	title = {A critical review in calibration methods for solid-phase microextraction},
	volume = {627},
	issn = {00032670},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0003267008014578},
	doi = {10.1016/j.aca.2008.08.015},
	pages = {184--197},
	number = {2},
	journaltitle = {Analytica Chimica Acta},
	author = {Ouyang, Gangfeng and Pawliszyn, Janusz},
	urldate = {2017-08-02},
	date = {2008-10},
	langid = {english},
	file = {Ouyang-2008-A critical review in calibrantion methods.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\6C2XHXI3\\Ouyang-2008-A critical review in calibrantion methods.pdf:application/pdf}
}

@article{pawliszyn_sample_2003,
	title = {Sample Preparation: Quo Vadis?},
	volume = {75},
	issn = {0003-2700, 1520-6882},
	url = {http://pubs.acs.org/doi/abs/10.1021/ac034094h},
	doi = {10.1021/ac034094h},
	shorttitle = {Sample Preparation},
	pages = {2543--2558},
	number = {11},
	journaltitle = {Analytical Chemistry},
	author = {Pawliszyn, Janusz},
	urldate = {2017-08-02},
	date = {2003-06},
	langid = {english},
	file = {ac034094h.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\K649HZXT\\ac034094h.pdf:application/pdf}
}

@article{ghiasvand_cooling-assisted_2016-2,
	title = {Cooling-assisted microextraction: Comparison of techniques and applications},
	volume = {77},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S016599361530042X},
	doi = {10.1016/j.trac.2015.12.008},
	shorttitle = {Cooling-assisted microextraction},
	pages = {54--65},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Ghiasvand, Ali Reza and Hajipour, Somayeh and Heidari, Nahid},
	urldate = {2017-08-02},
	date = {2016-03},
	langid = {english},
	file = {1-s2.0-S016599361530042X-main.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\GNZXR3WD\\1-s2.0-S016599361530042X-main.pdf:application/pdf}
}

@article{mehdinia_advances_2013-2,
	title = {Advances for sensitive, rapid and selective extraction in different configurations of solid-phase microextraction},
	volume = {51},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0165993613001544},
	doi = {10.1016/j.trac.2013.05.013},
	pages = {13--22},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Mehdinia, Ali and Aziz-Zanjani, Mohammad Ovais},
	urldate = {2017-08-02},
	date = {2013-11},
	langid = {english},
	file = {1-s2.0-S0165993613001544-main.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\GFEHUT6I\\1-s2.0-S0165993613001544-main.pdf:application/pdf}
}

@article{armenta_role_2015-3,
	title = {The role of green extraction techniques in Green Analytical Chemistry},
	volume = {71},
	issn = {01659936},
	url = {http://linkinghub.elsevier.com/retrieve/pii/S0165993615001314},
	doi = {10.1016/j.trac.2014.12.011},
	pages = {2--8},
	journaltitle = {{TrAC} Trends in Analytical Chemistry},
	author = {Armenta, Sergio and Garrigues, Salvador and de la Guardia, Miguel},
	urldate = {2017-08-02},
	date = {2015-09},
	langid = {english},
	file = {1-s2.0-S0165993615001314-main.pdf:C\:\\Users\\nazmula\\Zotero\\storage\\EBVTD4T5\\1-s2.0-S0165993615001314-main.pdf:application/pdf}
}

@article{reyes-garces_effect_2018-1,
	title = {The effect of hematocrit on solid-phase microextraction},
	volume = {1001},
	issn = {0003-2670},
	url = {http://www.sciencedirect.com/science/article/pii/S0003267017312667},
	doi = {10.1016/j.aca.2017.11.014},
	abstract = {Solid-phase microextraction ({SPME}) is an approach to sample preparation that has demonstrated its appropriateness for isolating/enriching analytes present in complex biofluids with minimum sample pre-treatment. Several prior in vitro and in vivo studies have used {SPME} to monitor the concentrations of various drugs and metabolites in blood samples. In this work, we present the results of an investigation into how various levels of hematocrit (Hct) affect {SPME} recoveries. The matrices for this study consisted of whole blood samples that had been adjusted at three different Hct levels (20\%, 45\%, and 70\%), and the selected model compounds were drugs with different physicochemical characteristics (log P range from 0.33 to 6.36). In addition, two experimental setups were employed to conduct the extractions: hydrophilic lipophilic balanced ({HLB}) coated {SPME} devices ({HLB}-D) at 1500 rpm (vortex agitation), and mixed mode {SPME} fibres ({MM}-F) at 400 rpm (orbital shaking agitation). Our results demonstrated that the Hct effect in {SPME} is dependent on the analytes of interest, and that different outcomes can be attained by altering experimental conditions, such as coating type, convection, and extraction time. Interestingly, a target compound's relative affinity for the matrix components and for the coating material proved to be one of the main factors that determine the final effect that different erythrocyte levels have on {SPME} recoveries. Finally, although the Hct content affects each analyte differently and the final Hct effect depends on the experimental parameters, matrix variability can be corrected by using appropriate internal standards, thereby resulting in correct quantification.},
	pages = {40--50},
	journaltitle = {Analytica Chimica Acta},
	shortjournal = {Analytica Chimica Acta},
	author = {Reyes-Garcés, Nathaly and Alam, Md Nazmul and Pawliszyn, Janusz},
	urldate = {2020-01-07},
	date = {2018-02-25},
	langid = {english},
	keywords = {Blood, Hematocrit effect, Red blood cells, Sample preparation, Solid-phase microextraction, {SPME}},
	file = {ScienceDirect Snapshot:C\:\\Users\\nazmula\\Zotero\\storage\\BMJ6BJE3\\S0003267017312667.html:text/html}
}

license: MIT

license_type: permissive

branch_name: refs/heads/master


text:
DESCRIPTION = "List capabilities of sound devices"
HOMEPAGE = "http://www.volkerschatz.com/noise/alsa.html#alsacap"
SECTION = "devel/libs"
LICENSE = "ISC"
LIC_FILES_CHKSUM = "file://LICENSE;md5=9e398ba76be3f67dfe58740aa067c50c"

SRC_URI = "http://www.volkerschatz.com/noise/alsacap.tgz"

SRC_URI[md5sum] = "19642bdffd4666caa53344271aa585e9"

DEPENDS = "alsa-lib"
RDEPENDS_${PN} = "alsa-lib"

S = "${WORKDIR}/alsacap"

do_configure() {
	sed -i -e 's!gcc!$(CC) $(CFLAGS) $(LDFLAGS)!' Makefile
}

do_compile() {
	oe_runmake
}

do_install() {
	install -d ${D}/usr/bin/
	install -m 755 alsacap ${D}/usr/bin/
}

extension: bb


text:
@inproceedings{kumar-etal-2019-zero,
    title = "Zero-shot Word Sense Disambiguation using Sense Definition Embeddings",
    author = "Kumar, Sawan  and
      Jat, Sharmistha  and
      Saxena, Karan  and
      Talukdar, Partha",
    booktitle = "Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics",
    month = jul,
    year = "2019",
    address = "Florence, Italy",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/P19-1568",
    doi = "10.18653/v1/P19-1568",
    pages = "5670--5681",
}

url: https://raw.githubusercontent.com/Hugh-Shi/DL-NLP-Readings/924e4d189e5660c5b5d4854278f3df755ae2231d/Bibtex/Zero-shot Word Sense Disambiguation using Sense Definition Embeddings.bib

repository: Hugh-Shi/DL-NLP-Readings

repo_name: Hugh-Shi/DL-NLP-Readings

gha_license_id: MIT

extension: bib


text:
SECTION = "devel/chicken"
DESCRIPTION = "sql-de-lite support for awful"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://awful-sql-de-lite.meta;md5=cedc6a2441dc8ed6a0ecc3dd0ec69ac0"
DEPENDS_append_class-cross = " chicken-egg-awful-cross chicken-egg-sql-de-lite-cross"
DEPENDS_append_class-crosssdk = " chicken-egg-awful-crosssdk chicken-egg-sql-de-lite-crosssdk"
DEPENDS_append_class-nativesdk = " nativesdk-chicken-egg-awful nativesdk-chicken-egg-sql-de-lite chicken-egg-awful-crosssdk chicken-egg-sql-de-lite-crosssdk"
DEPENDS = " chicken-egg-awful chicken-egg-sql-de-lite chicken-egg-awful-cross chicken-egg-sql-de-lite-cross"
RDEPENDS_${PN} = " chicken-egg-awful chicken-egg-sql-de-lite"

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

SRC_URI[md5sum] = "1369b7ac0d9ebe2b61ad2efd1d802f46"
SRC_URI[sha256sum] = "5047f21a6fb7a71bb2145538c9827e1081fc20cf3fd3209c85f44e6a4137f993"

S = "${WORKDIR}/awful-sql-de-lite-${PV}"

inherit chicken_install

BBCLASSEXTEND = "cross crosssdk nativesdk"

repository: OSSystems/meta-chicken

repo_name: OSSystems/meta-chicken


text:
package zerotier

import (
	httper2 "github.com/IceWhaleTech/CasaOS/pkg/utils/httper"
	"github.com/tidwall/gjson"
	"net/http"
)

func PostData(url, token string, data string) interface{} {

	body, code := httper2.ZeroTierPostJson(url, data, GetHead(token))

	if code != http.StatusOK {
		return ""
	}
	result := gjson.Parse(body)
	return result.Value()
}

func GetData(url, token string) interface{} {

	body, code := httper2.ZeroTierGet(url, GetHead(token))

	if code != http.StatusOK {
		return ""
	}
	result := gjson.Parse(body)
	return result.Value()
}

func DeleteMember(url, token string) interface{} {

	body, code := httper2.ZeroTierDelete(url, GetHead(token))

	if code != http.StatusOK {
		return ""
	}
	result := gjson.Parse(body)
	return result.Value()
}

func GetHead(token string) map[string]string {
	var head = make(map[string]string)
	head["Authorization"] = "Bearer " + token
	head["Content-Type"] = "application/json"
	return head
}

repository: MaciejMacko/CasaOS

repo_name: MaciejMacko/CasaOS

branch_name: refs/heads/main

extension: go


text:
package writefile

import (
	"os"

	"github.com/KMACEL/IITR/errc"
)

/*
██╗    ██╗██████╗ ██╗████████╗███████╗        ███████╗██╗██╗     ███████╗
██║    ██║██╔══██╗██║╚══██╔══╝██╔════╝        ██╔════╝██║██║     ██╔════╝
██║ █╗ ██║██████╔╝██║   ██║   █████╗          █████╗  ██║██║     █████╗
██║███╗██║██╔══██╗██║   ██║   ██╔══╝          ██╔══╝  ██║██║     ██╔══╝
╚███╔███╔╝██║  ██║██║   ██║   ███████╗        ██║     ██║███████╗███████╗
 ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝   ╚═╝   ╚══════╝        ╚═╝     ╚═╝╚══════╝╚══════╝
*/
// WriteFile is a package created to print tests, reports, errors, and files.
// This package uses the 'os' library, especially the 'csv' format, for tabling data.
// This package can become direct communication from other packages.

/*
 ██████╗██████╗ ███████╗ █████╗ ████████╗███████╗        ███████╗██╗██╗     ███████╗
██╔════╝██╔══██╗██╔════╝██╔══██╗╚══██╔══╝██╔════╝        ██╔════╝██║██║     ██╔════╝
██║     ██████╔╝█████╗  ███████║   ██║   █████╗          █████╗  ██║██║     █████╗
██║     ██╔══██╗██╔══╝  ██╔══██║   ██║   ██╔══╝          ██╔══╝  ██║██║     ██╔══╝
╚██████╗██║  ██║███████╗██║  ██║   ██║   ███████╗        ██║     ██║███████╗███████╗
 ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝        ╚═╝     ╚═╝╚══════╝╚══════╝
*/

// CreateFile is used to create a new file. This function externally takes only
// a value of type "string" with the name "fileName". This value determines
// the name of the file to be created. This function performs util using the command "os.Create".
// The file is closed after it is created. This is the intent of the "defer" block.
func CreateFile(fileName string) {
	//open output file
	fc, errCreate := os.Create(fileName)
	if errCreate != nil {
		errc.ErrorCenter(createFileTag, errCreate)
		panic(errCreate)
	}

	defer func() {
		if errCreate = fc.Close(); errCreate != nil {
			errc.ErrorCenter(createFileTag, errCreate)
			panic(errCreate)
		}
	}()
}

/*
 ██████╗ ██████╗ ███████╗███╗   ██╗        ███████╗██╗██╗     ███████╗
██╔═══██╗██╔══██╗██╔════╝████╗  ██║        ██╔════╝██║██║     ██╔════╝
██║   ██║██████╔╝█████╗  ██╔██╗ ██║        █████╗  ██║██║     █████╗
██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║        ██╔══╝  ██║██║     ██╔══╝
╚██████╔╝██║     ███████╗██║ ╚████║        ██║     ██║███████╗███████╗
 ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝        ╚═╝     ╚═╝╚══════╝╚══════╝
*/

// OpenFile performs the opening process to write or read a file.
// This function takes two external values.
// openingFileName: This gets the name with the extension of the file to be opened.
//     If it is in the same folder as the program, only the name is enough.
// openedOSFile: This variable is important. Several files can be opened
//     at the same time and separate util can be performed on those files.
//     If you have a single "os.File" variable, you can not do the same operation.
//     For this reason, we expect the user to define a variable "var fileVarible * os.File"
//    instead of a constant variable and send this variable value to the "OpenFile" function.
//    This function returns the file that it opened in the form of "os.File" when opening.
//    Thus, when the file is opened, writing or reading util can be performed through the variable that returns easily.
//   Example Usage:
//      var openFile1 *os.File
//      writefile.CreateFile("testFile.csv")
//      openFile1 = writefile.OpenFile2("testFile.csv", openFile1)
func OpenFile(openedOSFile *os.File, openingFileName string) *os.File {
	if openedOSFile, errOpenFile := os.OpenFile(openingFileName, os.O_APPEND|os.O_WRONLY, os.ModeAppend); errOpenFile != nil {
		errc.ErrorCenter(openFileTag, errOpenFile)
		panic(errOpenFile)
	} else {
		return openedOSFile
	}
}

/*
██╗    ██╗██████╗ ██╗████████╗███████╗         █████╗ ██████╗ ██████╗  █████╗ ██╗   ██╗
██║    ██║██╔══██╗██║╚══██╔══╝██╔════╝        ██╔══██╗██╔══██╗██╔══██╗██╔══██╗╚██╗ ██╔╝
██║ █╗ ██║██████╔╝██║   ██║   █████╗          ███████║██████╔╝██████╔╝███████║ ╚████╔╝
██║███╗██║██╔══██╗██║   ██║   ██╔══╝          ██╔══██║██╔══██╗██╔══██╗██╔══██║  ╚██╔╝
╚███╔███╔╝██║  ██║██║   ██║   ███████╗        ██║  ██║██║  ██║██║  ██║██║  ██║   ██║
 ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝   ╚═╝   ╚══════╝        ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝
*/

// WriteArray writes the data received in the Array type to the opened file and closes that file. It takes two values.
// writeTextArray: takes an array of type string. This array is written to the file.
// openedFile: The file to be opened.
func WriteArray(openedFile *os.File, writeTextArray []string) {
	for _, text := range writeTextArray {
		//if !strings.Contains(text, "\n") {
		if _, errWriteArray := openedFile.WriteString(text + ","); errWriteArray != nil {
			errc.ErrorCenter(writeArrayTag, errWriteArray)
			panic(errWriteArray)
		}
		/*} else {
			if _, errWriteArray := openedFile.WriteString(text); errWriteArray != nil {
				errc.ErrorCenter(writeArrayTag, errWriteArray)
				panic(errWriteArray)
			}
		}*/
	}
	/*defer func() {
		if _, errWriteArray := openedFile.WriteString("\n"); errWriteArray != nil {
			errc.ErrorCenter(writeArrayTag, errWriteArray)
			panic(errWriteArray)
		}
	}()*/

}

/*
██╗    ██╗██████╗ ██╗████████╗███████╗        ██████╗ ██╗   ██╗████████╗███████╗
██║    ██║██╔══██╗██║╚══██╔══╝██╔════╝        ██╔══██╗╚██╗ ██╔╝╚══██╔══╝██╔════╝
██║ █╗ ██║██████╔╝██║   ██║   █████╗          ██████╔╝ ╚████╔╝    ██║   █████╗
██║███╗██║██╔══██╗██║   ██║   ██╔══╝          ██╔══██╗  ╚██╔╝     ██║   ██╔══╝
╚███╔███╔╝██║  ██║██║   ██║   ███████╗        ██████╔╝   ██║      ██║   ███████╗
 ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝   ╚═╝   ╚══════╝        ╚═════╝    ╚═╝      ╚═╝   ╚══════╝
*/

// WriteByte writes the data in the byte type received in the Array type to the opened file and closes that file. It takes two values.
// writeTextByte: takes an array of type byte. This array is written to the file.
// openedFile: The file to be opened.
func WriteByte(openedFile *os.File, writeTextByte []byte) {
	if _, errWriteByte := openedFile.Write(writeTextByte); errWriteByte != nil {
		errc.ErrorCenter(writeByteTag, errWriteByte)
		panic(errWriteByte)
	}
	defer func() {
		if _, errWriteByte := openedFile.WriteString("\n"); errWriteByte != nil {
			errc.ErrorCenter(writeByteTag, errWriteByte)
			panic(errWriteByte)
		}

	}()
}

/*
██╗    ██╗██████╗ ██╗████████╗███████╗        ████████╗███████╗██╗  ██╗████████╗
██║    ██║██╔══██╗██║╚══██╔══╝██╔════╝        ╚══██╔══╝██╔════╝╚██╗██╔╝╚══██╔══╝
██║ █╗ ██║██████╔╝██║   ██║   █████╗             ██║   █████╗   ╚███╔╝    ██║
██║███╗██║██╔══██╗██║   ██║   ██╔══╝             ██║   ██╔══╝   ██╔██╗    ██║
╚███╔███╔╝██║  ██║██║   ██║   ███████╗           ██║   ███████╗██╔╝ ██╗   ██║
 ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝   ╚═╝   ╚══════╝           ╚═╝   ╚══════╝╚═╝  ╚═╝   ╚═╝
*/

// WriteText retrieves data in series. A serial data stream gets the first line of a csv formatted data.
// Thus, how many columns have been filled in so many columns, how many times this function is called,
// will create as many lines. Unlike the others, the variable "os.File" comes first because it needs to be a variable terminator.
// openedFile: Specifies the file to be written.
// writeText: a serialized variable of type string. This function can be sent as a string type by putting "," between them.
func WriteText(openedFile *os.File, writeText ...string) {
	for _, text := range writeText {
		if _, errWriteText := openedFile.WriteString(text + SplitCharacter); errWriteText != nil {
			errc.ErrorCenter(writeTextTag, errWriteText)
			panic(errWriteText)
		}
	}
	defer func() {
		if _, errWriteText := openedFile.WriteString("\n"); errWriteText != nil {
			errc.ErrorCenter(writeTextTag, errWriteText)
			panic(errWriteText)
		}
	}()
}

repository: KMACEL/IITR

repo_name: KMACEL/IITR

gha_language: Go


text:
// SPDX-FileCopyrightText: 2021 SAP SE or an SAP affiliate company and Gardener contributors.
//
// SPDX-License-Identifier: Apache-2.0

package manifest_test

import (
	"context"
	"path/filepath"
	"testing"

	"github.com/go-logr/logr"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/client-go/kubernetes/scheme"

	manifestv1alpha2 "github.com/gardener/landscaper/apis/deployer/manifest/v1alpha2"

	lsv1alpha1 "github.com/gardener/landscaper/apis/core/v1alpha1"
	manifestv1alpha1 "github.com/gardener/landscaper/apis/deployer/manifest/v1alpha1"
	"github.com/gardener/landscaper/pkg/deployer/manifest"

	kutil "github.com/gardener/landscaper/pkg/utils/kubernetes"
	"github.com/gardener/landscaper/test/utils"
	"github.com/gardener/landscaper/test/utils/envtest"
)

func TestConfig(t *testing.T) {
	RegisterFailHandler(Fail)
	RunSpecs(t, "manifest Test Suite")
}

var (
	testenv     *envtest.Environment
	projectRoot = filepath.Join("../../../")
)

var _ = BeforeSuite(func() {
	var err error
	testenv, err = envtest.New(projectRoot)
	Expect(err).ToNot(HaveOccurred())

	_, err = testenv.Start()
	Expect(err).ToNot(HaveOccurred())
})

var _ = AfterSuite(func() {
	Expect(testenv.Stop()).ToNot(HaveOccurred())
})

var _ = Describe("Reconcile", func() {

	var (
		ctx   context.Context
		state *envtest.State
	)

	BeforeEach(func() {
		ctx = context.Background()
		var err error
		state, err = testenv.InitState(ctx)
		Expect(err).ToNot(HaveOccurred())
	})

	AfterEach(func() {
		defer ctx.Done()
		Expect(state.CleanupState(ctx, testenv.Client, nil)).To(Succeed())
	})

	It("should create a configured configmap", func() {
		target, err := utils.CreateKubernetesTarget(state.Namespace, "my-target", testenv.Env.Config)
		Expect(err).ToNot(HaveOccurred())
		Expect(state.Create(ctx, testenv.Client, target)).To(Succeed())

		cm := &corev1.ConfigMap{}
		cm.Name = "my-cm"
		cm.Namespace = state.Namespace
		cm.Data = map[string]string{
			"key": "val",
		}
		rawCM, err := kutil.ConvertToRawExtension(cm, scheme.Scheme)
		Expect(err).ToNot(HaveOccurred())

		manifestConfig := &manifestv1alpha1.ProviderConfiguration{}
		manifestConfig.Manifests = []*runtime.RawExtension{
			rawCM,
		}
		item, err := manifest.NewDeployItemBuilder().
			Key(state.Namespace, "myitem").
			ProviderConfig(manifestConfig).
			Target(target.Namespace, target.Name).
			Build()
		Expect(err).ToNot(HaveOccurred())
		Expect(state.Create(ctx, testenv.Client, item)).To(Succeed())

		m, err := manifest.New(logr.Discard(), testenv.Client, testenv.Client, &manifestv1alpha2.Configuration{}, item, target)
		Expect(err).ToNot(HaveOccurred())

		Expect(m.Reconcile(ctx)).To(Succeed())

		cmRes := &corev1.ConfigMap{}
		Expect(testenv.Client.Get(ctx, kutil.ObjectKeyFromObject(cm), cmRes)).To(Succeed())
		Expect(cmRes.Data).To(HaveKeyWithValue("key", "val"))
	})

	It("should create a configured configmap with a kubeconfig target referenced by secret", func() {
		kubeconfigBytes, err := kutil.GenerateKubeconfigBytes(testenv.Env.Config)
		Expect(err).ToNot(HaveOccurred())
		kSecret := &corev1.Secret{}
		kSecret.Name = "my-target"
		kSecret.Namespace = state.Namespace
		kSecret.Data = map[string][]byte{
			lsv1alpha1.DefaultKubeconfigKey: kubeconfigBytes,
		}
		Expect(state.Create(ctx, testenv.Client, kSecret)).To(Succeed())

		target, err := utils.CreateKubernetesTargetFromSecret(state.Namespace, "my-target", kSecret)
		Expect(err).ToNot(HaveOccurred())
		Expect(state.Create(ctx, testenv.Client, target)).To(Succeed())

		cm := &corev1.ConfigMap{}
		cm.Name = "my-cm"
		cm.Namespace = state.Namespace
		cm.Data = map[string]string{
			"key": "val",
		}
		rawCM, err := kutil.ConvertToRawExtension(cm, scheme.Scheme)
		Expect(err).ToNot(HaveOccurred())

		manifestConfig := &manifestv1alpha1.ProviderConfiguration{}
		manifestConfig.Manifests = []*runtime.RawExtension{
			rawCM,
		}
		item, err := manifest.NewDeployItemBuilder().
			Key(state.Namespace, "myitem").
			ProviderConfig(manifestConfig).
			Target(target.Namespace, target.Name).
			Build()
		Expect(err).ToNot(HaveOccurred())
		Expect(state.Create(ctx, testenv.Client, item)).To(Succeed())

		m, err := manifest.New(logr.Discard(), testenv.Client, testenv.Client, &manifestv1alpha2.Configuration{}, item, target)
		Expect(err).ToNot(HaveOccurred())

		Expect(m.Reconcile(ctx)).To(Succeed())

		cmRes := &corev1.ConfigMap{}
		Expect(testenv.Client.Get(ctx, kutil.ObjectKeyFromObject(cm), cmRes)).To(Succeed())
		Expect(cmRes.Data).To(HaveKeyWithValue("key", "val"))
	})
})

repository: jfortin-sap-zz/landscaper

repo_name: jfortin-sap-zz/landscaper


text:
@article{bezanson2017julia,
  title={Julia: A fresh approach to numerical computing},
  author={Bezanson, Jeff and Edelman, Alan and Karpinski, Stefan and Shah, Viral B},
  journal={SIAM review},
  volume={59},
  number={1},
  pages={65--98},
  year={2017},
  publisher={SIAM},
  doi={10.1137/141000671}
}

@article{Richardson:72,
author = {William Hadley Richardson},
journal = {J. Opt. Soc. Am.},
keywords = {Arrays; Deconvolution; Image processing; Point spread function},
number = {1},
pages = {55--59},
publisher = {OSA},
title = {Bayesian-Based Iterative Method of Image Restoration$\ast$},
volume = {62},
month = {Jan},
year = {1972},
url = {http://www.osapublishing.org/abstract.cfm?URI=josa-62-1-55},
doi = {10.1364/JOSA.62.000055},
abstract = {An iterative method of restoring degraded images was developed by treating images, point spread functions, and degraded images as probability-frequency functions and by applying Bayes's theorem. The method functions effectively in the presence of noise and is adaptable to computer operation.},
}

@ARTICLE{lucy:74,
       author = {{Lucy}, L.~B.},
        title = "{An iterative technique for the rectification of observed distributions}",
      journal = {Astronomical Journal},
         year = 1974,
        month = jun,
       volume = {79},
        pages = {745},
          doi = {10.1086/111605},
}

@book{wiener2013extrapolation,
  title={Extrapolation, Interpolation, and Smoothing of Stationary Time Series, with Engineering Applications},
  author={Wiener, Nobert},
  year={1949},
  publisher={Wiley},
  doi={2946.001.0001}
}

@InProceedings{Kruse_2017_ICCV,
author = {Kruse, Jakob and Rother, Carsten and Schmidt, Uwe},
title = {Learning to Push the Limits of Efficient {FFT}-Based Image Deconvolution},
booktitle = {Proceedings of the IEEE International Conference on Computer Vision (ICCV)},
month = {Oct},
year = {2017},
doi={10.1109/ICCV.2017.491}
}

@Article{FFTW05,
  author = 	 {Frigo, Matteo and Johnson, Steven~G.},
  title = 	 {The Design and Implementation of {FFTW3}},
  journal = 	 {Proceedings of the IEEE},
  year = 	 2005,
  volume =	 93,
  number =	 2,
  pages =	 {216--231},
  note =	 {Special issue on ``Program Generation, Optimization, and Platform Adaptation''},
  doi = {10.1109/JPROC.2004.840301}
}

@article{mogensen2018optim,
  author  = {Mogensen, Patrick Kofod and Riseth, Asbj{\o}rn Nilsen},
  title   = {Optim: A mathematical optimization package for {Julia}},
  journal = {Journal of Open Source Software},
  year    = {2018},
  volume  = {3},
  number  = {24},
  pages   = {615},
  doi     = {10.21105/joss.00615}
}

@article{besard2018juliagpu,
  author        = {Besard, Tim and Foket, Christophe and De Sutter, Bjorn},
  title         = {Effective Extensible Programming: Unleashing {Julia} on {GPUs}},
  journal       = {IEEE Transactions on Parallel and Distributed Systems},
  year          = {2018},
  doi           = {10.1109/TPDS.2018.2872064},
  ISSN          = {1045-9219},
  archivePrefix = {arXiv},
  eprint        = {1712.03112},
  primaryClass  = {cs.PL},
}

@article{Zygote.jl-2018,
  author    = {Michael Innes},
  title     = {Don't Unroll Adjoint: Differentiating {SSA}-Form Programs},
  journal   = {CoRR},
  volume    = {abs/1810.07951},
  year      = {2018},
  url       = {http://arxiv.org/abs/1810.07951},
  archivePrefix = {arXiv},
  eprint    = {1810.07951},
  timestamp = {Tue, 30 Oct 2018 20:39:56 +0100},
  biburl    = {https://dblp.org/rec/bib/journals/corr/abs-1810-07951},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  doi = {10.48550/arXiv.1810.07951}
}

@article{LBFGS,
author = {Liu, Dong C. and Nocedal, Jorge},
title = {On the Limited Memory BFGS Method for Large Scale Optimization},
year = {1989},
issue_date = {August    1989},
publisher = {Springer-Verlag},
address = {Berlin, Heidelberg},
volume = {45},
number = {1–3},
issn = {0025-5610},
abstract = {We study the numerical performance of a limited memory quasi-Newton method for large scale optimization, which we call the L-BFGS method. We compare its performance with that of the method developed by Buckley and LeNir (1985), which combines cycles of BFGS steps and conjugate direction steps. Our numerical tests indicate that the L-BFGS method is faster than the method of Buckley and LeNir, and is better able to use additional storage to accelerate convergence. We show that the L-BFGS method can be greatly accelerated by means of a simple scaling. We then compare the L-BFGS method with the partitioned quasi-Newton method of Griewank and Toint (1982a). The results show that, for some problems, the partitioned quasi-Newton method is clearly superior to the L-BFGS method. However we find that for other problems the L-BFGS method is very competitive due to its low iteration cost. We also study the convergence properties of the L-BFGS method, and prove global convergence on uniformly convex problems.},
journal = {Math. Program.},
month = aug,
pages = {503–528},
numpages = {26},
keywords = {conjugate gradient method, Large scale nonlinear optimization, partitioned quasi-Newton method, limited memory methods},
doi = {10.1007/BF01589116}
}

@article{Verveer:98,
author = {Peter J. Verveer and Thomas M. Jovin},
journal = {J. Opt. Soc. Am. A},
keywords = {Deconvolution; Image reconstruction-restoration; Inverse problems; Three-dimensional image processing; Confocal microscopy; Fluorescence microscopy; Biological imaging; Confocal laser scanning microscopy; Fluorescence microscopy; Image restoration; Refractive index; Three dimensional imaging},
number = {5},
pages = {1077--1083},
publisher = {OSA},
title = {Image restoration based on Good's roughness penalty with application to fluorescence microscopy},
volume = {15},
month = {May},
year = {1998},
url = {http://josaa.osa.org/abstract.cfm?URI=josaa-15-5-1077},
doi = {10.1364/JOSAA.15.001077},
abstract = {We present efficient algorithms for image restoration by means of Good's roughness penalty. We assume Gaussian or Poisson statistics for the noise and derive an algorithm for each case. Performance is tested by simulated three-dimensional imaging with a fluorescence confocal laser scanning microscope. Results are compared with those for algorithms that use Gaussian or entropy penalty terms, which we derived previously \[J. Opt. Soc. Am. A14, 1696 (1997)\]. The algorithms based on Good's roughness yield superior results. An example is given of the restoration of an image of a biological specimen.},
}

@article{Good:71,
 ISSN = {00063444},
 URL = {http://www.jstor.org/stable/2334515},
 abstract = {Given a number of observations x1, ..., xN, a nonparametric method is suggested for estimating the entire probability density curve. The method is to subtract a roughness penalty from the log likelihood, where the roughness penalty is a certain functional of the assumed density function f. Those used are linear combinations of ∫ γ'2 dx and ∫ γ"2 dx, where γ = √ f. The method appears to be consistent under wide conditions, although consistent methods can be rough. Numerical examples are given and show that for certain values of the coefficient in this linear expression the density function turns out to be very smooth even when N is small. Multivariate extensions are proposed, including one to distributions having some continuous and some discrete components, but numerical examples of these have not been tried. Some of the techniques are borrowed from quantum mechanics and tensor calculus.},
 author = {I. J. Good and R. A. Gaskins},
 journal = {Biometrika},
 number = {2},
 pages = {255--277},
 publisher = {[Oxford University Press, Biometrika Trust]},
 title = {Nonparametric Roughness Penalties for Probability Densities},
 volume = {58},
 year = {1971},
 doi = {10.2307/2334515},
}

@article{jax2018github,
  author = {James Bradbury and Roy Frostig and Peter Hawkins and Matthew James Johnson and Chris Leary and Dougal Maclaurin and George Necula and Adam Paszke and Jake Vander{P}las and Skye Wanderman-{M}ilne and Qiao Zhang},
  title = {{JAX}: composable transformations of {P}ython+{N}um{P}y programs},
  url = {http://github.com/google/jax},
  version = {0.2.5},
  year = {2018},
  journal={GitHub}
}

@article{deconvlab2,
    AUTHOR="Sage, D. and Donati, L. and Soulez, F. and Fortun, D. and Schmit, G. and Seitz, A. and Guiet, R. and Vonesch, C. and Unser, M.",
    TITLE="{D}econvolution{L}ab2: {A}n Open-Source Software for
            Deconvolution Microscopy",
    JOURNAL="Methods---Image Processing for Biologists",
    YEAR="2017",
    volume="115",
    number="",
    pages="28--41",
    doi = {10.1016/j.ymeth.2016.12.015},
    month="February 15,",
    note=""
}

@article{ikoma2018convex,
  title={A convex {3D} deconvolution algorithm for low photon count fluorescence imaging},
  author={Ikoma, Hayato and Broxton, Michael and Kudo, Takamasa and Wetzstein, Gordon},
  doi = {10.1038/s41598-018-29768-x},
  journal={Scientific reports},
  volume={8},
  number={1},
  pages={11489},
  year={2018},
  publisher={Nature Publishing Group}
}

@inproceedings{CUDA,
author = {Nickolls, John and Buck, Ian and Garland, Michael and Skadron, Kevin},
title = {Scalable Parallel Programming with {CUDA}},
year = {2008},
isbn = {9781450378451},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1401132.1401152},
doi = {10.1145/1401132.1401152},
abstract = {Is CUDA the parallel programming model that application developers have been waiting for?},
booktitle = {ACM SIGGRAPH 2008 Classes},
articleno = {16},
numpages = {14},
location = {Los Angeles, California},
series = {SIGGRAPH '08}
}

@article{rel_energy_regain,
title = {Estimating missing information by maximum likelihood deconvolution},
journal = {Micron},
volume = {38},
number = {2},
pages = {136-144},
year = {2007},
note = {Special issue on Super-resolution and other Novel Microscopies},
issn = {0968-4328},
doi = {10.1016/j.micron.2006.07.009},
url = {https://www.sciencedirect.com/science/article/pii/S0968432806001272},
author = {Rainer Heintzmann},
keywords = {Deblurring, Fluorescence microscopy, Quality criterion, Bandwidth extension},
abstract = {The ability of iteratively constrained maximum likelihood (ML) deconvolution to reconstruct out-of-band information is discussed and exemplified by simulations. The frequency dependent relative energy regain, a novel way of quantifying the reconstruction ability, is introduced. The positivity constraint of ML deconvolution allows reconstructing information outside the spatial frequency bandwidth which is set by the optical system. This is demonstrated for noise-free and noisy data. It is also shown that this property depends on the type of object under investigation. An object is constructed where no significant out-of-band reconstruction is possible. It is concluded that in practical situations the amount of possible out-of-band reconstruction depends on the agreement between reality and the model describing “typical objects” incorporated into the algorithm by appropriate penalty functions.}
}

@book{Mertz:2019,
    place={Cambridge},
    edition={2},
    title={Introduction to Optical Microscopy},
    DOI={10.1017/9781108552660},
    publisher={Cambridge University Press},
    author={Mertz, Jerome},
    year={2019}
}

@misc{michael_abbott_2021_5047410,
    author       = {Michael Abbott and
                    Dilum Aluthge and
                    N3N5 and
                    Simeon Schaub and
                    Carlo Lucibello and
                    Chris Elrod and
                    Johnny Chen},
    title        = {{mcabbott/Tullio.jl: v0.3.0}},
    month        = jun,
    year         = 2021,
    publisher    = {Zenodo},
    version      = {v0.3.0},
    doi          = {10.5281/zenodo.5047410},
    url          = {https://doi.org/10.5281/zenodo.5047410}
}

@article{besard2019prototyping,
 publisher     = {Elsevier},
 pages         = {29--46},
 author        = {Besard, Tim and Churavy, Valentin and Edelman, Alan and De Sutter, Bjorn},
 year          = {2019},
 volume        = {132},
 journal       = {Advances in Engineering Software},
 title         = {Rapid software prototyping for heterogeneous and distributed platforms},
 doi = {10.1016/j.advengsoft.2019.02.002}
}

@misc{BenchmarkTools.jl-2016,
 primaryClass  = {cs.PF},
 author        = {{Chen}, Jiahao and {Revels}, Jarrett},
 adsnote       = {Provided by the SAO/NASA Astrophysics Data System},
 month         = {Aug},
 journal       = {arXiv e-prints},
 archivePrefix = {arXiv},
 title         = {{Robust benchmarking in noisy environments}},
 eid           = {arXiv:1608.04295},
 keywords      = {Computer Science - Performance, 68N30, B.8.1, D.2.5},
 eprint        = {1608.04295},
 year          = {2016},
 url           = {https://arxiv.org/abs/1608.04295},
 adsurl        = {https://ui.adsabs.harvard.edu/abs/2016arXiv160804295C},
 doi           = {10.48550/arXiv.1608.04295}
}

@article{DifferentialEquations.jl-2017,
 author        = {Rackauckas, Christopher and Nie, Qing},
 journal       = {The Journal of Open Research Software},
 title         = {DifferentialEquations.jl – A Performant and Feature-Rich Ecosystem for Solving Differential Equations in Julia},
 number        = {1},
 doi           = {10.5334/jors.151},
 keywords      = {Applied Mathematics},
 note          = {Exported from https://app.dimensions.ai on 2019/05/05},
 year          = {2017},
 url           = {https://app.dimensions.ai/details/publication/pub.1085583166 and http://openresearchsoftware.metajnl.com/articles/10.5334/jors.151/galley/245/download/},
 volume        = {5}
}

@article{LLVM.jl-2017,
  author    = {Besard, Tim and Foket, Christophe and De Sutter, Bjorn},
  title     = {Effective Extensible Programming: Unleashing {Julia} on {GPUs}},
  journal   = {IEEE Transactions on Parallel and Distributed Systems},
  year      = {2018},
  doi       = {10.1109/TPDS.2018.2872064},
  ISSN      = {1045-9219},
}

gha_language: Julia


text:
@book{FultzINSbook,
  author = {Fultz, Brent and Kelly, Tim and Lin, Jiao Y Y and Lee, JaeDong and Delaire, Olivier and Kresch, Max and McKerns, Mike and Aivazis, Michael},
  title = {Experimental Inelastic Neutron Scattering with a Chopper Spectrometer},
  year = {2006-2016},
  url = {http://www.cacr.caltech.edu/projects/danse/doc/Inelastic_Book.pdf},
}

@article{KreschNickel2007,
  title = {Neutron scattering measurements of phonons in nickel at elevated temperatures},
  author = {Kresch, M. and Delaire, O. and Stevens, R. and Lin, J. Y. Y. and Fultz, B.},
  journal = {Phys. Rev. B},
  volume = {75},
  issue = {10},
  pages = {104301},
  numpages = {7},
  year = {2007},
  month = {Mar},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevB.75.104301},
  url = {https://link.aps.org/doi/10.1103/PhysRevB.75.104301}
}

@book{ashcroftmermin,
  title={Solid State Physics},
  author={Ashcroft, N.W. and Mermin, N.D.},
  isbn={9788131500521},
  year={2011},
  publisher={Cengage Learning}
}

@article{lichen2015,
  title={Orbitally driven giant phonon anharmonicity in SnSe},
  author={Li, Chen W and Hong, Jiawang and May, Andrew F and Bansal, Dipanshu and Chi, Songxue and Hong, Tao and Ehlers, Georg and Delaire, O},
  journal={Nature Physics},
  volume={11},
  number={12},
  pages={1063},
  year={2015},
  publisher={Nature Publishing Group},
  doi={10.1038/nphys3492}
}

@article{budai2014,
  title={Metallization of vanadium dioxide driven by large phonon entropy},
  author={Budai, John D and Hong, Jiawang and Manley, Michael E and Specht, Eliot D and Li, Chen W and Tischler, Jonathan Z and Abernathy, Douglas L and Said, Ayman H and Leu, Bogdan M and Boatner, Lynn A and others},
  journal={Nature},
  volume={515},
  number={7528},
  pages={535},
  year={2014},
  publisher={Nature Publishing Group},
  doi={10.1038/nature13865}
}

@article{FULTZ2010,
title = "Vibrational thermodynamics of materials",
journal = "Progress in Materials Science",
volume = "55",
number = "4",
pages = "247 - 352",
year = "2010",
issn = "0079-6425",
doi = "https://doi.org/10.1016/j.pmatsci.2009.05.002",
url = "http://www.sciencedirect.com/science/article/pii/S0079642509000577",
author = "Brent Fultz"
}

@phdthesis{swan2006vibrational,
  title={Vibrational entropy contributions to the phase stability of iron-and aluminum-based binary alloys},
  author={Swan-Wood, Tabitha Liana},
  year={2006},
  school={California Institute of Technology},
  url={http://resolver.caltech.edu/CaltechETD:etd-09012005-143247}
}

@phdthesis{bogdanoff2002phonon,
  title={The phonon entropy of metals and alloys: the effects of thermal and chemical disorder},
  author={Bogdanoff, Peter David},
  year={2002},
  school={California Institute of Technology},
  url={http://resolver.caltech.edu/CaltechETD:etd-12272005-154952}
}

repository: granrothge/multiphonon

repo_name: granrothge/multiphonon


text:
@article{bartle,
    abstract = {{Four approaches to playing MUDs are identified and described. These approaches may arise from the inter-relationship of two dimensions of playing style: action versus interaction, and world-oriented versus player-oriented. An account of the dynamics of player populations is given in terms of these dimensions, with particular attention to how to promote balance or equilibrium. This analysis also offers an explanation for the labelling of MUDs as being either "social" or "gamelike".}},
    author = {Bartle, Richard A.},
    citeulike-article-id = {801903},
    citeulike-linkout-0 = {http://www.mud.co.uk/richard/hcds.htm},
    journal = {Journal of MUD Research},
    keywords = {player-types},
    posted-at = {2013-04-05 15:36:43},
    priority = {2},
    title = {{Hearts, Clubs, Diamonds, Spades: Players Who Suit MUDs}},
    url = {http://www.mud.co.uk/richard/hcds.htm},
    year = {1996}
}

@misc{ wiki:socialgames,
  author = {{Social-network game}},
  title = "Social-network game --- {W}ikipedia{,} The Free Encyclopedia",
  year = "2010",
  url = "https://en.wikipedia.org/wiki/Social-network_game",
  note = "[Online; accessed 26-October-2017]"
}

@misc{ gamifieduk,
  author = {{52 Gamification Mechanics and Elements}},
  title = "52 Gamification Mechanics and Elements --- Gamified.UK",
  year = "2017",
  url = "",
  note = "[Online; accessed 26-October-2017]"
}


text:
package psmdb

import (
	"crypto/rand"
	"encoding/json"
	"math/big"
	mrand "math/rand"
	"time"

	"github.com/Percona-Lab/percona-dbaas-cli/dbaas-lib/k8s"
	"github.com/Percona-Lab/percona-dbaas-cli/dbaas-lib/structs"
	"github.com/pkg/errors"
)

// CreateDBCluster start creating DB cluster
func (p *PSMDB) CreateDBCluster(name, opts, rootPass string) error {
	err := p.ParseOptions(opts)
	if err != nil {
		return errors.Wrap(err, "parse opts")
	}
	p.conf.SetName(name)
	p.conf.SetUsersSecretName(name)

	switch p.platformType {
	case k8s.PlatformMinishift, k8s.PlatformMinikube:
		p.conf.SetupMiniConfig()
	}

	if len(rootPass) > 0 {
		err = p.SetupPasswords(name, rootPass)
		if err != nil {
			return errors.Wrap(err, "set root password")
		}
	}

	cr, err := p.getCR(p.conf)
	if err != nil {
		return errors.Wrap(err, "get cr")
	}

	err = p.cmd.CreateCluster("psmdb", p.conf.GetOperatorImage(), name, cr, p.bundle(objects, p.conf.GetOperatorImage()))
	if err != nil {
		return errors.Wrap(err, "create cluster")
	}

	return nil
}

// DeleteDBCluster delete cluster by name
func (p *PSMDB) DeleteDBCluster(name, opts string, delePVC bool) (string, error) {
	ext, err := p.cmd.IsObjExists("psmdb", name)
	if err != nil {
		return "", errors.Wrap(err, "check if cluster exists")
	}
	if !ext {
		return "", errors.New("unable to find cluster psmdb/" + name)
	}
	err = p.cmd.DeleteCluster("psmdb", p.operatorName(), name, delePVC)
	if err != nil {
		return "", errors.Wrap(err, "delete cluster")
	}
	if !delePVC {
		pvcObj, err := p.cmd.GetObject("pvc", "mongod-data-"+name+"-rs0-0")
		if err != nil {
			return "", errors.Wrap(err, "get pvc")
		}
		pvc := &k8sPVC{}
		err = json.Unmarshal(pvcObj, pvc)
		if err != nil {
			return "", errors.Wrap(err, "unmarshal pvc")
		}
		return "pvc/" + pvc.Meta.Name, nil
	}
	err = p.cmd.DeleteObject("secret", name+"-psmdb-users-secrets")
	if err != nil {
		return "", errors.Wrap(err, "delete secret")
	}

	return "", nil
}

// GetDBCluster return DB object
func (p *PSMDB) GetDBCluster(name, opts string) (structs.DB, error) {
	var db structs.DB
	secrets, err := p.cmd.GetSecrets(name + "-psmdb-users-secrets")
	if err != nil {
		return db, errors.Wrap(err, "get cluster secrets")

	}
	cluster, err := p.cmd.GetObject("psmdb", name)
	if err != nil {
		return db, errors.Wrap(err, "get cluster object")

	}
	st := &k8sStatus{}
	err = json.Unmarshal(cluster, st)
	if err != nil {
		return db, errors.Wrap(err, "unmarshal object")
	}
	ns, err := p.cmd.GetCurrentNamespace()
	if err != nil {
		return db, errors.Wrap(err, "get namspace name")
	}
	if len(ns) == 0 {
		ns = "default"
	}
	db.Provider = provider
	db.Engine = engine
	db.ResourceName = name
	db.ResourceEndpoint = name + "-rs0." + ns + ".psmdb.svc.local"
	db.Port = 27017
	db.User = string(secrets["MONGODB_CLUSTER_ADMIN_USER"])
	db.Pass = string(secrets["MONGODB_CLUSTER_ADMIN_PASSWORD"])
	db.Status = string(st.Status.Status)
	if st.Status.Status == "ready" {
		db.Message = "To access database please run the following commands:\nkubectl port-forward svc/" + name + "-rs0 27017:27017 &\nmongo mongodb://" + db.User + ":PASSWORD@localhost:27017/admin?ssl=false"
	}

	return db, nil
}

// GetDBClusterList return list of existing DB obkects
func (p *PSMDB) GetDBClusterList() ([]structs.DB, error) {
	var dbList []structs.DB
	cluster, err := p.cmd.GetObjects("psmdb")
	if err != nil {
		return dbList, errors.Wrap(err, "get cluster object")

	}
	st := &k8sCluster{}
	err = json.Unmarshal(cluster, st)
	if err != nil {
		return dbList, errors.Wrap(err, "unmarshal object")
	}
	for _, c := range st.Items {
		db := structs.DB{
			ResourceName: c.Meta.Name,
			Status:       string(c.Status.Status),
		}
		dbList = append(dbList, db)
	}

	return dbList, nil
}

// UpdateDBCluster update DB
func (p *PSMDB) UpdateDBCluster(name, opts string) error {
	c := objects[defaultVersion].psmdb
	oldCR, err := p.cmd.GetObject("psmdb", name)
	if err != nil {
		return errors.Wrap(err, "get cluster cr")
	}
	err = json.Unmarshal(oldCR, &c)
	if err != nil {
		return errors.Wrap(err, "unmarshal cr")
	}
	p.conf = c
	p.ParseOptions(opts)
	p.conf.SetName(name)
	p.conf.SetUsersSecretName(name)
	cr, err := p.getCR(p.conf)
	if err != nil {
		return errors.Wrap(err, "get cr")
	}
	err = p.cmd.Upgrade("psmdb", name, cr)
	if err != nil {
		return errors.Wrap(err, "upgrade cluster")
	}

	return nil
}

func (p *PSMDB) SetupPasswords(clusterName, rootPass string) error {
	secretName := clusterName + "-psmdb-users-secrets"
	ext, err := p.cmd.IsObjExists("secret", secretName)
	if err != nil {
		return errors.Wrap(err, "check if secrets exists")
	}
	data := map[string][]byte{}
	if ext {
		data, err = p.cmd.GetSecrets(secretName)
		if err != nil {
			return errors.Wrap(err, "get secrets")
		}
		for k := range data {
			if k == "MONGODB_CLUSTER_ADMIN_PASSWORD" {
				data[k] = []byte(rootPass)
			}
		}
		err = p.cmd.UpdateSecrets(secretName, data)
		if err != nil {
			return errors.Wrap(err, "update secrets")
		}

		return nil
	}

	data["MONGODB_BACKUP_USER"] = []byte("backup")
	data["MONGODB_BACKUP_PASSWORD"], err = generatePass()
	if err != nil {
		return errors.Wrap(err, "create backup users pass")
	}
	data["MONGODB_CLUSTER_ADMIN_USER"] = []byte("clusterAdmin")
	data["MONGODB_CLUSTER_ADMIN_PASSWORD"] = []byte(rootPass)
	data["MONGODB_CLUSTER_MONITOR_USER"] = []byte("clusterMonitor")
	data["MONGODB_CLUSTER_MONITOR_PASSWORD"], err = generatePass()
	if err != nil {
		return errors.Wrap(err, "create cluster monitor users pass")
	}
	data["MONGODB_USER_ADMIN_USER"] = []byte("userAdmin")
	data["MONGODB_USER_ADMIN_PASSWORD"], err = generatePass()
	if err != nil {
		return errors.Wrap(err, "create admin users pass")
	}

	err = p.cmd.CreateSecret(secretName, data)
	if err != nil {
		return errors.Wrap(err, "create secrets")
	}

	return nil
}

const (
	passwordMaxLen = 20
	passwordMinLen = 16
	passSymbols    = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
		"abcdefghijklmnopqrstuvwxyz" +
		"0123456789"
)

func generatePass() ([]byte, error) {
	mrand.Seed(time.Now().UnixNano())
	ln := mrand.Intn(passwordMaxLen-passwordMinLen) + passwordMinLen
	b := make([]byte, ln)
	for i := 0; i < ln; i++ {
		randInt, err := rand.Int(rand.Reader, big.NewInt(int64(len(passSymbols))))
		if err != nil {
			return nil, err
		}
		b[i] = passSymbols[randInt.Int64()]
	}

	return b, nil
}

repository: EvgeniyPatlan/percona-dbaas-cli

repo_name: EvgeniyPatlan/percona-dbaas-cli


text:
DESCRIPTION = "Robust and configurable e-mail client for GNOME"
HOMEPAGE = "http://pawsa.fedorapeople.org/balsa/"
SECTION = "x11/network"
LICENSE = "GPL"
SRC_URI = "http://pawsa.fedorapeople.org/balsa/${P}.tar.bz2 \
           file://obsolete-icon.patch"
PR = "r0"

DEPENDS = "glib-2.0 gmime gnome-icon-theme gtk+ intltool-native libesmtp libxml-parser-perl-native"
RDEPENDS_${PN} = "gnome-icon-theme"
# FIXME: It is possible to build several variants of balsa: lite (SSL, gqlite/GPE, maybe HTML),
# standard (GNOME, spell checking, HTML), full (Kerberos, LDAP, PGP, Rubrica, X-Face)

# Options for regular expressions are: NONE (POSIX) glib-2.0 (GRegex) libpcre (PCRE)
DEPENDS += ""

# Options for remote activation are: libbonobo libunique
DEPENDS += "libunique"

# Options for HTML view are: gtkhtml-2.0(gtkhtml2) gtkhtml-3.0(gtkhtml3) webkit-gtk(webkit) NONE
DEPENDS += "webkit-gtk"

# Optional dependencies (missing in OE): Spell checking
#DEPENDS += "gtkspell"

# Optional dependencies: desktop notification:
DEPENDS += "libnotify"

# Optional dependencies: SSL support:
DEPENDS += "openssl"

# Optional dependencies: GPE addressbook:
DEPENDS += "sqlite"

# Optional dependencies: GNOME:
DEPENDS += "gconf libgnome libgnomeui"
#DEPENDS += "gnome-keyring"

# Optional dependencies: PGP support:
#DEPENDS += "gpgme"

# Optional dependencies: view source:
#DEPENDS += "gtksourceview2"

# Optional dependencies: LDAP:
#DEPENDS += "openldap"

# Options for optional Kerberos 5: heimdal (not in OE) krb5
#DEPENDS += "krb5"

# Optional dependencies: automatic online/offline with NetworkManager:
#DEPENDS += "networkmanager"

# Optional dependencies: Rubrica addressbook:
#DEPENDS += "libxml2"

# Optional dependencies (not yet in OE): X-Face support:
#DEPENDS += "compface"

# Optional dependencies: sound support:
#DEPENDS += "libcanberra"

# FIXME: doc build requires docbook4 and gnome-doc-utils

inherit autotools gtk-icon-cache

EXTRA_OECONF="--with-ssl \
	      --without-gnome \
	      --disable-scrollkeeper \
	      --enable-smime \
	      --with-sqlite \
	      --with-ssl \
	      --with-html-widget=webkit \
	      --with-unique \
	      --without-gtkspell \
	      --without-nm \
"
# Broken (does not compile, crashes after symbol fix):
#	      --enable-touch-ui \
# Not enabled:
#	      --with-gtkspell \
#	      --with-gpgme \
#	      --with-gtksourceview \
#	      --with-rubrica \
#	      --with-gss \
#	      --with-ldap \
#	      --with-compface \
#	      --with-canberra \

do_configure_prepend() {
	# aclocal seems to insist on looking in here.  Make sure it exists.
	mkdir -p ${S}/m4
}

SRC_URI[md5sum] = "fb9597446dfe8adcfae4a0928da336f7"
SRC_URI[sha256sum] = "581326a68a52f8344c900ca47d862536821bc5864c38b09cb6c333722a212952"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
require iptables.inc

DEPENDS += "libnfnetlink"

inherit autotools
EXTRA_OECONF = "--with-kernel=${STAGING_INCDIR} \
                ${@base_contains('DISTRO_FEATURES', 'ipv6', '', '--disable-ipv6', d)}"

PR = "${INC_PR}.1"

SRC_URI[iptables-1.4.9.1.md5sum] = "fbadfb0b5f2dbda49e0ad06a798898e3"
SRC_URI[iptables-1.4.9.1.sha256sum] = "0550f7ba7a170811dcf9b2df65036999786d84040b767238effc40232f617839"

PACKAGES =+ "${PN}-osf"

FILES_${PN}-osf = "${sbindir}/nfnl_osf ${datadir}/xtables"


text:
@article{RN1693,
 author = {Marini, K. D. and Croucher, D. R. and McCloy, R. A. and Vaghjiani, V. and Gonzalez-Rajal, A. and Hastings, J. F. and Chin, V. and Szczepny, A. and Kostyrko, K. and Marquez, C. and Jayasekara, W. S. N. and Alamgeer, M. and Boolell, V. and Han, J. Z. R. and Waugh, T. and Lee, H. C. and Oakes, S. R. and Kumar, B. and Harrison, C. A. and Hedger, M. P. and Lorensuhewa, N. and Kita, B. and Barrow, R. and Robinson, B. W. and de Kretser, D. M. and Wu, J. and Ganju, V. and Sweet-Cordero, E. A. and Burgess, A. and Martelotto, L. G. and Rossello, F. J. and Cain, J. E. and Watkins, D. N.},
 doi = {10.1126/scitranslmed.aat3504},
 issn = {1946-6242 (Electronic)
1946-6234 (Linking)},
 journal = {Sci Transl Med},
 number = {451},
 pages = {eaat3504},
 title = {Inhibition of activin signaling in lung adenocarcinoma increases the therapeutic index of platinum chemotherapy},
 type = {Journal Article},
 url = {https://www.ncbi.nlm.nih.gov/pubmed/30045976},
 volume = {10},
 year = {2018}
}

repository: laoshancai/ccb-home

repo_name: laoshancai/ccb-home


text:
require gpe-nmf.inc

RRECOMMENDS_${PN} += "gst-plugin-tcp"
PR = "r1"

SRC_URI[md5sum] = "28e1ff870af9b38d0cce345d339b857a"
SRC_URI[sha256sum] = "e3f89854fde8db448bd60fad1dce9a89aae994e75fa0cfdf97888891563e7232"


text:
package model

// Provides additional information such as the registration details.
type CorporateActionNarrative30 struct {

	// Provides information required for the registration.
	RegistrationDetails []*Max350Text `xml:"RegnDtls,omitempty"`

	// Provides additional information regarding the party, for example, the contact unit or person responsible for the transaction identified in the message.
	PartyContactNarrative []*Max350Text `xml:"PtyCtctNrrtv,omitempty"`

	// Provides information required for the certification/breakdown.
	CertificationBreakdown []*Max350Text `xml:"CertfctnBrkdwn,omitempty"`
}

func (c *CorporateActionNarrative30) AddRegistrationDetails(value string) {
	c.RegistrationDetails = append(c.RegistrationDetails, (*Max350Text)(&value))
}

func (c *CorporateActionNarrative30) AddPartyContactNarrative(value string) {
	c.PartyContactNarrative = append(c.PartyContactNarrative, (*Max350Text)(&value))
}

func (c *CorporateActionNarrative30) AddCertificationBreakdown(value string) {
	c.CertificationBreakdown = append(c.CertificationBreakdown, (*Max350Text)(&value))
}


text:
package __performance_status

import (
	"context"
	"encoding/json"

	ign2types "github.com/coreos/ignition/config/v2_2/types"
	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	tunedv1 "github.com/openshift/cluster-node-tuning-operator/pkg/apis/tuned/v1"
	v1 "github.com/openshift/custom-resource-status/conditions/v1"
	machineconfigv1 "github.com/openshift/machine-config-operator/pkg/apis/machineconfiguration.openshift.io/v1"
	"k8s.io/apimachinery/pkg/runtime"

	"github.com/openshift/cluster-node-tuning-operator/pkg/performanceprofile/controller/performanceprofile/components"
	testutils "github.com/openshift/cluster-node-tuning-operator/test/e2e/performanceprofile/functests/utils"
	testclient "github.com/openshift/cluster-node-tuning-operator/test/e2e/performanceprofile/functests/utils/client"
	"github.com/openshift/cluster-node-tuning-operator/test/e2e/performanceprofile/functests/utils/discovery"
	"github.com/openshift/cluster-node-tuning-operator/test/e2e/performanceprofile/functests/utils/mcps"
	"github.com/openshift/cluster-node-tuning-operator/test/e2e/performanceprofile/functests/utils/nodes"
	"github.com/openshift/cluster-node-tuning-operator/test/e2e/performanceprofile/functests/utils/profiles"

	corev1 "k8s.io/api/core/v1"
	nodev1 "k8s.io/api/node/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	utilrand "k8s.io/apimachinery/pkg/util/rand"
)

var _ = Describe("Status testing of performance profile", Ordered, func() {
	var (
		workerCNFNodes []corev1.Node
		err            error
		clean          func() error
	)

	BeforeEach(func() {
		if discovery.Enabled() && testutils.ProfileNotFound {
			Skip("Discovery mode enabled, performance profile not found")
		}
		workerCNFNodes, err = nodes.GetByLabels(testutils.NodeSelectorLabels)
		Expect(err).ToNot(HaveOccurred())
		workerCNFNodes, err = nodes.MatchingOptionalSelector(workerCNFNodes)
		Expect(err).ToNot(HaveOccurred(), "error looking for the optional selector: %v", err)
		Expect(workerCNFNodes).ToNot(BeEmpty())
		// initialized clean function handler to be nil on every It execution
		clean = nil
	})

	AfterEach(func() {
		if clean != nil {
			Expect(clean(), "failed to cleanup in AfterEach")
		}

	})

	Context("[rfe_id:28881][performance] Performance Addons detailed status", func() {

		It("[test_id:30894] Tuned status name tied to Performance Profile", func() {
			profile, err := profiles.GetByNodeLabels(testutils.NodeSelectorLabels)
			Expect(err).ToNot(HaveOccurred())
			key := types.NamespacedName{
				Name:      components.GetComponentName(profile.Name, components.ProfileNamePerformance),
				Namespace: components.NamespaceNodeTuningOperator,
			}
			tuned := &tunedv1.Tuned{}
			err = testclient.GetWithRetry(context.TODO(), key, tuned)
			Expect(err).ToNot(HaveOccurred(), "cannot find the Cluster Node Tuning Operator Tuned object "+key.String())
			tunedNamespacedname := types.NamespacedName{
				Name:      components.GetComponentName(profile.Name, components.ProfileNamePerformance),
				Namespace: components.NamespaceNodeTuningOperator,
			}
			tunedStatus := tunedNamespacedname.String()
			Expect(profile.Status.Tuned).NotTo(BeNil())
			Expect(*profile.Status.Tuned).To(Equal(tunedStatus))
		})

		It("[test_id:33791] Should include the generated runtime class name", func() {
			profile, err := profiles.GetByNodeLabels(testutils.NodeSelectorLabels)
			Expect(err).ToNot(HaveOccurred())

			key := types.NamespacedName{
				Name:      components.GetComponentName(profile.Name, components.ComponentNamePrefix),
				Namespace: metav1.NamespaceAll,
			}
			runtimeClass := &nodev1.RuntimeClass{}
			err = testclient.GetWithRetry(context.TODO(), key, runtimeClass)
			Expect(err).ToNot(HaveOccurred(), "cannot find the RuntimeClass object "+key.String())

			Expect(profile.Status.RuntimeClass).NotTo(BeNil())
			Expect(*profile.Status.RuntimeClass).To(Equal(runtimeClass.Name))
		})

		It("[test_id:29673] Machine config pools status tied to Performance Profile", func() {
			// Creating bad MC that leads to degraded state
			By("Creating bad MachineConfig")
			badMC := createBadMachineConfig("bad-mc")
			err = testclient.Client.Create(context.TODO(), badMC)
			Expect(err).ToNot(HaveOccurred())

			By("Wait for MCP condition to be Degraded")
			profile, err := profiles.GetByNodeLabels(testutils.NodeSelectorLabels)
			Expect(err).ToNot(HaveOccurred())
			performanceMCP, err := mcps.GetByProfile(profile)
			Expect(err).ToNot(HaveOccurred())
			mcps.WaitForCondition(performanceMCP, machineconfigv1.MachineConfigPoolDegraded, corev1.ConditionTrue)
			mcpConditionReason := mcps.GetConditionReason(performanceMCP, machineconfigv1.MachineConfigPoolDegraded)
			profileConditionMessage := profiles.GetConditionMessage(testutils.NodeSelectorLabels, v1.ConditionDegraded)
			// Verify the status reason of performance profile
			Expect(profileConditionMessage).To(ContainSubstring(mcpConditionReason))

			By("Deleting bad MachineConfig and waiting when Degraded state is removed")
			err = testclient.Client.Delete(context.TODO(), badMC)
			Expect(err).ToNot(HaveOccurred())

			mcps.WaitForCondition(performanceMCP, machineconfigv1.MachineConfigPoolUpdated, corev1.ConditionTrue)
		})

		It("[test_id:40402] Tuned profile status tied to Performance Profile", func() {
			// During this test we're creating additional synthetic tuned CR by invoking the createrBadTuned function.
			// This synthetic tuned will look for a tuned profile which doesn't exist.
			// This tuned CR will be applied on the profiles.tuned.openshift.io CR (there is such profile per node)
			// which is associate to the node object with the same name.
			// The connection between the node object and the tuned object is via the MachineConfigLables, worker-cnf in our case.
			ns := "openshift-cluster-node-tuning-operator"
			tunedName := "openshift-cause-tuned-failure"

			// Make sure to clean badTuned object even if the It threw an error
			clean = func() error {
				key := types.NamespacedName{
					Name:      tunedName,
					Namespace: ns,
				}
				runtimeClass := &tunedv1.Tuned{}
				err := testclient.Client.Get(context.TODO(), key, runtimeClass)
				// if err != nil probably the resource were already deleted
				if err == nil {
					Expect(testclient.Client.Delete(context.TODO(), runtimeClass), "failed to delete runtimeClass %q", runtimeClass.Name)
				}
				return err
			}

			// Creating bad Tuned object that leads to degraded state
			badTuned := createBadTuned(tunedName, ns)
			err = testclient.Client.Create(context.TODO(), badTuned)
			Expect(err).ToNot(HaveOccurred())

			By("Waiting for performance profile condition to be Degraded")
			profiles.WaitForCondition(testutils.NodeSelectorLabels, v1.ConditionDegraded, corev1.ConditionTrue)

			By("Deleting bad Tuned and waiting when Degraded state is removed")
			err = testclient.Client.Delete(context.TODO(), badTuned)
			profiles.WaitForCondition(testutils.NodeSelectorLabels, v1.ConditionAvailable, corev1.ConditionTrue)
		})
	})
})

func createBadMachineConfig(name string) *machineconfigv1.MachineConfig {
	rawIgnition, _ := json.Marshal(
		&ign2types.Config{
			Ignition: ign2types.Ignition{
				Version: ign2types.MaxVersion.String(),
			},
			Storage: ign2types.Storage{
				Disks: []ign2types.Disk{
					{
						Device: "/one",
					},
				},
			},
		},
	)

	return &machineconfigv1.MachineConfig{
		TypeMeta: metav1.TypeMeta{
			APIVersion: machineconfigv1.SchemeGroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:   name,
			Labels: map[string]string{"machineconfiguration.openshift.io/role": testutils.RoleWorkerCNF},
			UID:    types.UID(utilrand.String(5)),
		},
		Spec: machineconfigv1.MachineConfigSpec{
			OSImageURL: "",
			Config: runtime.RawExtension{
				Raw: rawIgnition,
			},
		},
	}
}

func createBadTuned(name, ns string) *tunedv1.Tuned {
	priority := uint64(20)
	// include=profile-does-not-exist
	// points to tuned profile which doesn't exist
	data := "[main]\nsummary=A Tuned daemon profile that does not exist\ninclude=profile-does-not-exist"

	return &tunedv1.Tuned{
		TypeMeta: metav1.TypeMeta{
			APIVersion: tunedv1.SchemeGroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: ns,
			UID:       types.UID(utilrand.String(5)),
		},
		Spec: tunedv1.TunedSpec{
			Profile: []tunedv1.TunedProfile{
				{
					Name: &name,
					Data: &data,
				},
			},
			Recommend: []tunedv1.TunedRecommend{
				{
					MachineConfigLabels: map[string]string{"machineconfiguration.openshift.io/role": testutils.RoleWorkerCNF},
					Priority:            &priority,
					Profile:             &name,
				},
			},
		},
	}

}

repository: openshift/cluster-node-tuning-operator

repo_name: openshift/cluster-node-tuning-operator


text:
package v1_test

import (
	"context"
	"log"
	"os"
	"testing"

	"google.golang.org/grpc"

	v1 "github.com/mee6aas/zeep/pkg/api/invoker/v1"
	grpcServer "github.com/mee6aas/zeep/pkg/protocol/grpc"
	inokerV1 "github.com/mee6aas/zeep/pkg/service/invoker/v1"
)

const (
	testServerAddress = "localhost:5123"
)

var (
	testGrpcServer   = grpc.NewServer()
	testServerHandle = &mockHandle{}
	ctxTestServer    context.Context
	stopTestServer   context.CancelFunc

	testConn   *grpc.ClientConn
	testClient v1.InvokerClient
)

func TestMain(m *testing.M) {
	var err error

	log.SetFlags(log.LstdFlags | log.Lshortfile)

	ctxTestServer, stopTestServer = context.WithCancel(context.Background())
	v1.RegisterInvokerServer(testGrpcServer, inokerV1.NewInvokerAPIServer(testServerHandle))

	go grpcServer.Serve(ctxTestServer, testGrpcServer, testServerAddress)

	if testConn, err = grpc.Dial(testServerAddress, grpc.WithInsecure()); err != nil {
		panic(err)
	}

	testClient = v1.NewInvokerClient(testConn)

	log.Println("Inoker API client created")

	code := m.Run()
	stopTestServer()
	os.Exit(code)
}


text:
package ssh

import (
	"golang.org/x/crypto/ssh"
)

// getSshSignerFromPkcs11 return ssh.Signer[] from pkcs11 token
func (c *Connect) getSshSignerFromPkcs11(server string) (signers []ssh.Signer, err error) {
	conf := c.Conf.Server[server]
	pkcs11Provider := conf.PKCS11Provider
	pkcs11PIN := conf.PKCS11PIN

	p := new(P11)
	p.PIN = pkcs11PIN

	// create pkcs11 ctx
	err = p.CreateCtx(pkcs11Provider)
	if err != nil {
		return
	}

	// get token label
	err = p.GetTokenLabel()
	if err != nil {
		return
	}

	// get PIN code
	err = p.GetPIN()
	if err != nil {
		return
	}

	// recreate ctx (pkcs11=>crypto11)
	err = p.RecreateCtx(pkcs11Provider)
	if err != nil {
		return
	}

	// get KeyID
	err = p.GetKeyID()
	if err != nil {
		return
	}

	// get crypto signers
	cryptoSigners, err := p.GetCryptoSigner()
	if err != nil {
		return
	}

	// TODO(blacknon): ↑までを別のfunctionにして、CryptoSignerを別に分ける(CertAuth時に鍵ファイルをPKCS11で扱えるようにするため。)

	for _, cryptoSigner := range cryptoSigners {
		signer, _ := ssh.NewSignerFromSigner(cryptoSigner)
		signers = append(signers, signer)
	}

	return
}

repository: kevinburke/lssh

repo_name: kevinburke/lssh


text:
const assert = require('assert')
const findByMinFitness = require('./')

const arr1 = [
  100,
  350,
  200
]

let result

// Search for nearest value to 300
result = findByMinFitness(arr1, (val) => {
  return 300 - val
})
assert.equal(result, 350)

// Search for nearest to 120 ignoring lower values
result = findByMinFitness(arr1, (val) => {
  if (val < 120) {
    // returning false will means this will be ignored
    return false
  } else {
    return 120 - val
  }
})
assert.equal(result, 200)

// Search for nearest to 199 heigher lower values
result = findByMinFitness(arr1, (val) => {
  if (val > 199) {
    return false
  } else {
    return 199 - val
  }
})
assert.equal(result, 100)

// Handles negatice values: Find nearest to 2
let arr2 = [
  -20,
  30,
  50
]
result = findByMinFitness(arr2, (val) => {
  return -10 - val
})
assert.equal(result, -20)

// Handle an empty array
result = findByMinFitness([], (val) => {
  return val // shouldn't even be called
})
assert.equal(result, null)

repository: bencevans/find-by-min-fitness

repo_name: bencevans/find-by-min-fitness

extension: js


text:
DESCRIPTION = "Poppler is a PDF rendering library based on the xpdf-3.0 code base."
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=751419260aa954499f7abaabaa882bbe"

SRC_URI = " \
    http://poppler.freedesktop.org/${PN}-${PV}.tar.gz \
"
SRC_URI[md5sum] = "49d55921ce795778c7231fe9f2fe923b"
SRC_URI[sha256sum] = "4f438f34e63265e2da8427f3423f940ff41c26088922a9f5d976f795c1dce13b"

DEPENDS = "fontconfig jpeg zlib gtk+ cairo tiff lcms"

inherit autotools pkgconfig

EXTRA_OECONF = "\
    --enable-xpdf-headers \
    --disable-gtk-test \
    --disable-poppler-qt4 \
    --enable-zlib \
"

# check for TARGET_FPU=soft and inform configure of the result so it can disable some floating points
def get_poppler_fpu_setting(bb, d):
    if d.getVar('TARGET_FPU', 1) in [ 'soft' ]:
        return "--enable-fixedpoint"
    return ""

EXTRA_OECONF += "${@get_poppler_fpu_setting(bb, d)}"

PACKAGES =+ "libpoppler libpoppler-glib"
FILES_libpoppler = "${libdir}/libpoppler.so.*"
FILES_libpoppler-glib = "${libdir}/libpoppler-glib.so.*"

RDEPENDS_${PN} = "poppler-data"

repository: ExorEmbedded/exor-workspace

repo_name: ExorEmbedded/exor-workspace

gha_language: Python


text:
@article{einstein,
    author =       "Alberti Einsteion",
    title =        "{Zur Elektrodynamik bewegter K{\"o}rper}. ({German})
        [{On} the electrodynamics of moving bodies]",
    journal =      "Annalen der Physik",
    volume =       "322",
    number =       "10",
    pages =        "891--921",
    year =         "1905",
    DOI =          "http://dx.doi.org/10.1002/andp.19053221004"
}

@book{latexcompanion,
    author    = "Michel Goossens and Frank Mittelbach and Alexander Samarin",
    title     = "The \LaTeX\ Companion",
    year      = "1993",
    publisher = "Addison-Wesley",
    address   = "Reading, Massachusetts"
}

@book{dsbook,
	author    = " Andrew S. Tanenbaum",
	title     = "Distributed Systems",
	year      = "2017",

}

@misc{knuthwebsite,
    author    = "Donald Knuth",
    title     = "Knuth: Computers and Typesetting",
    url       = "http://www-cs-faculty.stanford.edu/\~{}uno/abcde.html"
}

@misc{lbpcmysql,
	author    = "Leah Beatty",
	title     = "The Pros and Cons of MySQL",
	howpublished = "\url{https://www.smartfile.com/blog/the-pros-and-cons-of-mysql/}",
	url       = "https://www.smartfile.com/blog/the-pros-and-cons-of-mysql/",
	note ="[Online; accessed 12-Novemer-2019]"
}

@misc{sdpost,
	author    = "Stuti Dhruv",
	title     = "Pros and Cons of using PostgreSQL for Application Development",
	howpublished = "\url{https://www.aalpha.net/blog/pros-and-cons-of-using-postgresql-for-application-development/}",
	url       = "https://www.aalpha.net/blog/pros-and-cons-of-using-postgresql-for-application-development/",
	note ="[Online; accessed 12-Novemer-2019]"
}

@misc{gdbad,
	author    = "Mingxi Wu",
	title     = "What Are the Major Advantages of Using a Graph Database? ",
	howpublished = "\url{https://dzone.com/articles/what-are-the-pros-and-cons-of-using-a-graph-databa}",

	note ="[Online; accessed 29-Novemer-2019]"
}

@misc{gdbcomparison,
	author    = "solid IT",
	title     = "System Properties Comparison Datastax Enterprise vs. Neo4j vs. TigerGraph",
	howpublished = "\url{https://db-engines.com/en/system/Datastax+Enterprise%3BNeo4j%3BTigerGraph}",

	note ="[Online; accessed 29-Novemer-2019]"
}
@misc{agilemanifesto,
	author    = "Kent Beck and
	Mike Beedle and
	Arie van Bennekum and
	Alistair Cockburn and
	Ward Cunningham and
	Martin Fowler and
	James Grenning and
	Jim Highsmith and
	Andrew Hunt and
	Ron Jeffries and
	Jon Kern and
	Brian Marick and
	Robert C. Martin and
	Steve Mellor and
	Ken Schwaber and
	Jeff Sutherland and
	Dave Thomas",
	title     = "Manifesto for Agile Software Development ".
	howpublished = "\url{http://agilemanifesto.org/}",

	note ="[Online; accessed 11-Novemer-2019]"
}

@misc{dockeradv,
	author    = "Sergey C.
	and	Sviatoslav A. ",
	title     = "Advantages of Using Docker for Microservices ",
	howpublished = "\url{https://rubygarage.org/blog/advantages-of-using-docker-for-microservices}",

	note ="[Online; accessed 29-Novemer-2019]"
}

gha_language: JavaScript


text:
@article{FrazierCliftonCarlsonHarris.2014:Stand-alone,
	Author = {Frazier, Lyn and Clifton, Jr., Charles and Katy Carlson and Jesse A. Harris},
	Journal = {Language, Cognition and Neuroscience},
	Keywords = {prosody, local coherence},
	Number = {10},
	Pages = {1519-1544},
	Title = {Standing alone with prosodic help},
	Volume = {28},
	Year = {2014}}


text:
package crm

import (
    "encoding/xml"

    "github.com/bububa/opentaobao/model"
)

/*
会员等级营销-等级营销活动查询 APIResponse
taobao.crm.grademkt.member.detail.query

商家通过该接口查询等级营销活动
*/
type TaobaoCrmGrademktMemberDetailQueryAPIResponse struct {
    model.CommonResponse
    TaobaoCrmGrademktMemberDetailQueryResponse
}

type TaobaoCrmGrademktMemberDetailQueryResponse struct {
    XMLName xml.Name `xml:"crm_grademkt_member_detail_query_response"`
	RequestId     string         `json:"request_id,omitempty" xml:"request_id,omitempty"`         // 平台颁发的每次请求访问的唯一标识

    // totalCount为记录总数

    Model   string `json:"model,omitempty" xml:"model,omitempty"`

}

repository: phpyandong/opentaobao

repo_name: phpyandong/opentaobao