text:
@proceedings{ws-2018-abusive,
    title = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    editor = "Fi{\v{s}}er, Darja  and
      Huang, Ruihong  and
      Prabhakaran, Vinodkumar  and
      Voigt, Rob  and
      Waseem, Zeerak  and
      Wernimont, Jacqueline",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5100",
}
@inproceedings{mishra-etal-2018-neural,
    title = "Neural Character-based Composition Models for Abuse Detection",
    author = "Mishra, Pushkar  and
      Yannakoudakis, Helen  and
      Shutova, Ekaterina",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5101",
    doi = "10.18653/v1/W18-5101",
    pages = "1--10",
}
@inproceedings{de-gibert-etal-2018-hate,
    title = "Hate Speech Dataset from a White Supremacy Forum",
    author = "de Gibert, Ona  and
      Perez, Naiara  and
      Garc{\'\i}a-Pablos, Aitor  and
      Cuadros, Montse",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5102",
    doi = "10.18653/v1/W18-5102",
    pages = "11--20",
}
@inproceedings{gunasekara-nejadgholi-2018-review,
    title = "A Review of Standard Text Classification Practices for Multi-label Toxicity Identification of Online Content",
    author = "Gunasekara, Isuru  and
      Nejadgholi, Isar",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5103",
    doi = "10.18653/v1/W18-5103",
    pages = "21--25",
}
@inproceedings{kshirsagar-etal-2018-predictive,
    title = "Predictive Embeddings for Hate Speech Detection on Twitter",
    author = "Kshirsagar, Rohan  and
      Cukuvac, Tyrus  and
      McKeown, Kathy  and
      McGregor, Susan",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5104",
    doi = "10.18653/v1/W18-5104",
    pages = "26--32",
}
@inproceedings{van-aken-etal-2018-challenges,
    title = "Challenges for Toxic Comment Classification: An In-Depth Error Analysis",
    author = {van Aken, Betty  and
      Risch, Julian  and
      Krestel, Ralf  and
      L{\"o}ser, Alexander},
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5105",
    doi = "10.18653/v1/W18-5105",
    pages = "33--42",
}
@inproceedings{singh-etal-2018-aggression,
    title = "Aggression Detection on Social Media Text Using Deep Neural Networks",
    author = "Singh, Vinay  and
      Varshney, Aman  and
      Akhtar, Syed Sarfaraz  and
      Vijay, Deepanshu  and
      Shrivastava, Manish",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5106",
    doi = "10.18653/v1/W18-5106",
    pages = "43--50",
}
@inproceedings{sprugnoli-etal-2018-creating,
    title = "Creating a {W}hats{A}pp Dataset to Study Pre-teen Cyberbullying",
    author = "Sprugnoli, Rachele  and
      Menini, Stefano  and
      Tonelli, Sara  and
      Oncini, Filippo  and
      Piras, Enrico",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5107",
    doi = "10.18653/v1/W18-5107",
    pages = "51--59",
}
@inproceedings{svec-etal-2018-improving,
    title = "Improving Moderation of Online Discussions via Interpretable Neural Models",
    author = "{\v{S}}vec, Andrej  and
      Pikuliak, Mat{\'u}{\v{s}}  and
      {\v{S}}imko, Mari{\'a}n  and
      Bielikov{\'a}, M{\'a}ria",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5108",
    doi = "10.18653/v1/W18-5108",
    pages = "60--65",
}
@inproceedings{caines-etal-2018-aggressive,
    title = "Aggressive language in an online hacking forum",
    author = "Caines, Andrew  and
      Pastrana, Sergio  and
      Hutchings, Alice  and
      Buttery, Paula",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5109",
    doi = "10.18653/v1/W18-5109",
    pages = "66--74",
}
@inproceedings{fehn-unsvag-gamback-2018-effects,
    title = "The Effects of User Features on Twitter Hate Speech Detection",
    author = {Fehn Unsv{\aa}g, Elise  and
      Gamb{\"a}ck, Bj{\"o}rn},
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5110",
    doi = "10.18653/v1/W18-5110",
    pages = "75--85",
}
@inproceedings{wang-2018-interpreting,
    title = "Interpreting Neural Network Hate Speech Classifiers",
    author = "Wang, Cindy",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5111",
    doi = "10.18653/v1/W18-5111",
    pages = "86--92",
}
@inproceedings{magu-luo-2018-determining,
    title = "Determining Code Words in Euphemistic Hate Speech Using Word Embedding Networks",
    author = "Magu, Rijul  and
      Luo, Jiebo",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5112",
    doi = "10.18653/v1/W18-5112",
    pages = "93--100",
}
@inproceedings{lee-etal-2018-comparative,
    title = "Comparative Studies of Detecting Abusive Language on Twitter",
    author = "Lee, Younghun  and
      Yoon, Seunghyun  and
      Jung, Kyomin",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5113",
    doi = "10.18653/v1/W18-5113",
    pages = "101--106",
}
@inproceedings{sharifirad-etal-2018-boosting,
    title = "Boosting Text Classification Performance on Sexist Tweets by Text Augmentation and Text Generation Using a Combination of Knowledge Graphs",
    author = "Sharifirad, Sima  and
      Jafarpour, Borna  and
      Matwin, Stan",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5114",
    doi = "10.18653/v1/W18-5114",
    pages = "107--114",
}
@inproceedings{sahlgren-etal-2018-learning,
    title = "Learning Representations for Detecting Abusive Language",
    author = "Sahlgren, Magnus  and
      Isbister, Tim  and
      Olsson, Fredrik",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5115",
    doi = "10.18653/v1/W18-5115",
    pages = "115--123",
}
@inproceedings{ljubesic-etal-2018-datasets,
    title = "Datasets of {S}lovene and {C}roatian Moderated News Comments",
    author = "Ljube{\v{s}}i{\'c}, Nikola  and
      Erjavec, Toma{\v{z}}  and
      Fi{\v{s}}er, Darja",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5116",
    doi = "10.18653/v1/W18-5116",
    pages = "124--131",
}
@inproceedings{karan-snajder-2018-cross,
    title = "Cross-Domain Detection of Abusive Language Online",
    author = "Karan, Mladen  and
      {\v{S}}najder, Jan",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5117",
    doi = "10.18653/v1/W18-5117",
    pages = "132--137",
}
@inproceedings{mathur-etal-2018-offend,
    title = "Did you offend me? Classification of Offensive Tweets in {H}inglish Language",
    author = "Mathur, Puneet  and
      Sawhney, Ramit  and
      Ayyar, Meghna  and
      Shah, Rajiv",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5118",
    doi = "10.18653/v1/W18-5118",
    pages = "138--148",
}
@inproceedings{wu-etal-2018-decipherment,
    title = "Decipherment for Adversarial Offensive Language Detection",
    author = "Wu, Zhelun  and
      Kambhatla, Nishant  and
      Sarkar, Anoop",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5119",
    doi = "10.18653/v1/W18-5119",
    pages = "149--159",
}
@inproceedings{castelle-2018-linguistic,
    title = "The Linguistic Ideologies of Deep Abusive Language Classification",
    author = "Castelle, Michael",
    booktitle = "Proceedings of the 2nd Workshop on Abusive Language Online ({ALW}2)",
    month = oct,
    year = "2018",
    address = "Brussels, Belgium",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-5120",
    doi = "10.18653/v1/W18-5120",
    pages = "160--170",
}


text:
@article{caliskan_active_2019,
 author = {Caliskan, Can and Burak, Abdurrahman and Turkmen, Esref and Yazici, Melik and Gurbuz, Yasar},
 doi = {10.1109/TCSII.2019.2896526},
 issn = {1549-7747, 1558-3791},
 journal = {IEEE Transactions on Circuits and Systems II: Express Briefs},
 pages = {1--1},
 title = {Active Positive Sloped Equalizer for X-Band SiGe BiCMOS Phased Array Applications},
 url = {https://ieeexplore.ieee.org/document/8630066/},
 urldate = {2019-08-14},
 year = {2019}
}

license: MIT

repository: melikyazici/academic-kickstart

license_type: permissive

repo_name: melikyazici/academic-kickstart

branch_name: refs/heads/master

extension: bib


text:
package main

import (
	"testing"
)

func TestHasNick(t *testing.T) {
	ch := &Channel{nicklist: &nicklist{nicks: []string{"aaa", "bbb", "ccc"}}}
	if !ch.HasNick("bbb") {
		t.Errorf("hasNick(\"bbb\") == false")
	}

	if ch.HasNick("ddd") {
		t.Errorf("hasNick(\"ddd\") == true")
	}
}

func TestRemoveNick(t *testing.T) {
	ch := &Channel{nicklist: &nicklist{nicks: []string{}}}
	ch.RemoveNick("aaa")

	ch = &Channel{nicklist: &nicklist{nicks: []string{"aaa"}}}
	ch.RemoveNick("bbb")
	if ch.nicks[0] != "aaa" {
		t.Errorf("ch.nicks[0] != \"aaa\"")
	}

	ch.RemoveNick("aaa")
	if len(ch.nicks) != 0 {
		t.Errorf("ch.nicks != []string{}")
	}
}

func TestInsertNick(t *testing.T) {
	ch := &Channel{nicklist: &nicklist{nicks: []string{}}}
	ch.InsertNick("aaa")
	if ch.nicks[0] != "aaa" {
		t.Errorf("ch.nicks[0] != \"aaa\"")
	}

	ch.InsertNick("bbb")
	if ch.nicks[1] != "bbb" {
		t.Errorf("ch.nicks[1] != \"bbb\"")
	}

	ch.InsertNick("aaa")
	if len(ch.nicks) != 2 {
		t.Errorf("len(ch.nicks) != 2")
	}
}

func TestSetNicks(t *testing.T) {
	ch := &Channel{nicklist: &nicklist{nicks: []string{}}}
	ch.SetNicks([]string{"bbb", "aaa"})

	if ch.nicks[0] != "aaa" || ch.nicks[1] != "bbb" {
		t.Errorf("ch.nicks[0] != \"aaa\" || ch.nicks[1] != \"bbb\"")
	}
}

license: ISC

repository: qcoh/fenrirc

repo_name: qcoh/fenrirc

extension: go


text:
set(CMAKE_C_COMPILER "no-C-compiler")
set(CMAKE_CXX_COMPILER "no-CXX-compiler")
project(BadCompilerCandCXXInner C CXX)
message(FATAL_ERROR "This error should not be reached.")

extension: cmake


text:
DESCRIPTION = "Xfce4 Widget library and X Window System interaction"
SECTION = "x11/libs"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=252890d9eee26aab7b432e8b8a616475"
PR = "r1"
DEPENDS = "gtk+ intltool libxfce4util startup-notification xfconf glade3"

inherit xfce

SRC_URI += "file://0001-libxfce4kbd-private-xfce4-keyboard-shortcuts.xml-fix.patch"
SRC_URI[md5sum] = "6df1ce474a3d4885aee31cda9dbc9192"
SRC_URI[sha256sum] = "a2b9fa288ccb5f16fa13264e507ba3f7b8da0176da259a11239f21538c0ea3e2"

FILES_${PN}-dbg += "${libdir}/glade3/modules/.debug"
FILES_${PN}-dev += "${libdir}/glade3/modules/*.la \
                   ${datadir}/glade3/catalogs/*.in"
PACKAGES += "${PN}-glade"
FILES_${PN}-glade = "${libdir}/glade3 \
                     ${datadir}/glade3"

repository: linkessence/Galileo

repo_name: linkessence/Galileo

extension: bb


text:
package subnetworks

import (
	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
)

func cmp(a, b externalapi.DomainSubnetworkID) int {
	// We compare the hashes backwards because Hash is stored as a little endian byte array.
	for i := externalapi.DomainSubnetworkIDSize - 1; i >= 0; i-- {
		switch {
		case a[i] < b[i]:
			return -1
		case a[i] > b[i]:
			return 1
		}
	}
	return 0
}

// Less returns true iff id a is less than id b
func Less(a, b externalapi.DomainSubnetworkID) bool {
	return cmp(a, b) < 0
}

repository: aorji/kaspad

repo_name: aorji/kaspad

gha_license_id: ISC

gha_language: Go


text:
package log

import (
	"github.com/TeaWeb/code/tealogs"
	"github.com/iwind/TeaGo/actions"
	"time"
)

type ResponseHeaderAction actions.Action

// 响应Header
func (this *ResponseHeaderAction) Run(params struct {
	LogId string
}) {
	query := tealogs.NewQuery()
	query.From(time.Now())
	query.Id(params.LogId)
	accessLog, err := query.Find()
	if err != nil {
		this.Fail(err.Error())
	}

	if accessLog != nil {
		this.Data["headers"] = accessLog.SentHeader
	} else {
		this.Data["headers"] = map[string][]string{}
	}

	this.Data["body"] = string(accessLog.ResponseBodyData)

	this.Success()
}


text:
package blobstore

import (
	"bytes"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"

	"golang.org/x/crypto/chacha20poly1305"

	"github.com/beardedfoo/blobstore/backend"
	"github.com/beardedfoo/masterkey"
)

// Authenticate hashing operations with a 256-bit subkey
const hmacSubKeyID = "checksum"
const hmacKeySize = 32

// New returns a Blobstore which uses HMAC-SHA-256 and ChaCha20
func New(b backend.Backend, key masterkey.MasterKey) Blobstore {
	return Blobstore{
		masterKey: key,
		backend: b,
	}
}

// Blobstore provides secure access to a blobstore through a backend storage implementation
type Blobstore struct {
	masterKey masterkey.MasterKey
	backend backend.Backend
}

// checksum computes an authenticated checksum of data using HMAC
func (b Blobstore) checksum(data []byte) (string, error) {
	// Get the key for HMAC operations
	hmacKey, err := b.masterKey.SubKey(hmacSubKeyID, hmacKeySize)
	if err != nil {
		return "", fmt.Errorf("error generating hmac material: %v", err)
	}

	// Compute the checksum of this data and return it
	checksum := hmac.New(sha256.New, hmacKey)
	io.Copy(checksum, bytes.NewReader(data))
	return hex.EncodeToString(checksum.Sum(nil)), nil
}

// Encrypt data to be stored in the blobstore
func (b Blobstore) encrypt(subKeyID string, plaintext []byte) ([]byte, error) {
	// Get the encryption key specified
	encKey, err := b.masterKey.SubKey(subKeyID, chacha20poly1305.KeySize)
	if err != nil {
		return nil, fmt.Errorf("error generating key material: %v", err)
	}

	// Create a new ChaCha20-Poly1305 cipher
	aead, err := chacha20poly1305.New(encKey)
	if err != nil {
		return nil, fmt.Errorf("error creating cipher: %v", err)
	}

	// Get the nonce for this blob, to be used with the cipher
	nonce, err := b.masterKey.SubKey("nonce-"+subKeyID, chacha20poly1305.NonceSize)
	if err != nil {
		return nil, fmt.Errorf("error generating nonce material: %v", err)
	}

	// Encrypt the data in AEAD mode
	ciphertext := aead.Seal(nil, nonce, plaintext, nil)
	return ciphertext, nil
}

// Decrypt data stored by the blobstore
func (b Blobstore) decrypt(subKeyID string, ciphertext []byte) ([]byte, error) {
	encKey, err := b.masterKey.SubKey(subKeyID, chacha20poly1305.KeySize)
	if err != nil {
		return nil, fmt.Errorf("error generating key material: %v", err)
	}

	// Create a new ChaCha20-Poly1305 cipher
	aead, err := chacha20poly1305.New(encKey)
	if err != nil {
		return nil, fmt.Errorf("error creating cipher: %v", err)
	}

	// Get the nonce for this blob, to be used with the cipher
	nonce, err := b.masterKey.SubKey("nonce-"+subKeyID, chacha20poly1305.NonceSize)
	if err != nil {
		return nil, fmt.Errorf("error generating nonce material: %v", err)
	}

	// Decrypt the data in AEAD mode
	plaintext, err := aead.Open(nil, nonce, ciphertext, nil)
	if err != nil {
		return nil, fmt.Errorf("error in cipher: %v", err)
	}
	return plaintext, nil
}

// Put encrypts and stores a blob, returning the blobID for the data
func (b Blobstore) Put(data []byte) (string, error) {
	// Use the checksum of the data as the blobID
	blobID, err := b.checksum(data)
	if err != nil {
		return "", fmt.Errorf("error computing checksum: %v", err)
	}

	// Check if the object is already in S3, if so we have nothing to do
	ok, err := b.backend.Verify(blobID, b.checksum)
	if err != nil {
		return "", fmt.Errorf("error checking for blob %v: %v", blobID, err)
	}
	if ok {
		return blobID, nil
	}

	// Encrypt the data
	ciphertext, err := b.encrypt(blobID, data)
	if err != nil {
		return "", fmt.Errorf("error encrypting blob: %v", err)
	}

	// Store the ciphertext in the backend
	if err := b.backend.Put(blobID, ciphertext, b.checksum); err != nil {
		return "", fmt.Errorf("backend error: %v", err)
	}

	return blobID, nil
}

// Get retrieves and decrypts a blob from storage
func (b Blobstore) Get(blobID string) ([]byte, error) {
	// Fetch the ciphertext from storage
	ciphertext, err := b.backend.Get(blobID, b.checksum)

	// Decrypt the blob
	plaintext, err := b.decrypt(blobID, ciphertext)
	if err != nil {
		return nil, fmt.Errorf("error decrypting blob: %v", err)
	}

	// Verify the downloaded data against the blobID
	checksum, err := b.checksum(plaintext)
	if err != nil {
		return nil, fmt.Errorf("error computing checksum: %v", err)
	}
	if checksum != blobID {
		return nil, fmt.Errorf("bad checksum `in blob %v: %v", blobID, checksum)
	}

	return plaintext, nil
}

repository: beardedfoo/blobstore

repo_name: beardedfoo/blobstore


text:
# Remove the log file.
file(REMOVE ${Log})

# Run a child that sleeps longer than the timout of this test.
# Log its output so check.cmake can verify it dies.
execute_process(COMMAND ${Timeout} OUTPUT_FILE ${Log})


text:
// Code generated by protoc-gen-goten-object
// File: edgelq/limits/proto/v1alpha2/limit.proto
// DO NOT EDIT!!!

package limit

// proto imports
import (
	ntt_meta "github.com/cloudwan/edgelq-sdk/common/types/meta"
	multi_region_policy "github.com/cloudwan/edgelq-sdk/common/types/multi_region_policy"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	limit_pool "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/limit_pool"
	meta_resource "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/resource"
	meta_service "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/service"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
)

// make sure we're using proto imports
var (
	_ = &ntt_meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &limit_pool.LimitPool{}
	_ = &meta_resource.Resource{}
	_ = &meta_service.Service{}
	_ = &timestamp.Timestamp{}
)

type LimitFieldPathBuilder struct{}

func NewLimitFieldPathBuilder() LimitFieldPathBuilder {
	return LimitFieldPathBuilder{}
}
func (LimitFieldPathBuilder) Name() LimitPathSelectorName {
	return LimitPathSelectorName{}
}
func (LimitFieldPathBuilder) Service() LimitPathSelectorService {
	return LimitPathSelectorService{}
}
func (LimitFieldPathBuilder) Resource() LimitPathSelectorResource {
	return LimitPathSelectorResource{}
}
func (LimitFieldPathBuilder) Region() LimitPathSelectorRegion {
	return LimitPathSelectorRegion{}
}
func (LimitFieldPathBuilder) ConfiguredLimit() LimitPathSelectorConfiguredLimit {
	return LimitPathSelectorConfiguredLimit{}
}
func (LimitFieldPathBuilder) ActiveLimit() LimitPathSelectorActiveLimit {
	return LimitPathSelectorActiveLimit{}
}
func (LimitFieldPathBuilder) Usage() LimitPathSelectorUsage {
	return LimitPathSelectorUsage{}
}
func (LimitFieldPathBuilder) Source() LimitPathSelectorSource {
	return LimitPathSelectorSource{}
}
func (LimitFieldPathBuilder) Metadata() LimitPathSelectorMetadata {
	return LimitPathSelectorMetadata{}
}

type LimitPathSelectorName struct{}

func (LimitPathSelectorName) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorName}
}

func (s LimitPathSelectorName) WithValue(value *Name) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorName) WithArrayOfValues(values []*Name) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

type LimitPathSelectorService struct{}

func (LimitPathSelectorService) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorService}
}

func (s LimitPathSelectorService) WithValue(value *meta_service.Reference) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorService) WithArrayOfValues(values []*meta_service.Reference) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

type LimitPathSelectorResource struct{}

func (LimitPathSelectorResource) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorResource}
}

func (s LimitPathSelectorResource) WithValue(value *meta_resource.Reference) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorResource) WithArrayOfValues(values []*meta_resource.Reference) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

type LimitPathSelectorRegion struct{}

func (LimitPathSelectorRegion) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorRegion}
}

func (s LimitPathSelectorRegion) WithValue(value string) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorRegion) WithArrayOfValues(values []string) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

type LimitPathSelectorConfiguredLimit struct{}

func (LimitPathSelectorConfiguredLimit) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorConfiguredLimit}
}

func (s LimitPathSelectorConfiguredLimit) WithValue(value int64) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorConfiguredLimit) WithArrayOfValues(values []int64) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

type LimitPathSelectorActiveLimit struct{}

func (LimitPathSelectorActiveLimit) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorActiveLimit}
}

func (s LimitPathSelectorActiveLimit) WithValue(value int64) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorActiveLimit) WithArrayOfValues(values []int64) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

type LimitPathSelectorUsage struct{}

func (LimitPathSelectorUsage) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorUsage}
}

func (s LimitPathSelectorUsage) WithValue(value int64) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorUsage) WithArrayOfValues(values []int64) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

type LimitPathSelectorSource struct{}

func (LimitPathSelectorSource) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorSource}
}

func (s LimitPathSelectorSource) WithValue(value *limit_pool.Reference) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorSource) WithArrayOfValues(values []*limit_pool.Reference) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

type LimitPathSelectorMetadata struct{}

func (LimitPathSelectorMetadata) FieldPath() *Limit_FieldTerminalPath {
	return &Limit_FieldTerminalPath{selector: Limit_FieldPathSelectorMetadata}
}

func (s LimitPathSelectorMetadata) WithValue(value *ntt_meta.Meta) *Limit_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldTerminalPathValue)
}

func (s LimitPathSelectorMetadata) WithArrayOfValues(values []*ntt_meta.Meta) *Limit_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldTerminalPathArrayOfValues)
}

func (LimitPathSelectorMetadata) WithSubPath(subPath ntt_meta.Meta_FieldPath) *Limit_FieldSubPath {
	return &Limit_FieldSubPath{selector: Limit_FieldPathSelectorMetadata, subPath: subPath}
}

func (s LimitPathSelectorMetadata) WithSubValue(subPathValue ntt_meta.Meta_FieldPathValue) *Limit_FieldSubPathValue {
	return &Limit_FieldSubPathValue{Limit_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s LimitPathSelectorMetadata) WithSubArrayOfValues(subPathArrayOfValues ntt_meta.Meta_FieldPathArrayOfValues) *Limit_FieldSubPathArrayOfValues {
	return &Limit_FieldSubPathArrayOfValues{Limit_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s LimitPathSelectorMetadata) WithSubArrayItemValue(subPathArrayItemValue ntt_meta.Meta_FieldPathArrayItemValue) *Limit_FieldSubPathArrayItemValue {
	return &Limit_FieldSubPathArrayItemValue{Limit_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (LimitPathSelectorMetadata) CreateTime() LimitPathSelectorMetadataCreateTime {
	return LimitPathSelectorMetadataCreateTime{}
}

func (LimitPathSelectorMetadata) UpdateTime() LimitPathSelectorMetadataUpdateTime {
	return LimitPathSelectorMetadataUpdateTime{}
}

func (LimitPathSelectorMetadata) DeleteTime() LimitPathSelectorMetadataDeleteTime {
	return LimitPathSelectorMetadataDeleteTime{}
}

func (LimitPathSelectorMetadata) Uuid() LimitPathSelectorMetadataUuid {
	return LimitPathSelectorMetadataUuid{}
}

func (LimitPathSelectorMetadata) Tags() LimitPathSelectorMetadataTags {
	return LimitPathSelectorMetadataTags{}
}

func (LimitPathSelectorMetadata) Labels() LimitPathSelectorMetadataLabels {
	return LimitPathSelectorMetadataLabels{}
}

func (LimitPathSelectorMetadata) Annotations() LimitPathSelectorMetadataAnnotations {
	return LimitPathSelectorMetadataAnnotations{}
}

func (LimitPathSelectorMetadata) Generation() LimitPathSelectorMetadataGeneration {
	return LimitPathSelectorMetadataGeneration{}
}

func (LimitPathSelectorMetadata) ResourceVersion() LimitPathSelectorMetadataResourceVersion {
	return LimitPathSelectorMetadataResourceVersion{}
}

func (LimitPathSelectorMetadata) OwnerReferences() LimitPathSelectorMetadataOwnerReferences {
	return LimitPathSelectorMetadataOwnerReferences{}
}

func (LimitPathSelectorMetadata) Shards() LimitPathSelectorMetadataShards {
	return LimitPathSelectorMetadataShards{}
}

func (LimitPathSelectorMetadata) Syncing() LimitPathSelectorMetadataSyncing {
	return LimitPathSelectorMetadataSyncing{}
}

func (LimitPathSelectorMetadata) Lifecycle() LimitPathSelectorMetadataLifecycle {
	return LimitPathSelectorMetadataLifecycle{}
}

type LimitPathSelectorMetadataCreateTime struct{}

func (LimitPathSelectorMetadataCreateTime) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().CreateTime().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataCreateTime) WithValue(value *timestamp.Timestamp) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataCreateTime) WithArrayOfValues(values []*timestamp.Timestamp) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataUpdateTime struct{}

func (LimitPathSelectorMetadataUpdateTime) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().UpdateTime().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataUpdateTime) WithValue(value *timestamp.Timestamp) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataUpdateTime) WithArrayOfValues(values []*timestamp.Timestamp) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataDeleteTime struct{}

func (LimitPathSelectorMetadataDeleteTime) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().DeleteTime().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataDeleteTime) WithValue(value *timestamp.Timestamp) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataDeleteTime) WithArrayOfValues(values []*timestamp.Timestamp) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataUuid struct{}

func (LimitPathSelectorMetadataUuid) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Uuid().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataUuid) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataUuid) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataTags struct{}

func (LimitPathSelectorMetadataTags) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Tags().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataTags) WithValue(value []string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataTags) WithArrayOfValues(values [][]string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

func (s LimitPathSelectorMetadataTags) WithItemValue(value string) *Limit_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Limit_FieldSubPathArrayItemValue)
}

type LimitPathSelectorMetadataLabels struct{}

func (LimitPathSelectorMetadataLabels) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Labels().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataLabels) WithValue(value map[string]string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataLabels) WithArrayOfValues(values []map[string]string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

func (LimitPathSelectorMetadataLabels) WithKey(key string) LimitMapPathSelectorMetadataLabels {
	return LimitMapPathSelectorMetadataLabels{key: key}
}

type LimitMapPathSelectorMetadataLabels struct {
	key string
}

func (s LimitMapPathSelectorMetadataLabels) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s LimitMapPathSelectorMetadataLabels) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitMapPathSelectorMetadataLabels) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataAnnotations struct{}

func (LimitPathSelectorMetadataAnnotations) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Annotations().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataAnnotations) WithValue(value map[string]string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataAnnotations) WithArrayOfValues(values []map[string]string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

func (LimitPathSelectorMetadataAnnotations) WithKey(key string) LimitMapPathSelectorMetadataAnnotations {
	return LimitMapPathSelectorMetadataAnnotations{key: key}
}

type LimitMapPathSelectorMetadataAnnotations struct {
	key string
}

func (s LimitMapPathSelectorMetadataAnnotations) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Annotations().WithKey(s.key).FieldPath(),
	}
}

func (s LimitMapPathSelectorMetadataAnnotations) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitMapPathSelectorMetadataAnnotations) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataGeneration struct{}

func (LimitPathSelectorMetadataGeneration) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Generation().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataGeneration) WithValue(value int64) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataGeneration) WithArrayOfValues(values []int64) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataResourceVersion struct{}

func (LimitPathSelectorMetadataResourceVersion) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().ResourceVersion().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataResourceVersion) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataResourceVersion) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataOwnerReferences struct{}

func (LimitPathSelectorMetadataOwnerReferences) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().OwnerReferences().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataOwnerReferences) WithValue(value []*ntt_meta.OwnerReference) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataOwnerReferences) WithArrayOfValues(values [][]*ntt_meta.OwnerReference) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

func (s LimitPathSelectorMetadataOwnerReferences) WithItemValue(value *ntt_meta.OwnerReference) *Limit_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Limit_FieldSubPathArrayItemValue)
}

func (LimitPathSelectorMetadataOwnerReferences) Kind() LimitPathSelectorMetadataOwnerReferencesKind {
	return LimitPathSelectorMetadataOwnerReferencesKind{}
}

func (LimitPathSelectorMetadataOwnerReferences) Version() LimitPathSelectorMetadataOwnerReferencesVersion {
	return LimitPathSelectorMetadataOwnerReferencesVersion{}
}

func (LimitPathSelectorMetadataOwnerReferences) Name() LimitPathSelectorMetadataOwnerReferencesName {
	return LimitPathSelectorMetadataOwnerReferencesName{}
}

func (LimitPathSelectorMetadataOwnerReferences) Region() LimitPathSelectorMetadataOwnerReferencesRegion {
	return LimitPathSelectorMetadataOwnerReferencesRegion{}
}

func (LimitPathSelectorMetadataOwnerReferences) Controller() LimitPathSelectorMetadataOwnerReferencesController {
	return LimitPathSelectorMetadataOwnerReferencesController{}
}

func (LimitPathSelectorMetadataOwnerReferences) BlockOwnerDeletion() LimitPathSelectorMetadataOwnerReferencesBlockOwnerDeletion {
	return LimitPathSelectorMetadataOwnerReferencesBlockOwnerDeletion{}
}

func (LimitPathSelectorMetadataOwnerReferences) RequiresOwnerReference() LimitPathSelectorMetadataOwnerReferencesRequiresOwnerReference {
	return LimitPathSelectorMetadataOwnerReferencesRequiresOwnerReference{}
}

type LimitPathSelectorMetadataOwnerReferencesKind struct{}

func (LimitPathSelectorMetadataOwnerReferencesKind) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().OwnerReferences().Kind().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataOwnerReferencesKind) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataOwnerReferencesKind) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataOwnerReferencesVersion struct{}

func (LimitPathSelectorMetadataOwnerReferencesVersion) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().OwnerReferences().Version().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataOwnerReferencesVersion) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataOwnerReferencesVersion) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataOwnerReferencesName struct{}

func (LimitPathSelectorMetadataOwnerReferencesName) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().OwnerReferences().Name().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataOwnerReferencesName) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataOwnerReferencesName) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataOwnerReferencesRegion struct{}

func (LimitPathSelectorMetadataOwnerReferencesRegion) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().OwnerReferences().Region().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataOwnerReferencesRegion) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataOwnerReferencesRegion) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataOwnerReferencesController struct{}

func (LimitPathSelectorMetadataOwnerReferencesController) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().OwnerReferences().Controller().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataOwnerReferencesController) WithValue(value bool) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataOwnerReferencesController) WithArrayOfValues(values []bool) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataOwnerReferencesBlockOwnerDeletion struct{}

func (LimitPathSelectorMetadataOwnerReferencesBlockOwnerDeletion) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().OwnerReferences().BlockOwnerDeletion().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataOwnerReferencesBlockOwnerDeletion) WithValue(value bool) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataOwnerReferencesBlockOwnerDeletion) WithArrayOfValues(values []bool) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataOwnerReferencesRequiresOwnerReference struct{}

func (LimitPathSelectorMetadataOwnerReferencesRequiresOwnerReference) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().OwnerReferences().RequiresOwnerReference().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithValue(value bool) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithArrayOfValues(values []bool) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataShards struct{}

func (LimitPathSelectorMetadataShards) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Shards().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataShards) WithValue(value map[string]int64) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataShards) WithArrayOfValues(values []map[string]int64) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

func (LimitPathSelectorMetadataShards) WithKey(key string) LimitMapPathSelectorMetadataShards {
	return LimitMapPathSelectorMetadataShards{key: key}
}

type LimitMapPathSelectorMetadataShards struct {
	key string
}

func (s LimitMapPathSelectorMetadataShards) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Shards().WithKey(s.key).FieldPath(),
	}
}

func (s LimitMapPathSelectorMetadataShards) WithValue(value int64) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitMapPathSelectorMetadataShards) WithArrayOfValues(values []int64) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataSyncing struct{}

func (LimitPathSelectorMetadataSyncing) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Syncing().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataSyncing) WithValue(value *ntt_meta.SyncingMeta) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataSyncing) WithArrayOfValues(values []*ntt_meta.SyncingMeta) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

func (LimitPathSelectorMetadataSyncing) OwningRegion() LimitPathSelectorMetadataSyncingOwningRegion {
	return LimitPathSelectorMetadataSyncingOwningRegion{}
}

func (LimitPathSelectorMetadataSyncing) Regions() LimitPathSelectorMetadataSyncingRegions {
	return LimitPathSelectorMetadataSyncingRegions{}
}

type LimitPathSelectorMetadataSyncingOwningRegion struct{}

func (LimitPathSelectorMetadataSyncingOwningRegion) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Syncing().OwningRegion().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataSyncingOwningRegion) WithValue(value string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataSyncingOwningRegion) WithArrayOfValues(values []string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataSyncingRegions struct{}

func (LimitPathSelectorMetadataSyncingRegions) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Syncing().Regions().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataSyncingRegions) WithValue(value []string) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataSyncingRegions) WithArrayOfValues(values [][]string) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

func (s LimitPathSelectorMetadataSyncingRegions) WithItemValue(value string) *Limit_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*Limit_FieldSubPathArrayItemValue)
}

type LimitPathSelectorMetadataLifecycle struct{}

func (LimitPathSelectorMetadataLifecycle) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Lifecycle().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataLifecycle) WithValue(value *ntt_meta.Lifecycle) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataLifecycle) WithArrayOfValues(values []*ntt_meta.Lifecycle) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

func (LimitPathSelectorMetadataLifecycle) State() LimitPathSelectorMetadataLifecycleState {
	return LimitPathSelectorMetadataLifecycleState{}
}

func (LimitPathSelectorMetadataLifecycle) BlockDeletion() LimitPathSelectorMetadataLifecycleBlockDeletion {
	return LimitPathSelectorMetadataLifecycleBlockDeletion{}
}

type LimitPathSelectorMetadataLifecycleState struct{}

func (LimitPathSelectorMetadataLifecycleState) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Lifecycle().State().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataLifecycleState) WithValue(value ntt_meta.Lifecycle_State) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataLifecycleState) WithArrayOfValues(values []ntt_meta.Lifecycle_State) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

type LimitPathSelectorMetadataLifecycleBlockDeletion struct{}

func (LimitPathSelectorMetadataLifecycleBlockDeletion) FieldPath() *Limit_FieldSubPath {
	return &Limit_FieldSubPath{
		selector: Limit_FieldPathSelectorMetadata,
		subPath:  ntt_meta.NewMetaFieldPathBuilder().Lifecycle().BlockDeletion().FieldPath(),
	}
}

func (s LimitPathSelectorMetadataLifecycleBlockDeletion) WithValue(value bool) *Limit_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*Limit_FieldSubPathValue)
}

func (s LimitPathSelectorMetadataLifecycleBlockDeletion) WithArrayOfValues(values []bool) *Limit_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*Limit_FieldSubPathArrayOfValues)
}

repository: cloudwan/edgelq-sdk

repo_name: cloudwan/edgelq-sdk

branch_name: refs/heads/main


text:
package cdsclient

import (
	"context"
	"net/url"

	"github.com/ovh/cds/sdk"
)

func (c *client) ProjectKeysList(key string) ([]sdk.ProjectKey, error) {
	k := []sdk.ProjectKey{}
	if _, err := c.GetJSON(context.Background(), "/project/"+key+"/keys", &k); err != nil {
		return nil, err
	}
	return k, nil
}

func (c *client) ProjectKeyCreate(projectKey string, keyProject *sdk.ProjectKey) error {
	_, err := c.PostJSON(context.Background(), "/project/"+projectKey+"/keys", keyProject, keyProject)
	return err
}

func (c *client) ProjectKeysDelete(projectKey string, keyName string) error {
	_, _, _, err := c.Request(context.Background(), "DELETE", "/project/"+projectKey+"/keys/"+url.QueryEscape(keyName), nil)
	return err
}

func (c *client) ProjectKeysDisable(projectKey string, keyProjectName string) error {
	_, err := c.PostJSON(context.Background(), "/project/"+projectKey+"/keys/"+url.QueryEscape(keyProjectName)+"/disable", nil, nil)
	return err
}

func (c *client) ProjectKeysEnable(projectKey string, keyProjectName string) error {
	_, err := c.PostJSON(context.Background(), "/project/"+projectKey+"/keys/"+url.QueryEscape(keyProjectName)+"/enable", nil, nil)
	return err
}

repository: ovh/cds

repo_name: ovh/cds


text:
SECTION = "devel/chicken"
DESCRIPTION = "Monads"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://monad.meta;md5=d3f9116fdd1b6227f0dbedce7721e75f"
DEPENDS = " chicken-egg-monad-cross"

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

SRC_URI[md5sum] = "291cdb021930466611661c209627c036"
SRC_URI[sha256sum] = "00e5c1637cb344e30a3034377482cc1abdefef3a766144e1ab20b96b27489ac1"

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

inherit chicken_install

BBCLASSEXTEND = "cross crosssdk nativesdk"

repository: OSSystems/meta-chicken

repo_name: OSSystems/meta-chicken


text:
#
# base recipe: meta/recipes-devtools/python/python3_3.4.3.bb
# base branch: jethro
#

require python3.inc

DEPENDS = "python3-native libffi bzip2 db gdbm openssl readline sqlite3 zlib virtual/libintl xz"
PR = "${INC_PR}"

PYTHON_BINABI= "${PYTHON_MAJMIN}m"

SRC_URI += " \
	file://python-config.patch \
	file://000-cross-compile.patch \
	file://020-dont-compile-python-files.patch \
	file://030-fixup-include-dirs.patch \
	file://070-dont-clean-ipkg-install.patch \
	file://080-distutils-dont_adjust_files.patch \
	file://110-enable-zlib.patch \
	file://130-readline-setup.patch \
	file://150-fix-setupterm.patch \
	file://0001-h2py-Fix-issue-13032-where-it-fails-with-UnicodeDeco.patch \
	file://makerace.patch \
	${DISTRO_SRC_URI} \
	file://03-fix-tkinter-detection.patch \
	file://04-default-is-optimized.patch \
	file://avoid_warning_about_tkinter.patch \
	file://cgi_py.patch \
	file://host_include_contamination.patch \
	file://python-3.3-multilib.patch \
	file://shutil-follow-symlink-fix.patch \
	file://sysroot-include-headers.patch \
	file://unixccompiler.patch \
	file://avoid-ncursesw-include-path.patch \
	file://python3-use-CROSSPYTHONPATH-for-PYTHON_FOR_BUILD.patch \
	file://python3-setup.py-no-host-headers-libs.patch \
	file://sysconfig.py-add-_PYTHON_PROJECT_SRC.patch \
	file://setup.py-check-cross_compiling-when-get-FLAGS.patch \
	file://setup.py-find-libraries-in-staging-dirs.patch \
"

DEBIAN_PATCH_TYPE = "quilt"

inherit multilib_header python3native pkgconfig

CONFIGUREOPTS += " --with-system-ffi "

CACHED_CONFIGUREVARS = " \
	ac_cv_have_chflags=no \
	ac_cv_have_lchflags=no \
	ac_cv_have_long_long_format=yes \
	ac_cv_buggy_getaddrinfo=no \
	ac_cv_file__dev_ptmx=yes \
	ac_cv_file__dev_ptc=no \
"

# The 3 lines below are copied from the libffi recipe, ctypes ships its own copy of the libffi sources
#Somehow gcc doesn't set __SOFTFP__ when passing -mfloatabi=softp :(
TARGET_CC_ARCH_append_armv6 = " -D__SOFTFP__"
TARGET_CC_ARCH_append_armv7a = " -D__SOFTFP__"
TARGET_CC_ARCH += "-DNDEBUG -fno-inline"
EXTRA_OEMAKE += "CROSS_COMPILE=yes"
EXTRA_OECONF += "CROSSPYTHONPATH=${STAGING_LIBDIR_NATIVE}/python${PYTHON_MAJMIN}/lib-dynload/ --without-ensurepip"

export CROSS_COMPILE = "${TARGET_PREFIX}"
export _PYTHON_PROJECT_BASE = "${B}"
export _PYTHON_PROJECT_SRC = "${S}"
export CCSHARED = "-fPIC"

# Fix ctypes cross compilation
export CROSSPYTHONPATH = "${B}/build/lib.linux-${TARGET_ARCH}-${PYTHON_MAJMIN}:${S}/Lib:${S}/Lib/plat-linux"

# No ctypes option for python 3
PYTHONLSBOPTS = ""
do_configure_append() {
	rm -f ${S}/Makefile.orig
	autoreconf -Wcross --verbose --install --force --exclude=autopoint ${S}/Modules/_ctypes/libffi
}

do_compile() {
	# regenerate platform specific files, because they depend on system headers
	cd ${S}/Lib/plat-linux*
	include=${STAGING_INCDIR} ${STAGING_BINDIR_NATIVE}/python3-native/python3 \
		${S}/Tools/scripts/h2py.py -i '(u_long)' \
		${STAGING_INCDIR}/dlfcn.h \
		${STAGING_INCDIR}/linux/cdrom.h \
		${STAGING_INCDIR}/netinet/in.h \
		${STAGING_INCDIR}/sys/types.h
	sed -e 's,${STAGING_DIR_HOST},,g' -i *.py
	cd -

	# remove any bogus LD_LIBRARY_PATH
	sed -i -e s,RUNSHARED=.*,RUNSHARED=, Makefile

	if [ ! -f Makefile.orig ]; then
		install -m 0644 Makefile Makefile.orig
	fi
	sed -i -e 's,^CONFIGURE_LDFLAGS=.*,CONFIGURE_LDFLAGS=-L. -L${STAGING_LIBDIR},g' \
		-e 's,libdir=${libdir},libdir=${STAGING_LIBDIR},g' \
		-e 's,libexecdir=${libexecdir},libexecdir=${STAGING_DIR_HOST}${libexecdir},g' \
		-e 's,^LIBDIR=.*,LIBDIR=${STAGING_LIBDIR},g' \
		-e 's,includedir=${includedir},includedir=${STAGING_INCDIR},g' \
		-e 's,^INCLUDEDIR=.*,INCLUDE=${STAGING_INCDIR},g' \
		-e 's,^CONFINCLUDEDIR=.*,CONFINCLUDE=${STAGING_INCDIR},g' \
		Makefile
	# save copy of it now, because if we do it in do_install and
	# then call do_install twice we get Makefile.orig == Makefile.sysroot
	install -m 0644 Makefile Makefile.sysroot

	oe_runmake HOSTPGEN=${STAGING_BINDIR_NATIVE}/python3-native/pgen \
		HOSTPYTHON=${STAGING_BINDIR_NATIVE}/python3-native/python3 \
		STAGING_LIBDIR=${STAGING_LIBDIR} \
		STAGING_BASELIBDIR=${STAGING_BASELIBDIR} \
		STAGING_INCDIR=${STAGING_INCDIR} \
		BUILD_SYS=${BUILD_SYS} HOST_SYS=${HOST_SYS} \
		LIB=${baselib} \
		ARCH=${TARGET_ARCH} \
		OPT="${CFLAGS}" libpython3.so

	oe_runmake HOSTPGEN=${STAGING_BINDIR_NATIVE}/python3-native/pgen \
		HOSTPYTHON=${STAGING_BINDIR_NATIVE}/python3-native/python3 \
		STAGING_LIBDIR=${STAGING_LIBDIR} \
		STAGING_INCDIR=${STAGING_INCDIR} \
		STAGING_BASELIBDIR=${STAGING_BASELIBDIR} \
		BUILD_SYS=${BUILD_SYS} HOST_SYS=${HOST_SYS} \
		LIB=${baselib} \
		ARCH=${TARGET_ARCH} \
		OPT="${CFLAGS}"
}

do_install() {
	# make install needs the original Makefile, or otherwise the inclues would
	# go to ${D}${STAGING...}/...
	install -m 0644 Makefile.orig Makefile

	install -d ${D}${libdir}/pkgconfig
	install -d ${D}${libdir}/python${PYTHON_MAJMIN}/config

	# rerun the build once again with original makefile this time
	# run install in a separate step to avoid compile/install race
	oe_runmake HOSTPGEN=${STAGING_BINDIR_NATIVE}/python3-native/pgen \
		HOSTPYTHON=${STAGING_BINDIR_NATIVE}/python3-native/python3 \
		STAGING_LIBDIR=${STAGING_LIBDIR} \
		STAGING_INCDIR=${STAGING_INCDIR} \
		STAGING_BASELIBDIR=${STAGING_BASELIBDIR} \
		BUILD_SYS=${BUILD_SYS} HOST_SYS=${HOST_SYS} \
		LIB=${baselib} \
		ARCH=${TARGET_ARCH} \
		DESTDIR=${D} LIBDIR=${libdir}

	oe_runmake HOSTPGEN=${STAGING_BINDIR_NATIVE}/python3-native/pgen \
		HOSTPYTHON=${STAGING_BINDIR_NATIVE}/python3-native/python3 \
		STAGING_LIBDIR=${STAGING_LIBDIR} \
		STAGING_INCDIR=${STAGING_INCDIR} \
		STAGING_BASELIBDIR=${STAGING_BASELIBDIR} \
		BUILD_SYS=${BUILD_SYS} HOST_SYS=${HOST_SYS} \
		LIB=${baselib} \
		ARCH=${TARGET_ARCH} \
		DESTDIR=${D} LIBDIR=${libdir} install

	# avoid conflict with 2to3 from Python 2
	rm -f ${D}/${bindir}/2to3

	install -m 0644 Makefile.sysroot ${D}/${libdir}/python${PYTHON_MAJMIN}/config/Makefile

	if [ -e ${WORKDIR}/sitecustomize.py ]; then
		install -m 0644 ${WORKDIR}/sitecustomize.py ${D}/${libdir}/python${PYTHON_MAJMIN}
	fi

	oe_multilib_header python${PYTHON_BINABI}/pyconfig.h

	# install file follow file list of package idle-python3.4
	mv ${D}${bindir}/idle3.4 ${D}${bindir}/idle-python3.4
	rm -rf ${D}${bindir}/idle3

	# install file follow file list of package libpython3.4
	LINKLIB=$(basename $(readlink ${D}${libdir}/libpython3.4m.so))
	rm ${D}${libdir}/libpython3.4m.so
	ln -s ../${LINKLIB} ${D}${libdir}/python3.4/libpython3.4m.so
	ln -s ../${LINKLIB} ${D}${libdir}/python3.4/libpython3.4.so
	ln -s ${LINKLIB} ${D}${libdir}/libpython3.4m.so.1

	ln -s python3.4m ${D}${includedir}/python3.4

	install -d ${D}${sysconfdir}/python3.4
	mv ${D}${libdir}/python3.4/sitecustomize.py ${D}${sysconfdir}/python3.4/

	install -m 0755 ${S}/Tools/i18n/pygettext.py ${D}${bindir}/pygettext3.4
	ln -s ../lib/python3.4 ${D}${bindir}/pdb3.4

	rm ${D}${bindir}/pydoc3
	rm ${D}${bindir}/pyvenv

	rm ${D}${bindir}/python3-config
        rm ${D}${bindir}/python3
}

do_install_append_class-nativesdk () {
	create_wrapper ${D}${bindir}/python${PYTHON_MAJMIN} TERMINFO_DIRS='${sysconfdir}/terminfo:/etc/terminfo:/usr/share/terminfo:/usr/share/misc/terminfo:/lib/terminfo'
}

SSTATE_SCAN_FILES += "Makefile"
PACKAGE_PREPROCESS_FUNCS += "py_package_preprocess"

py_package_preprocess () {
	# copy back the old Makefile to fix target package
	install -m 0644 ${B}/Makefile.orig ${PKGD}/${libdir}/python${PYTHON_MAJMIN}/config/Makefile
	# Remove references to buildmachine paths in target Makefile and _sysconfigdata
	sed -i -e 's:--sysroot=${STAGING_DIR_TARGET}::g' -e s:'--with-libtool-sysroot=${STAGING_DIR_TARGET}'::g \
		${PKGD}/${libdir}/python${PYTHON_MAJMIN}/config/Makefile \
		${PKGD}/${libdir}/python${PYTHON_MAJMIN}/_sysconfigdata.py
}

require python-${PYTHON_MAJMIN}-manifest.inc

# manual dependency additions
RPROVIDES_${PN}-core = "${PN}"
RRECOMMENDS_${PN}-core = "${PN}-readline"
RRECOMMENDS_${PN}-crypt = "openssl"
RRECOMMENDS_${PN}-crypt_class-nativesdk = "nativesdk-openssl"

PACKAGES =+ "libpython3.4 idle-python3.4 python3.4 python3.4-dev python3.4-examples python3.4-minimal python3.4-venv "
FILES_idle-python3.4 += " ${bindir}/idle-python3.4 "

FILES_python3.4 = " \
	${bindir}/2to3-3.4 \
	${bindir}/pdb3.4 \
	${bindir}/pydoc3.4 \
	${bindir}/pygettext3.4 \
"
FILES_python3.4-dev = " \
	${bindir}/python3.4-config \
	${bindir}/python3.4m-config \
"

FILES_python3.4-examples = " ${libdir}/python3.4/turtledemo/* "

FILES_python3.4-minimal = " ${bindir}/python3.4*"

FILES_python3.4-venv = " \
	${bindir}/pyvenv-3.4 \
	${libdir}/python3.4/ensurepip/ \
"

# package libpython3
PACKAGES =+ " libpython3.4-staticdev libpython3.4-dev libpython3.4-minimal libpython3.4-stdlib libpython3.4-testsuite"

FILES_libpython3.4-staticdev += "${libdir}/python3.4/config-3.4m/libpython3.4m.a"

FILES_libpython3.4 = " \
	${libdir}/libpython*.so.* \
"

FILES_libpython3.4-dev = " \
	${includedir}/python3.4m/* \
	${includedir}/python3.4 \
	${libdir}/python3.4/config-3.4m/* \
	${libdir}/pkgconfig/* \
	${libdir}/python3.4/libpython3.4*.so \
"

FILES_libpython3.4-minimal = " \
	${sysconfdir}/python3.4/sitecustomize.py \
	${libdir}/python3.4/encodings/* \
	${libdir}/python3.4/__future__.py \
	${libdir}/python3.4/_bootlocale.py \
	${libdir}/python3.4/_collections_abc.py \
	${libdir}/python3.4/_compat_pickle.py \
	${libdir}/python3.4/_sitebuiltins.py \
	${libdir}/python3.4/_sysconfigdata.py \
	${libdir}/python3.4/_threading_local.py \
	${libdir}/python3.4/_weakrefset.py \
	${libdir}/python3.4/abc.py \
	${libdir}/python3.4/argparse.py \
	${libdir}/python3.4/ast.py \
	${libdir}/python3.4/base64.py \
	${libdir}/python3.4/bisect.py \
	${libdir}/python3.4/codecs.py \
	${libdir}/python3.4/collections/* \
	${libdir}/python3.4/enum.py \
	${libdir}/python3.4/fnmatch.py \
	${libdir}/python3.4/compileall.py \
	${libdir}/python3.4/configparser.py \
	${libdir}/python3.4/contextlib.py \
	${libdir}/python3.4/copy.py \
	${libdir}/python3.4/copyreg.py \
	${libdir}/python3.4/dis.py \
	${libdir}/python3.4/functools.py \
        ${libdir}/python3.4/genericpath.py \
	${libdir}/python3.4/getopt.py \
	${libdir}/python3.4/glob.py \
	${libdir}/python3.4/hashlib.py \
	${libdir}/python3.4/heapq.py \
	${libdir}/python3.4/imp.py \
	${libdir}/python3.4/importlib/* \
	${libdir}/python3.4/inspect.py \
	${libdir}/python3.4/io.py \
	${libdir}/python3.4/keyword.py \
	${libdir}/python3.4/lib-dynload/* \
	${libdir}/python3.4/linecache.py \
	${libdir}/python3.4/locale.py \
	${libdir}/python3.4/logging/* \
	${libdir}/python3.4/opcode.py \
	${libdir}/python3.4/operator.py \
	${libdir}/python3.4/optparse.py \
	${libdir}/python3.4/os.py \
	${libdir}/python3.4/pickle.py \
	${libdir}/python3.4/pkgutil.py \
	${libdir}/python3.4/_sysconfigdata_m.py \
	${libdir}/python3.4/platform.py \
	${libdir}/python3.4/posixpath.py \
	${libdir}/python3.4/py_compile.py \
	${libdir}/python3.4/random.py \
	${libdir}/python3.4/re.py \
	${libdir}/python3.4/reprlib.py \
	${libdir}/python3.4/runpy.py \
	${libdir}/python3.4/selectors.py \
	${libdir}/python3.4/site.py \
	${libdir}/python3.4/sitecustomize.py \
	${libdir}/python3.4/socket.py \
	${libdir}/python3.4/sre_compile.py \
	${libdir}/python3.4/sre_constants.py \
	${libdir}/python3.4/sre_parse.py \
	${libdir}/python3.4/ssl.py \
	${libdir}/python3.4/stat.py \
	${libdir}/python3.4/string.py \
	${libdir}/python3.4/stringprep.py \
	${libdir}/python3.4/struct.py \
	${libdir}/python3.4/subprocess.py \
	${libdir}/python3.4/sysconfig.py \
	${libdir}/python3.4/tempfile.py \
	${libdir}/python3.4/textwrap.py \
	${libdir}/python3.4/threading.py \
	${libdir}/python3.4/token.py \
	${libdir}/python3.4/tokenize.py \
	${libdir}/python3.4/traceback.py \
	${libdir}/python3.4/types.py \
	${libdir}/python3.4/warnings.py \
	${libdir}/python3.4/weakref.py \
"

FILES_libpython3.4-stdlib = " \
	${libdir}/python3.4/LICENSE.txt \
	${libdir}/python3.4/__phello__.foo.py \
	${libdir}/python3.4/_dummy_thread.py \
	${libdir}/python3.4/_markupbase.py \
	${libdir}/python3.4/_osx_support.py \
	${libdir}/python3.4/_pyio.py \
	${libdir}/python3.4/_strptime.py \
	${libdir}/python3.4/aifc.py \
	${libdir}/python3.4/antigravity.py \
	${libdir}/python3.4/asynchat.py \
	${libdir}/python3.4/asyncio/* \
	${libdir}/python3.4/asyncore.py \
	${libdir}/python3.4/bdb.py \
	${libdir}/python3.4/binhex.py \
	${libdir}/python3.4/bz2.py \
	${libdir}/python3.4/cProfile.py \
	${libdir}/python3.4/calendar.py \
	${libdir}/python3.4/cgi.py \
	${libdir}/python3.4/cgitb.py \
	${libdir}/python3.4/chunk.py \
	${libdir}/python3.4/cmd.py \
	${libdir}/python3.4/code.py \
	${libdir}/python3.4/codeop.py \
	${libdir}/python3.4/colorsys.py \
	${libdir}/python3.4/concurrent/* \
	${libdir}/python3.4/crypt.py \
	${libdir}/python3.4/csv.py \
	${libdir}/python3.4/ctypes/* \
	${libdir}/python3.4/curses/* \
	${libdir}/python3.4/datetime.py \
	${libdir}/python3.4/dbm/* \
	${libdir}/python3.4/decimal.py \
	${libdir}/python3.4/difflib.py \
	${libdir}/python3.4/distutils/* \
	${libdir}/python3.4/doctest.py \
	${libdir}/python3.4/dummy_threading.py \
	${libdir}/python3.4/email/* \
	${libdir}/python3.4/filecmp.py \
	${libdir}/python3.4/fileinput.py \
	${libdir}/python3.4/formatter.py \
	${libdir}/python3.4/fractions.py \
	${libdir}/python3.4/ftplib.py \
	${libdir}/python3.4/getpass.py \
	${libdir}/python3.4/gettext.py \
	${libdir}/python3.4/gzip.py \
	${libdir}/python3.4/hmac.py \
	${libdir}/python3.4/html/* \
	${libdir}/python3.4/http/* \
	${libdir}/python3.4/idlelib/* \
	${libdir}/python3.4/imaplib.py \
	${libdir}/python3.4/imghdr.py \
	${libdir}/python3.4/ipaddress.py \
	${libdir}/python3.4/json/* \
	${libdir}/python3.4/lib-dynload/* \
	${libdir}/python3.4/lib2to3/ \
	${libdir}/python3.4/lzma.py \
	${libdir}/python3.4/macpath.py \
	${libdir}/python3.4/macurl2path.py \
	${libdir}/python3.4/mailbox.py \
	${libdir}/python3.4/mailcap.py \
	${libdir}/python3.4/mimetypes.py \
	${libdir}/python3.4/modulefinder.py \
	${libdir}/python3.4/multiprocessing/* \
	${libdir}/python3.4/netrc.py \
	${libdir}/python3.4/nntplib.py \
	${libdir}/python3.4/ntpath.py \
	${libdir}/python3.4/nturl2path.py \
	${libdir}/python3.4/numbers.py \
	${libdir}/python3.4/pathlib.py \
	${libdir}/python3.4/pdb.py \
	${libdir}/python3.4/pickletools.py \
	${libdir}/python3.4/pipes.py \
	${libdir}/python3.4/plat-linux/* \
	${libdir}/python3.4/plistlib.py \
	${libdir}/python3.4/poplib.py \
	${libdir}/python3.4/pprint.py \
	${libdir}/python3.4/profile.py \
	${libdir}/python3.4/pstats.py \
	${libdir}/python3.4/pty.py \
	${libdir}/python3.4/pyclbr.py \
	${libdir}/python3.4/pydoc.py \
	${libdir}/python3.4/pydoc_data/* \
	${libdir}/python3.4/queue.py \
	${libdir}/python3.4/quopri.py \
	${libdir}/python3.4/rlcompleter.py \
	${libdir}/python3.4/sched.py \
	${libdir}/python3.4/shelve.py \
	${libdir}/python3.4/shlex.py \
	${libdir}/python3.4/smtpd.py \
	${libdir}/python3.4/shutil.py \
	${libdir}/python3.4/smtplib.py \
	${libdir}/python3.4/sndhdr.py \
	${libdir}/python3.4/socketserver.py \
	${libdir}/python3.4/sqlite3/* \
	${libdir}/python3.4/statistics.py \
	${libdir}/python3.4/sunau.py \
	${libdir}/python3.4/symbol.py \
	${libdir}/python3.4/symtable.py \
	${libdir}/python3.4/tabnanny.py \
	${libdir}/python3.4/tarfile.py \
	${libdir}/python3.4/telnetlib.py \
	${libdir}/python3.4/test/__init__.py \
	${libdir}/python3.4/test/pystone.py \
	${libdir}/python3.4/test/regrtest.py \
	${libdir}/python3.4/test/support/__init__.py \
	${libdir}/python3.4/this.py \
	${libdir}/python3.4/timeit.py \
	${libdir}/python3.4/tkinter/* \
	${libdir}/python3.4/trace.py \
	${libdir}/python3.4/tracemalloc.py \
	${libdir}/python3.4/tty.py \
	${libdir}/python3.4/turtle.py \
	${libdir}/python3.4/unittest/* \
	${libdir}/python3.4/urllib/* \
	${libdir}/python3.4/uu.py \
	${libdir}/python3.4/uuid.py \
	${libdir}/python3.4/venv/ \
	${libdir}/python3.4/wave.py \
	${libdir}/python3.4/webbrowser.py \
	${libdir}/python3.4/wsgiref/* \
	${libdir}/python3.4/xdrlib.py \
	${libdir}/python3.4/xml/ \
	${libdir}/python3.4/xmlrpc/* \
	${libdir}/python3.4/zipfile.py \
"

FILES_libpython3.4-testsuite = " \
	${libdir}/python3.4/ctypes/test/* \
	${libdir}/python3.4/distutils/tests/* \
	${libdir}/python3.4/idlelib/idle_test/* \
	${libdir}/python3.4/lib2to3/tests/* \
	${libdir}/python3.4/sqlite3/test/* \
	${libdir}/python3.4/test/* \
"

# catch debug extensions (isn't that already in python-core-dbg?)
FILES_${PN}-dbg += "${libdir}/python${PYTHON_MAJMIN}/lib-dynload/.debug"

# catch all the rest (unsorted)
PACKAGES += "${PN}-misc"
RDEPENDS_${PN}-misc += "${PN}-core"
FILES_${PN}-misc = "${libdir}/python${PYTHON_MAJMIN}"

# catch manpage
PACKAGES += "${PN}-man"
FILES_${PN}-man = "${datadir}/man"

BBCLASSEXTEND = "nativesdk"

repository: iwamatsu/meta-debian

repo_name: iwamatsu/meta-debian

branch_name: refs/heads/jethro


text:
@Book{		  girard2007,
  author	= {J.-Y. Girard},
  publisher	= {Hermann},
  title		= {Le Point Aveugle II : Vers l'Imperfection},
  isbn		= {9782705666347},
  series	= {Visions des sciences},
  abstract	= {Le Point Aveugle II : Vers l'imperfection. Ce livre est à
		  la fois un cours de logique (théorie de la démonstration)
		  et d'épistémologie des "fondements". Il s'adresse aussi
		  bien aux mathématiciens qu'aux informaticiens, aux
		  philosophes qu'aux physiciens et aux linguistes. Le premier
		  tome Vers la perfection s'achevait sur la logique linéaire
		  et la distinction entre parfait et imparfait : le parfait
		  référant à un monde d'actions où l'on vit dans
		  l'instant loin des vérités pérennes, alors que
		  l'imparfait est le monde de l'infini et de la pérennité,
		  lieu du non-terminé. Alors que la perfection s'analyse
		  sans problème, tous les paradigmes logiques considérés
		  deviennent problématiques hors du mode parfait. Dans ce
		  second tome Vers l'imperfection, nous interrogeons ce monde
		  imparfait. En particulier, comment postuler la pérennité
		  sans postuler en même temps la pérennité de la
		  pérennité ? Une pérennité non pérenne s'exprime
		  cependant dans les logiques iconoclastes, des systèmes qui
		  font sens sur le papier, mais qu'on a du mal à asseoir :
		  la bonne intuition se trouve finalement du côté de la
		  mécanique quantique et des algèbres d'opérateurs : c'est
		  la géométrie de l'interaction. L'interprétation de
		  l'imperfection suppose la reconnaissance de l'intrication
		  entre sujet et objet : on découvre in fine que la
		  tradition logique a minimisé le rôle du sujet ;
		  paradoxalement, en cherchant des notions objectives, elle
		  est tombée dans le subjectivisme. Le premier tome
		  s'ouvrait sur l'essentialisme arrogant de Tarski : la
		  vérité est la qualité de ce qui est vrai. Le second tome
		  lui répond en se refermant sur une définition subjective
		  de la vérité, qui tient (enfin) compte de la place
		  prépondérante du sujet dans l'énonciation.},
  date		= {2007-03},
  organization	= {Hermann}
}

repository: mmontevil/visiondessciences

repo_name: mmontevil/visiondessciences


text:
require abiword.inc

RCONFLICTS = "abiword-embedded"

SRC_URI[md5sum] = "30fbd0a9b539f15f54f90d3812a75266"
SRC_URI[sha256sum] = "98105f03b1f33f26cddbfc18d64b04e64a85db3c861508837ab290d26ca2fed3"


text:
@Article{sagovac_estimation_2016,
  title = {Estimation of the firmâ€~s balance sheet channel effects during the economic crisis: Case of Croatia},
  language = {en},
  author = {Mislav {\a'L} agovac and Luka {\a'L} iki{\"A}NA},
  pages = {10--29},
  file = {A agovac and A ikiÄ‡ - 2016 - Estimation of the firmâ€~s balance sheet channel eff.pdf:C\:\\Users\\Lukas\\Zotero\\storage\\L9RVSLAY\\A agovac and A ikiÄ‡ - 2016 - Estimation of the firmâ€~s balance sheet channel eff.pdf:application/pdf},
  volume = {2},
  issn = {2459-5616},
  url = {https://www.degruyter.com/doi/10.1515/crebss-2016-0010},
  doi = {10.1515/crebss-2016-0010},
  abstract = {Economic theory recognizes the importance of the firmâ€™s balance sheet channel. This stands in stark contrast to the neoclassical theory of investment. This paper analyses the response of firms to the economic crisis in the sample of Croatian firms. Our main variables of interest are investment and employment. We estimated the OLS model that accounts for a heterogeneous response to the crisis shock of differently leveraged firms. The empirical model is augmented so that it accounts for industry and county effects. The robustness checks are performed for different dependent as well as control variables and interactions. The results strongly and robustly confirm the importance of the firmâ€™s balance sheet channel.},
  number = {2},
  urldate = {2020-11-27},
  journal = {Croatian Review of Economic, Business and Social Statistics},
  month = {dec},
  year = {2016},
  shorttitle = {Estimation of the firmâ€~s balance sheet channel effects during the economic crisis},
  pubtype = {2},
  date = {2016-01-01},
}

repository: lusiki/starter-academic

repo_name: lusiki/starter-academic


text:
DESCRIPTION = "auto mount and umount SDcard and USB storage"
SECTION = "userland"

FILESEXTRAPATHS_prepend := "${THISDIR}/files/:"

RDEPENDS_${PN} += "bash"

SRC_URI = "file://100-usbstorage.rules \
			file://autoinstall.sh \
			file://automount.sh \
			file://autoumount.sh"

LICENSE = "CLOSED"

PV = "0.4"
PR = "r1"

S = "${WORKDIR}"

inherit allarch update-alternatives

#FILESDIR = "${FILE_DIRNAME}/files/"

FILES_${PN}  += " \
 /lib/udev/rules.d/100-usbstorage.rules \
 /etc/automount.sh \
 /etc/autoumount.sh \
 /etc/autoinstall.sh \
"

do_install() {
	install -v -d  ${D}/etc/
	install -v -d  ${D}/lib/udev/rules.d/
    install -m 0755 automount.sh ${D}/etc/
    install -m 0755 autoumount.sh ${D}/etc/
    install -m 0755 autoinstall.sh ${D}/etc/
    install -m 0755 100-usbstorage.rules ${D}/lib/udev/rules.d/
}


text:
PST,Max TemperatureF,Mean TemperatureF,Min TemperatureF,Max Dew PointF,MeanDew PointF,Min DewpointF,Max Humidity, Mean Humidity, Min Humidity, Max Sea Level PressureIn, Mean Sea Level PressureIn, Min Sea Level PressureIn, Max VisibilityMiles, Mean VisibilityMiles, Min VisibilityMiles, Max Wind SpeedMPH, Mean Wind SpeedMPH, Max Gust SpeedMPH,PrecipitationIn, CloudCover, Events, WindDirDegrees

2008-2-1,59,52,45,46,42,36,77,65,53,30.22,30.14,30.09,10,10,10,17,5,31,0.00,3,,133

2008-2-2,57,53,48,45,38,28,80,58,35,30.16,30.11,30.08,10,10,10,15,7,26,0.00,4,,288

2008-2-3,58,54,49,52,46,38,93,76,59,30.09,29.93,29.83,10,6,1,30,14,43,0.68,6,Rain,265

2008-2-4,62,55,48,37,30,25,61,43,25,30.13,29.99,29.89,10,10,10,22,12,31,0.00,2,,323

2008-2-5,61,52,43,42,29,20,66,45,23,30.32,30.26,30.14,10,10,10,17,6,29,0.00,0,,283

2008-2-6,59,51,43,42,36,29,68,52,35,30.31,30.23,30.17,10,10,10,13,4,21,0.00,2,,127

2008-2-7,64,55,45,50,43,35,83,60,36,30.24,30.16,30.09,10,10,9,15,5,26,0.00,1,,242

2008-2-8,69,59,48,49,44,38,89,63,37,30.10,30.07,30.04,10,10,7,14,4,28,0.00,2,Fog,247

2008-2-9,82,66,49,45,36,26,71,43,14,30.10,30.06,30.04,10,10,10,15,5,20,0.00,0,,323

2008-2-10,74,62,49,49,41,33,72,48,23,30.12,30.07,30.04,10,10,10,12,5,23,0.00,2,,222

2008-2-11,72,61,49,49,45,40,77,57,36,30.07,30.04,30.01,10,9,5,13,4,22,0.00,1,,122

2008-2-12,78,64,50,54,50,38,93,59,25,30.09,30.03,29.98,10,8,0,16,5,28,0.00,1,Fog,236

2008-2-13,57,54,50,52,50,47,100,86,72,29.99,29.89,29.78,10,3,0,14,5,21,0.00,7,Fog,211

2008-2-14,60,55,50,48,35,13,83,49,15,30.02,29.85,29.76,10,10,10,17,8,26,T,4,Rain,17

2008-2-15,66,59,52,43,30,16,66,43,19,30.18,30.09,30.02,10,10,10,28,9,38,0.00,0,,285

2008-2-16,63,55,46,48,43,34,77,65,53,30.23,30.18,30.15,10,10,9,15,5,23,0.00,2,,237

2008-2-17,60,55,50,49,46,44,86,74,62,30.17,30.12,30.08,10,8,5,14,6,17,0.00,4,,277

2008-2-18,58,54,49,48,47,46,89,78,67,30.11,30.06,30.03,10,7,3,16,6,30,0.00,6,,249

2008-2-19,59,56,53,48,47,46,83,75,67,30.17,30.12,30.07,10,10,8,14,6,23,0.02,6,,226

2008-2-20,59,56,52,56,50,44,93,80,66,30.16,30.07,29.98,10,7,1,33,10,38,0.26,7,Fog-Rain,210

2008-2-21,60,55,50,50,46,44,89,72,55,30.12,30.05,30.02,10,8,2,21,8,30,0.18,7,Rain,91

2008-2-22,58,54,49,52,48,43,93,77,61,30.08,29.98,29.93,10,8,2,24,12,31,0.10,6,Rain,214

2008-2-23,62,55,47,48,45,42,86,69,51,30.16,30.12,30.05,10,10,4,20,7,35,0.18,6,Rain,109

2008-2-24,60,55,50,52,49,46,93,79,64,30.23,30.16,30.09,10,6,2,25,10,35,0.75,6,Rain,113

2008-2-25,64,56,48,49,46,44,86,69,52,30.25,30.19,30.14,10,10,9,15,5,26,0.00,2,,278

2008-2-26,79,66,52,49,41,32,83,51,19,30.18,30.13,30.09,10,10,10,16,4,26,0.00,1,,270

2008-2-27,78,68,57,54,42,33,86,55,23,30.11,30.01,29.91,10,10,10,17,6,26,0.00,1,Fog,286

2008-2-28,69,60,50,54,51,46,93,74,55,30.02,29.93,29.88,10,7,2,15,5,28,0.00,4,Fog,184

2008-2-29,61,57,53,51,49,48,90,77,64,30.18,30.10,30.02,10,7,4,15,6,25,0.00,6,,228

repository: nhuntwalker/mystuff

repo_name: nhuntwalker/mystuff


text:
// Copyright (c) 2015 Uber Technologies, Inc.

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

package testutils

import (
	"sync"

	"go.uber.org/atomic"
)

// Decrement is the interface returned by Decrementor.
type Decrement interface {
	// Single returns whether any more tokens are remaining.
	Single() bool

	// Multiple tries to get n tokens. It returns the actual amount of tokens
	// available to use. If this is 0, it means there are no tokens left.
	Multiple(n int) int
}

type decrementor struct {
	n atomic.Int64
}

func (d *decrementor) Single() bool {
	return d.n.Dec() >= 0
}

func (d *decrementor) Multiple(n int) int {
	decBy := -1 * int64(n)
	decremented := d.n.Add(decBy)
	if decremented <= decBy {
		// Already out of tokens before this decrement.
		return 0
	} else if decremented < 0 {
		// Not enough tokens, return how many tokens we actually could decrement.
		return n + int(decremented)
	}

	return n
}

// Decrementor returns a function that can be called from multiple goroutines and ensures
// it will only return true n times.
func Decrementor(n int) Decrement {
	return &decrementor{
		n: *atomic.NewInt64(int64(n)),
	}
}

// Batch returns a slice with n broken into batches of size batchSize.
func Batch(n, batchSize int) []int {
	fullBatches := n / batchSize
	batches := make([]int, 0, fullBatches+1)
	for i := 0; i < fullBatches; i++ {
		batches = append(batches, batchSize)
	}
	if remaining := n % batchSize; remaining > 0 {
		batches = append(batches, remaining)
	}
	return batches
}

// Buckets splits n over the specified number of buckets.
func Buckets(n int, numBuckets int) []int {
	perBucket := n / numBuckets

	buckets := make([]int, numBuckets)
	for i := range buckets {
		buckets[i] = perBucket
		if i == 0 {
			buckets[i] += n % numBuckets
		}
	}
	return buckets
}

// RunN runs the given f n times (and passes the run's index) and waits till they complete.
// It starts n-1 goroutines, and runs one instance in the current goroutine.
func RunN(n int, f func(i int)) {
	var wg sync.WaitGroup
	for i := 0; i < n-1; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			f(i)
		}(i)
	}
	f(n - 1)
	wg.Wait()
}

repository: uber/tchannel-go

repo_name: uber/tchannel-go

branch_name: refs/heads/dev

gha_license_id: MIT


text:
package uploadedissuehandler

import (
	"fmt"
	"html/template"
	"path/filepath"
	"strings"

	"github.com/uoregon-libraries/newspaper-curation-app/src/internal/logger"
	"github.com/uoregon-libraries/newspaper-curation-app/src/models"
	"github.com/uoregon-libraries/newspaper-curation-app/src/schema"
	"github.com/uoregon-libraries/newspaper-curation-app/src/uploads"
)

// TitleType tells us if a title contains born-digital issues or scanned
type TitleType int

// The two constants for TitleType
const (
	TitleTypeScanned TitleType = iota
	TitleTypeBornDigital
)

// String tells us a human-friendly meaning for the type of title
func (tt TitleType) String() string {
	switch tt {
	case TitleTypeScanned:
		return "Scanned"
	case TitleTypeBornDigital:
		return "BornDigital"
	}

	return "N/A"
}

// Title wraps a schema.Title with some extra information for web presentation.
type Title struct {
	*schema.Title
	MOC         string
	Issues      []*Issue
	IssueLookup map[string]*Issue
	Type        TitleType
}

func (t *Title) decorateIssues(issueList []*schema.Issue) {
	t.Issues = make([]*Issue, 0)
	t.IssueLookup = make(map[string]*Issue)
	for _, i := range issueList {
		if !searcher.IsInProcess(i.Key()) {
			t.appendSchemaIssue(i)
		}
	}
}

func (t *Title) appendSchemaIssue(i *schema.Issue) *Issue {
	var uIssue = uploads.New(i, watcher.Scanner, conf)
	var issue = &Issue{
		Issue: uIssue,
		Slug:  i.DateEdition(),
		Title: t,
	}
	issue.decorateFiles(uIssue.Files)
	issue.decoratePriorJobLogs()
	issue.ValidateFast()
	t.Issues = append(t.Issues, issue)
	t.IssueLookup[issue.Slug] = issue

	return issue
}

// Show returns true if the title has any issues or errors.  If there are no
// errors and no issues, there's no reason to display it.
func (t *Title) Show() bool {
	return len(t.Issues) > 0 || t.HasErrors()
}

// HasErrors reports true if this title has any errors - due to the way
// AddError works in the schema, this will report true if the title has an
// error *or* if one or more issues have errors
func (t *Title) HasErrors() bool {
	return t.Errors.Major().Len() > 0
}

// Link returns a link for this title
func (t *Title) Link() template.HTML {
	return template.HTML(fmt.Sprintf(`<a href="%s">%s</a>`, TitlePath(t.Slug()), t.Name))
}

// Slug generates a URL for the title based on its type, marc org code, and LCCN
func (t *Title) Slug() string {
	var parts = []string{"", t.MOC, t.LCCN}
	switch t.Type {
	case TitleTypeBornDigital:
		parts[0] = "dig"
	case TitleTypeScanned:
		parts[0] = "scan"
	}

	return strings.Join(parts, "-")
}

// Issue wraps uploads.Issue for web presentation
type Issue struct {
	*uploads.Issue
	Slug       string           // Short, URL-friendly identifier for an issue
	Title      *Title           // Title to which this issue belongs
	QueueInfo  template.HTML    // Informational message from the queue process, if any
	Files      []*File          // List of files
	FileLookup map[string]*File // Lookup for finding a File by its filename / slug
}

func (i *Issue) decorateFiles(fileList []*uploads.File) {
	i.Files = make([]*File, 0)
	i.FileLookup = make(map[string]*File)
	for _, f := range fileList {
		var slug = filepath.Base(f.Location)
		var pdf = &File{File: f, Slug: slug, Issue: i}
		i.Files = append(i.Files, pdf)
		i.FileLookup[pdf.Slug] = pdf
	}
}

// decoratePriorJobLogs adds information to issues that have old failed jobs.
func (i *Issue) decoratePriorJobLogs() {
	var dbi, err = models.FindIssueByKey(i.Key())
	if err != nil {
		logger.Warnf("Unable to look up issue for decorating queue messages: %s", err)
		return
	}
	if dbi == nil {
		return
	}

	var dbJobs []*models.Job
	dbJobs, err = dbi.Jobs()
	if err != nil {
		logger.Errorf("Unable to look up jobs for issue id %d (%q): %s", dbi.ID, i.Key(), err)
		return
	}

	var subErrors []string
	for _, j := range dbJobs {
		// We only care to report on the failed jobs, as those haven't been requeued
		if j.Status != string(models.JobStatusFailed) {
			continue
		}

		for _, log := range j.Logs() {
			switch log.LogLevel {
			case "DEBUG", "INFO", "WARN":
				continue
			case "ERROR", "CRIT":
				subErrors = append(subErrors, log.Message)
			default:
				logger.Errorf("Unknown job log level: %q", log.LogLevel)
			}
		}
	}

	if len(subErrors) > 0 {
		var listItems string
		for _, e := range subErrors {
			listItems += "
" + e + "
\n"
		}
		var msg = fmt.Sprintf(`
			A previous queue attempt failed, but you can attempt to re-queue or
			contact the system administrator.

			Details:

				%s

			`, listItems)
		i.QueueInfo = template.HTML(msg)
	}
}

// Link returns a link for this title
func (i *Issue) Link() template.HTML {
	var path = IssuePath(i.Title.Slug(), i.Slug)
	return template.HTML(fmt.Sprintf(`<a href="%s">%s</a>`, path, i.RawDate))
}

// WorkflowPath returns the path to perform a workflow action against this issue
func (i *Issue) WorkflowPath(action string) string {
	return IssueWorkflowPath(i.Title.Slug(), i.Slug, action)
}

// HasErrors reports true if this issue has any errors - due to the way
// AddError works in the schema, this will report true if the issue has an
// error *or* if one or more files have errors
func (i *Issue) HasErrors() bool {
	return i.Errors.Major().Len() > 0
}

// HasWarnings reports true if this issue has any warnings
func (i *Issue) HasWarnings() bool {
	return i.Errors.Minor().Len() > 0
}

// ChildErrors reports the number of files with errors
func (i *Issue) ChildErrors() (n int) {
	for _, f := range i.Files {
		if f.HasErrors() {
			n++
		}
	}

	return n
}

// File wraps a schema.File for web presentation
type File struct {
	*uploads.File
	Issue *Issue
	Slug  string
}

// Link returns a link for this title
func (f *File) Link() template.HTML {
	var path = FilePath(f.Issue.Title.Slug(), f.Issue.Slug, f.Slug)
	return template.HTML(fmt.Sprintf(`<a href="%s">%s</a>`, path, f.Slug))
}

// RelativePath returns the location on disk relative to the title's location
// on disk (primarily to help locate SFTP issues)
func (f *File) RelativePath() string {
	return strings.Replace(f.Location, f.Issue.Title.Location, "", 1)
}

// HasErrors reports true if this file has any errors
func (f *File) HasErrors() bool {
	return f.Errors.Major().Len() > 0
}


text:
@article{national_highway_traffic_safety_administration_nhtsa_federal_2017,
	title = {Federal {Motor} {Vehicle} {Safety} {Standards}; {V}2V {Communications}; {Notice} of {Proposed} {Rulemaking} ({NPRM})},
	url = {https://www.federalregister.gov/documents/2017/01/12/2016-31059/federal-motor-vehicle-safety-standards-v2v-communications},
	author = {National Highway Traffic Safety Administration (NHTSA), U.S. Department of Transportation},
	month = jan,
	year = {2017}
}

@article{petit_potential_2015,
	title = {Potential {Cyberattacks} on {Automated} {Vehicles}},
	volume = {16},
	number = {2},
	journal = {IEEE Transactions on Intelligent Transportation Systems},
	author = {Petit, J. and Shladover, S. E.},
	year = {2015},
	pages = {546--556}
}

@article{whyte_security_2013,
	title = {A {Security} {Credential} {Management} {System} for {V}2V {Communications}},
	journal = {IEEE Vehicular Networking Conference (VNC 2013)},
	author = {Whyte, W. and Weimerskirch, A. and Kumar, V. and Hehn, T.},
	year = {2013}
}

@article{brecht_security_2018,
	title = {A {Security} {Credential} {Management} {System} for {V}2X {Communications}},
	author = {Brecht, B. and Therriault, D. and Weimerskirch, A. and Whyte, W. and Kumar, V. and Hehn, T. and Goudy, R.},
	month = feb,
	year = {2018}
}

@article{petit_pseudonym_2015,
	title = {Pseudonym {Schemes} in {Vehicular} {Networks}: {A} {Survey}},
	number = {1},
	journal = {IEEE Communications Surveys and Tutorials},
	author = {Petit, J. and Schaub, F. and Feiri, M. and Kargl, F.},
	year = {2015},
	pages = {228--255}
}

@article{haas_efficient_2011,
	title = {Efficient {Certificate} {Revocation} {List} {Distribution}},
	volume = {29},
	number = {3},
	journal = {IEEE Journal of Selected Areas in Communcations - Special Issue on Vehicular Communcations and Networks},
	author = {Haas, J. J. and Hu, Y.-C. and Laberteaux, K. P.},
	month = jan,
	year = {2011},
	pages = {595--604}
}

@article{raya_securing_2006,
	title = {Securing {Vehicular} {Communications}},
	volume = {13},
	number = {5},
	journal = {IEEE Wireless Communications},
	author = {Raya, M. and Papadimitratos, P. and Hubaux, J.-P.},
	year = {2006},
	pages = {9--15}
}

@book{sharma_securing_2017,
	title = {Securing {Wireless} {Communications} of {Connected} {Vehicles} with {Artificial} {Intelligence}},
	author = {Sharma, P. and Liu, H. and Wang, H. and Zhang, S.},
	year = {2017}
}

@article{brecht_elector-based_2015,
	title = {Elector-{Based} {Root} {Management} {System} {To} {Manage} {A} {Public} {Key} {Infrastructure}},
	journal = {Crash Avoidance Metrics Partners LLC (CAMP) Vehicle Safety Communications 5 (VSC5) Consortium},
	author = {Brecht, B. and Therriault, D. and Motz, R. and Kumar, V. and Lambert, R. and Lattin, B. and Romansky, B. and Whyte, W.},
	year = {2015},
	pages = {17}
}

@article{haidar_performance_2017,
	title = {On the performance evaluation of {Vehicular} {PKI} protocol for {V}2X communications security},
	journal = {IEEE 86th Vehicular Technology Conference (VTC2017-Fall), Toronto, Canada},
	author = {Haidar, F. and Kaiser, A. and Lonc, B.},
	year = {2017}
}

@misc{brecht_scms_nodate,
	title = {{SCMS} {CV} {Pilots} {Documentation} - {SCMS} {CV} {Pilots} {Documentation} - {CAMP} {Wiki}},
	url = {https://wiki.campllc.org/display/SCP/},
	urldate = {2018-05-09},
	author = {Brecht, Benedikt}
}

repository: FlatTargetInk/ThesisResearch

repo_name: FlatTargetInk/ThesisResearch


text:
.root {
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
}

.root svg {
  line-height: inherit;
  vertical-align: middle;
}

repository: appearhere/bloom

repo_name: appearhere/bloom

gha_language: JavaScript

extension: css


text:
SUMMARY = "Framework tools base components (core,kernel,network,audio,ui,python2,python3)"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

PACKAGE_ARCH = "${MACHINE_ARCH}"

inherit packagegroup

PROVIDES = "${PACKAGES}"
PACKAGES = "\
            packagegroup-framework-tools-base           \
            packagegroup-framework-tools-base-core      \
            packagegroup-framework-tools-base-kernel    \
            packagegroup-framework-tools-base-network   \
            packagegroup-framework-tools-base-audio     \
            packagegroup-framework-tools-base-ui        \
            packagegroup-framework-tools-base-python3   \
            "

# Manage to provide all framework tools base packages with overall one
RDEPENDS_packagegroup-framework-tools-base = "\
    packagegroup-framework-tools-base-core      \
    packagegroup-framework-tools-base-kernel    \
    packagegroup-framework-tools-base-network   \
    packagegroup-framework-tools-base-audio     \
    packagegroup-framework-tools-base-ui        \
    packagegroup-framework-tools-base-python3   \
    "

SUMMARY_packagegroup-framework-tools-base-core = "Framework tools base components for core"
RDEPENDS_packagegroup-framework-tools-base-core = "\
    ckermit         \
    coreutils       \
    libiio-iiod     \
    libiio-tests    \
    lrzsz           \
    libgpiod        \
    libgpiod-tools  \
    ${@bb.utils.contains('DISTRO_FEATURES', 'usbgadget', 'usbotg-gadget-config', '', d)} \
    "

SUMMARY_packagegroup-framework-tools-base-kernel = "Framework tools base components for kernel"
RDEPENDS_packagegroup-framework-tools-base-kernel = "\
    can-utils       \
    i2c-tools       \
    strace          \
    usbutils        \
    \
    evtest          \
    memtester       \
    mtd-utils       \
    v4l-utils       \
    proftpd	    \
    vsftpd	    \
    "

SUMMARY_packagegroup-framework-tools-base-network = "Framework tools base components for network"
RDEPENDS_packagegroup-framework-tools-base-network = "\
    ethtool         \
    iproute2        \
    curl            \
    "

SUMMARY_packagegroup-framework-tools-base-audio = "Framework tools base components for audio"
RDEPENDS_packagegroup-framework-tools-base-audio = "\
    ${@bb.utils.contains('DISTRO_FEATURES', 'alsa', 'libasound alsa-conf', '', d)}  \
    ${@bb.utils.contains('DISTRO_FEATURES', 'alsa', 'alsa-utils', '', d)}           \
    ${@bb.utils.contains('DISTRO_FEATURES', 'alsa', 'alsa-plugins', '', d)}         \
    "

SUMMARY_packagegroup-framework-tools-base-ui = "Framework tools base components for ui"
RDEPENDS_packagegroup-framework-tools-base-ui = "\
    "

SUMMARY_packagegroup-framework-tools-base-python3 = "Framework tools base components for python3"
RDEPENDS_packagegroup-framework-tools-base-python3 = "\
    "

repository: MYiR-Dev/meta-myir-st-tiny

repo_name: MYiR-Dev/meta-myir-st-tiny