text:
package operators

import (
	"context"
	"encoding/json"
	"fmt"

	destinationcreatorpkg "github.com/kyma-incubator/compass/components/director/pkg/destinationcreator"

	"github.com/kyma-incubator/compass/components/director/pkg/persistence"

	"github.com/hashicorp/go-multierror"
	"github.com/kyma-incubator/compass/components/director/internal/domain/formationconstraint"
	"github.com/kyma-incubator/compass/components/director/internal/model"
	formationconstraintpkg "github.com/kyma-incubator/compass/components/director/pkg/formationconstraint"
	"github.com/kyma-incubator/compass/components/director/pkg/log"
	"github.com/pkg/errors"
)

//go:generate mockery --exported --name=formationConstraintSvc --output=automock --outpkg=automock --case=underscore --disable-version-string
type formationConstraintSvc interface {
	ListMatchingConstraints(ctx context.Context, formationTemplateID string, location formationconstraintpkg.JoinPointLocation, details formationconstraintpkg.MatchingDetails) ([]*model.FormationConstraint, error)
}

//go:generate mockery --exported --name=tenantService --output=automock --outpkg=automock --case=underscore --disable-version-string
type tenantService interface {
	GetInternalTenant(ctx context.Context, externalTenant string) (string, error)
}

//go:generate mockery --exported --name=automaticScenarioAssignmentService --output=automock --outpkg=automock --case=underscore --disable-version-string
type automaticScenarioAssignmentService interface {
	ListForTargetTenant(ctx context.Context, targetTenantInternalID string) ([]*model.AutomaticScenarioAssignment, error)
}

//go:generate mockery --exported --name=destinationService --output=automock --outpkg=automock --case=underscore --disable-version-string
type destinationService interface {
	CreateDesignTimeDestinations(ctx context.Context, destinationsDetails []Destination, formationAssignment *model.FormationAssignment) error
	CreateBasicCredentialDestinations(ctx context.Context, destinationsDetails []Destination, basicAuthenticationCredentials BasicAuthentication, formationAssignment *model.FormationAssignment, correlationIDs []string) error
	CreateSAMLAssertionDestination(ctx context.Context, destinationsDetails []Destination, samlAssertionAuthCredentials *SAMLAssertionAuthentication, formationAssignment *model.FormationAssignment, correlationIDs []string) error
	CreateClientCertificateAuthenticationDestination(ctx context.Context, destinationsDetails []Destination, clientCertAuthCredentials *ClientCertAuthentication, formationAssignment *model.FormationAssignment, correlationIDs []string) error
	DeleteDestinations(ctx context.Context, formationAssignment *model.FormationAssignment) error
}

//go:generate mockery --exported --name=destinationCreatorService --output=automock --outpkg=automock --case=underscore --disable-version-string
type destinationCreatorService interface {
	CreateCertificate(ctx context.Context, destinationsDetails []Destination, destinationAuthType destinationcreatorpkg.AuthType, formationAssignment *model.FormationAssignment, depth uint8) (*CertificateData, error)
	EnrichAssignmentConfigWithCertificateData(assignmentConfig json.RawMessage, destinationTypePath string, certData *CertificateData) (json.RawMessage, error)
	EnrichAssignmentConfigWithSAMLCertificateData(assignmentConfig json.RawMessage, destinationTypePath string, certData *CertificateData) (json.RawMessage, error)
}

//go:generate mockery --exported --name=formationRepository --output=automock --outpkg=automock --case=underscore --disable-version-string
type formationRepository interface {
	ListByFormationNames(ctx context.Context, formationNames []string, tenantID string) ([]*model.Formation, error)
}

//go:generate mockery --exported --name=labelRepository --output=automock --outpkg=automock --case=underscore --disable-version-string
type labelRepository interface {
	GetByKey(ctx context.Context, tenant string, objectType model.LabelableObject, objectID, key string) (*model.Label, error)
	ListForObject(ctx context.Context, tenant string, objectType model.LabelableObject, objectID string) (map[string]*model.Label, error)
	ListForGlobalObject(ctx context.Context, objectType model.LabelableObject, objectID string) (map[string]*model.Label, error)
}

//go:generate mockery --exported --name=applicationRepository --output=automock --outpkg=automock --case=underscore --disable-version-string
type applicationRepository interface {
	ListByScenariosNoPaging(ctx context.Context, tenant string, scenarios []string) ([]*model.Application, error)
	GetByID(ctx context.Context, tenant, id string) (*model.Application, error)
	OwnerExists(ctx context.Context, tenant, id string) (bool, error)
}

//go:generate mockery --exported --name=labelService --output=automock --outpkg=automock --case=underscore --disable-version-string
type labelService interface {
	GetByKey(ctx context.Context, tenant string, objectType model.LabelableObject, objectID, key string) (*model.Label, error)
}

//go:generate mockery --exported --name=runtimeContextRepo --output=automock --outpkg=automock --case=underscore --disable-version-string
type runtimeContextRepo interface {
	GetByID(ctx context.Context, tenant, id string) (*model.RuntimeContext, error)
}

//go:generate mockery --exported --name=formationTemplateRepo --output=automock --outpkg=automock --case=underscore --disable-version-string
type formationTemplateRepo interface {
	Get(ctx context.Context, id string) (*model.FormationTemplate, error)
}

// FormationAssignmentRepository represents the Formation Assignment repository layer
//go:generate mockery --name=formationAssignmentRepository --output=automock --outpkg=automock --case=underscore --disable-version-string
type formationAssignmentRepository interface {
	Update(ctx context.Context, model *model.FormationAssignment) error
}

// OperatorInput represents the input needed by the constraint operator
type OperatorInput interface{}

// OperatorName represents the constraint operator name
type OperatorName string

// OperatorFunc provides an interface for functions implementing constraint operators
type OperatorFunc func(ctx context.Context, input OperatorInput) (bool, error)

// OperatorInputConstructor returns empty OperatorInput for a certain constraint operator
type OperatorInputConstructor func() OperatorInput

// ConstraintEngine determines which constraints are applicable to the reached join point and enforces them
type ConstraintEngine struct {
	transact                  persistence.Transactioner
	constraintSvc             formationConstraintSvc
	tenantSvc                 tenantService
	asaSvc                    automaticScenarioAssignmentService
	destinationSvc            destinationService
	destinationCreatorSvc     destinationCreatorService
	formationRepo             formationRepository
	labelRepo                 labelRepository
	labelService              labelService
	applicationRepository     applicationRepository
	runtimeContextRepo        runtimeContextRepo
	formationTemplateRepo     formationTemplateRepo
	formationAssignmentRepo   formationAssignmentRepository
	operators                 map[OperatorName]OperatorFunc
	operatorInputConstructors map[OperatorName]OperatorInputConstructor
	runtimeTypeLabelKey       string
	applicationTypeLabelKey   string
}

// NewConstraintEngine returns new ConstraintEngine
func NewConstraintEngine(transact persistence.Transactioner, constraintSvc formationConstraintSvc, tenantSvc tenantService, asaSvc automaticScenarioAssignmentService, destinationSvc destinationService, destinationCreatorSvc destinationCreatorService, formationRepo formationRepository, labelRepo labelRepository, labelService labelService, applicationRepository applicationRepository, runtimeContextRepo runtimeContextRepo, formationTemplateRepo formationTemplateRepo, formationAssignmentRepo formationAssignmentRepository, runtimeTypeLabelKey string, applicationTypeLabelKey string) *ConstraintEngine {
	c := &ConstraintEngine{
		transact:                transact,
		constraintSvc:           constraintSvc,
		tenantSvc:               tenantSvc,
		asaSvc:                  asaSvc,
		destinationSvc:          destinationSvc,
		destinationCreatorSvc:   destinationCreatorSvc,
		formationRepo:           formationRepo,
		labelRepo:               labelRepo,
		labelService:            labelService,
		applicationRepository:   applicationRepository,
		runtimeContextRepo:      runtimeContextRepo,
		formationTemplateRepo:   formationTemplateRepo,
		formationAssignmentRepo: formationAssignmentRepo,
		operatorInputConstructors: map[OperatorName]OperatorInputConstructor{
			IsNotAssignedToAnyFormationOfTypeOperator:            NewIsNotAssignedToAnyFormationOfTypeInput,
			DoesNotContainResourceOfSubtypeOperator:              NewDoesNotContainResourceOfSubtypeInput,
			DoNotGenerateFormationAssignmentNotificationOperator: NewDoNotGenerateFormationAssignmentNotificationInput,
			DestinationCreatorOperator:                           NewDestinationCreatorInput,
		},
		runtimeTypeLabelKey:     runtimeTypeLabelKey,
		applicationTypeLabelKey: applicationTypeLabelKey,
	}
	c.operators = map[OperatorName]OperatorFunc{
		IsNotAssignedToAnyFormationOfTypeOperator:            c.IsNotAssignedToAnyFormationOfType,
		DoesNotContainResourceOfSubtypeOperator:              c.DoesNotContainResourceOfSubtype,
		DoNotGenerateFormationAssignmentNotificationOperator: c.DoNotGenerateFormationAssignmentNotification,
		DestinationCreatorOperator:                           c.DestinationCreator,
	}
	return c
}

// EnforceConstraints finds all the applicable constraints based on JoinPointLocation and JoinPointDetails. Checks for each constraint if it is satisfied.
// If any constraint is not satisfied this information is stored and the engine proceeds with enforcing the next constraint if such exists. In the end if
// any constraint was not satisfied an error is returned.
func (e *ConstraintEngine) EnforceConstraints(ctx context.Context, location formationconstraintpkg.JoinPointLocation, details formationconstraintpkg.JoinPointDetails, formationTemplateID string) error {
	matchingDetails := details.GetMatchingDetails()
	log.C(ctx).Infof("Enforcing constraints for target operation %q, constraint type %q, resource type %q and resource subtype %q", location.OperationName, location.ConstraintType, matchingDetails.ResourceType, matchingDetails.ResourceSubtype)

	constraints, err := e.constraintSvc.ListMatchingConstraints(ctx, formationTemplateID, location, matchingDetails)
	if err != nil {
		return errors.Wrapf(err, "While listing matching constraints for target operation %q, constraint type %q, resource type %q and resource subtype %q", location.OperationName, location.ConstraintType, matchingDetails.ResourceType, matchingDetails.ResourceSubtype)
	}

	matchedConstraintsNames := make([]string, 0, len(constraints))
	for _, c := range constraints {
		matchedConstraintsNames = append(matchedConstraintsNames, c.Name)
	}

	log.C(ctx).Infof("Matched constraints: %v", matchedConstraintsNames)

	var errs *multierror.Error
	for _, mc := range constraints {
		operatorFunc, ok := e.operators[OperatorName(mc.Operator)]
		if !ok {
			errs = multierror.Append(errs, formationconstraint.ConstraintError{
				ConstraintName: mc.Name,
				Reason:         fmt.Sprintf("Operator %q not found", mc.Operator),
			})
			continue
		}

		operatorInputConstructor, ok := e.operatorInputConstructors[OperatorName(mc.Operator)]
		if !ok {
			errs = multierror.Append(errs, formationconstraint.ConstraintError{
				ConstraintName: mc.Name,
				Reason:         fmt.Sprintf("Operator input constructor for operator %q not found", mc.Operator),
			})
			continue
		}

		operatorInput := operatorInputConstructor()
		if err := formationconstraintpkg.ParseInputTemplate(mc.InputTemplate, details, operatorInput); err != nil {
			log.C(ctx).Errorf("An error occurred while parsing input template for formation constraint %q: %s", mc.Name, err.Error())
			errs = multierror.Append(errs, formationconstraint.ConstraintError{
				ConstraintName: mc.Name,
				Reason:         fmt.Sprintf("Failed to parse operator input template for operator %q", mc.Operator),
			})
			continue
		}

		operatorResult, err := operatorFunc(ctx, operatorInput)
		if err != nil {
			errs = multierror.Append(errs, formationconstraint.ConstraintError{
				ConstraintName: mc.Name,
				Reason:         fmt.Sprintf("An error occurred while executing operator %q for formation constraint %q: %v", mc.Operator, mc.Name, err),
			})
		}

		if !operatorResult {
			errs = multierror.Append(errs, formationconstraint.ConstraintError{
				ConstraintName: mc.Name,
				Reason:         fmt.Sprintf("Operator %q is not satisfied", mc.Operator),
			})
		}
	}

	return errs.ErrorOrNil()
}

repository: kyma-incubator/compass

repo_name: kyma-incubator/compass


text:
DESCRIPTION = "tool to show how long a CPU or cluster enters idle state"
SUMMARY = "Idlestat is a tool which can show how long a CPU or cluster \
enters idle state. This infomation is obtained using traces from trace-cmd \
or ftrace tools."
LICENSE = "GPL-2.0"
LIC_FILES_CHKSUM = "file://Makefile;md5=1e2d28a88b081f97157089bb67d4249d"
SRCREV = "6de5e87ccf87beb0946c627c10554efb1480326f"
PV = "0.2+git${SRCPV}"

SRC_URI = "git://git.linaro.org/power/idlestat.git"

S = "${WORKDIR}/git"

do_install () {
    install -D -p -m0755 idlestat ${D}/${sbindir}/idlestat
}

license: MIT

repository: linaro-mmwg/meta-linaro

license_type: permissive

repo_name: linaro-mmwg/meta-linaro

branch_name: refs/heads/master

extension: bb


text:
% Encoding: UTF-8

@Misc{sp20-516-223-aws-rm,
  author       = {{Amazon}},
  title        = {AWS RoboMaker},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/robomaker},
}

@Misc{sp20-516-223-aws-rm-ft,
  author       = {{Amazon}},
  title        = {AWS RoboMaker Features},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/robomaker/features},
}

@Misc{sp20-516-223-aws-rm-kinesis,
  author       = {{Amazon}},
  title        = {Amazon Kinesis},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/kinesis},
}

@Misc{sp20-516-223-aws-rm-rekognition,
  author       = {{Amazon}},
  title        = {Amazon Rekognition},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/rekognition},
}

@Misc{sp20-516-223-aws-rm-polly,
  author       = {{Amazon}},
  title        = {Amazon Polly},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/polly},
}

@Misc{sp20-516-223-aws-rm-cloudwatch,
  author       = {{Amazon}},
  title        = {Amazon CloudWatch},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/cloudwatch},
}

@Misc{sp20-516-223-aws-rm-greengrass,
  author       = {{Amazon}},
  title        = {AWS IoT Greengrass},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/greengrass},
}

@Misc{sp20-516-223-aws-account,
  author       = {Gregor von Laszewski},
  title        = {AWS Account},
  howpublished = {Web Page},
  url          = {https://cloudmesh.github.io/cloudmesh-manual/accounts/aws.html},
}

@Misc{sp20-516-223-aws-rm-gs-info,
  author       = {{Amazon}},
  title        = {Important Licensing Information},
  howpublished = {Web Page},
  url          = {https://docs.aws.amazon.com/robomaker/latest/dg/gs-info.html},
}

@Misc{sp20-516-223-aws-rm-c9-price,
  author       = {{Amazon}},
  title        = {AWS Cloud9 Pricing},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/cloud9/pricing},
}

@Misc{sp20-516-223-aws-rm-gg-price,
  author       = {{Amazon}},
  title        = {AWS IoT Greengrass Pricing},
  howpublished = {Web Page},
  url          = {https://aws.amazon.com/greengrass/pricing},
}

@Misc{sp20-516-223-aws-rm-sample,
  author       = {{Amazon}},
  title        = {Sample Applications},
  howpublished = {Web Page},
  url          = {https://docs.aws.amazon.com/robomaker/latest/dg/sample-applications.html},
}

@Comment{jabref-meta: databaseType:bibtex;}

extension: bib


text:
package cmd

import (
	"fmt"

	"github.com/spf13/cobra"
)

// checkCmd represents the check command
var checkCmd = &cobra.Command{
	Use:   "check",
	Short: "Check the status of your servers and their current state",
	Long:  `Check the status of your servers and their current state`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Check command not yet implemented!!!")
	},
}

func init() {
	RootCmd.AddCommand(checkCmd)
}

branch_name: refs/heads/develop

gha_language: Go

extension: go


text:
DESCRIPTION = "An audio Sample Rate Conversion library"
SECTION = "libs"
LICENSE = "GPL libsamplerate"

PR = "r2"

SRC_URI = "http://www.mega-nerd.com/SRC/libsamplerate-${PV}.tar.gz \
           file://libsamplerate-0.1.7-macro-quoting.patch;striplevel=0 \
           file://libsamplerate-0.1.7-tests.patch "
S = "${WORKDIR}/libsamplerate-${PV}"

inherit autotools pkgconfig

SRC_URI[md5sum] = "6731a81cb0c622c483b28c0d7f90867d"
SRC_URI[sha256sum] = "78ed5d9ff1bf162c4a078f6a3e7432a537dd2f22dc58872b081fb01156027fcc"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
DESCRIPTION = "X protocol headers"
SECTION = "x11/libs"
LICENSE= "MIT-X"
#MAINTAINER = ""

SRC_URI = "${XORG_MIRROR}/X11R7.0/src/proto/fontsproto-${PV}.tar.bz2"
S = "${WORKDIR}/fontsproto-${PV}"

inherit native autotools pkgconfig


text:
@Manual{citeR,
    title = {R: A Language and Environment for Statistical Computing},
    author = {{R Core Team}},
    organization = {R Foundation for Statistical Computing},
    address = {Vienna, Austria},
    year = {2020},
    url = {https://www.R-project.org/},
  }
@Manual{restcan,
    title = {COVID-19 having devastating impact on restaurant operators},
    author = {{Restaurants Canada}},
    organization = {Restaurants Canada},
    address = {Ontario, Canada},
    year = {202},
    url = {https://www.restaurantscanada.org/resources/covid-19-having-devastating-impact-on-restaurant-operators/},
  }
@Manual{license2021,
    title = {Municipal Licensing and Standards - Business Licences and Permits},
    author = {{Municipal Licensing & Standards}},
    address = {Ontario, Canada},
    year = {2021},
    url = {https://www.toronto.ca/services-payments/permits-licences-bylaws/},
  }
@Manual{todp2021,
    title = {Toronto Open Data Portal},
    author = {{City of Toronto}},
    address = {Toronto, Canada},
    year = {2021},
    url = {https://open.toronto.ca/dataset/municipal-licensing-and-standards-business-licences-and-permits/},
  }
@Manual{canpost,
    title = {Listing of Forward Sortation Area Codes (FSA)},
    author = {{Canada Post}},
    year = {2014},
    url = {https://www.canadapost.ca/cpo/mc/assets/pdf/business/nps/machineable_presort_fsalist_february2014.pdf},
  }
@book{gertler2016impact,
    title={Impact evaluation in practice},
    author={Gertler, Paul J and Martinez, Sebastian and Premand, Patrick and Rawlings, Laura B and Vermeersch, Christel MJ},
    year={2016},
    publisher={The World Bank}
  }
@article{shoemaker2005increase,
    title={How to increase menu prices without alienating your customers},
    author={Shoemaker, Stowe and Dawson, Mary and Johnson, Wade},
    journal={International Journal of Contemporary Hospitality Management},
    year={2005},
    publisher={Emerald Group Publishing Limited}
  }
@Manual{Sundar2019,
    title = {You May Not See Them, But Ghost Kitchens are Here to Stay},
    author = {Sundar, Shiv},
    year = {2020},
    publisher={Entrepreneur India},
    url = {https://www.entrepreneur.com/article/361267},
  }
@Manual{Mohammed2020,
    title = {How Restaurants Can Survive Right Now},
    author = {Mohammed, Rafi},
    year = {2020},
    publisher={Harvard Business Review},
    url = {https://hbr.org/2020/03/how-restaurants-can-survive-right-now},
  }
@Manual{Yelich2020,
    title = {Ontario Continues to Support Restaurants During COVID-19 Pandemic},
    author = {Yelich, Ivana},
    year = {2020},
    publisher={Government of Ontario},
    url = {https://news.ontario.ca/en/release/58790/ontario-continues-to-support-restaurants-during-covid-19-pandemic},
  }
@Manual{Shea2021,
    title = {“Most people would rather see their money go right to the restaurant”: A Q&A with the founder of Not Uber Eats, a no-commission guide to Toronto takeout and delivery},
    author = {Shea, Courtney},
    year = {2021},
    publisher={Toronto Life},
    url = {https://torontolife.com/food/most-people-would-rather-see-their-money-go-right-to-the-restaurant-a-qa-with-the-founder-of-not-uber-eats-a-no-commission-guide-to-toronto-takeout-and-delivery/},
  }
@Manual{Xing2020,
    title = {Small businesses struggle to stay afloat as Ontario reopens amid pandemic},
    author = {Xing, Lisa},
    year = {2020},
    publisher={CBC News},
    url = {https://www.cbc.ca/news/canada/toronto/covid-19-small-businesses-toronto-restaurants-shops-1.5658133},
  }
@Manual{kelly2019,
    title = {The rise of ghost kitchens in the age of COVID-19},
    author = {Kelly, John},
    year = {2020},
    publisher={Resto Biz},
    url = {https://www.restobiz.ca/ghost-kitchens-coming-out-on-top-during-covid-19/},
  }
@Manual{lacroix,
    title = {LaCroixColoR: LaCroix Water Color Palettes},
    author = {Johannes Bjork},
    year = {2021},
    note = {R package version 0.1.0},
  }
@Book{ggplot,
    author = {Hadley Wickham},
    title = {ggplot2: Elegant Graphics for Data Analysis},
    publisher = {Springer-Verlag New York},
    year = {2016},
    isbn = {978-3-319-24277-4},
    url = {https://ggplot2.tidyverse.org},
  }
@Manual{ggthemes,
    title = {ggthemes: Extra Themes, Scales and Geoms for 'ggplot2'},
    author = {Jeffrey B. Arnold},
    year = {2021},
    note = {R package version 4.2.4},
    url = {https://CRAN.R-project.org/package=ggthemes},
  }
@Manual{kable,
    title = {kableExtra: Construct Complex Table with 'kable' and Pipe Syntax},
    author = {Hao Zhu},
    year = {2020},
    note = {R package version 1.3.1},
    url = {https://CRAN.R-project.org/package=kableExtra},
  }
@Manual{knitr,
    title = {knitr: A General-Purpose Package for Dynamic Report
      Generation in R},
    author = {Yihui Xie},
    year = {2021},
    note = {R package version 1.31},
    url = {https://yihui.org/knitr/},
  }
@Manual{bookdown,
    title = {bookdown: Authoring Books and Technical Documents with R
      Markdown},
    author = {Yihui Xie},
    year = {2020},
    note = {R package version 0.21},
    url = {https://github.com/rstudio/bookdown},
  }
@Manual{tinytex,
    title = {tinytex: Helper Functions to Install and Maintain TeX
      Live, and Compile LaTeX Documents},
    author = {Yihui Xie},
    year = {2021},
    note = {R package version 0.29},
    url = {https://github.com/yihui/tinytex},
  }
  @Article{tidy,
    title = {Welcome to the {tidyverse}},
    author = {Hadley Wickham and Mara Averick and Jennifer Bryan and Winston Chang and Lucy D'Agostino McGowan and Romain François and Garrett Grolemund and Alex Hayes and Lionel Henry and Jim Hester and Max Kuhn and Thomas Lin Pedersen and Evan Miller and Stephan Milton Bache and Kirill Müller and Jeroen Ooms and David Robinson and Dana Paige Seidel and Vitalie Spinu and Kohske Takahashi and Davis Vaughan and Claus Wilke and Kara Woo and Hiroaki Yutani},
    year = {2019},
    journal = {Journal of Open Source Software},
    volume = {4},
    number = {43},
    pages = {1686},
    doi = {10.21105/joss.01686},
  }
@Manual{dplyr,
    title = {dplyr: A Grammar of Data Manipulation},
    author = {Hadley Wickham and Romain François and Lionel Henry and Kirill Müller},
    year = {2021},
    note = {R package version 1.0.3},
    url = {https://CRAN.R-project.org/package=dplyr},
  }
@Manual{janitor,
    title = {janitor: Simple Tools for Examining and Cleaning Dirty Data},
    author = {Sam Firke},
    year = {2021},
    note = {R package version 2.1.0},
    url = {https://CRAN.R-project.org/package=janitor},
  }
@Manual{purrr,
    title = {purrr: Functional Programming Tools},
    author = {Lionel Henry and Hadley Wickham},
    year = {2020},
    note = {R package version 0.3.4},
    url = {https://CRAN.R-project.org/package=purrr},
  }
@Manual{broom,
    title = {broom: Convert Statistical Objects into Tidy Tibbles},
    author = {David Robinson and Alex Hayes and Simon Couch},
    year = {2020},
    note = {R package version 0.7.3},
    url = {https://CRAN.R-project.org/package=broom},
  }
@Manual{opendatatoronto,
    title = {opendatatoronto: Access the City of Toronto Open Data Portal},
    author = {Sharla Gelfand},
    year = {2020},
    note = {R package version 0.1.4},
    url = {https://CRAN.R-project.org/package=opendatatoronto},
  }
@Manual{Doradea2020,
    title = {Ghost kitchens are gaining popularity in Toronto, but what are they?},
    author = {Doradea, Karen},
    year = {2020},
    url = {https://dailyhive.com/toronto/what-is-ghost-kitchens-toronto},
  }
@book{wu2020sampling,
  title={Sampling Theory and Practice},
  author={Wu, Changbao and Thompson, Mary E},
  year={2020},
  publisher={Springer}
}

repository: bonjwow/covid-shut-down

repo_name: bonjwow/covid-shut-down

branch_name: refs/heads/main

gha_license_id: MIT

gha_language: R


text:
DESCRIPTION = "C++ bindings for dbus"
LICENSE = "LGPL"
SECTION = "libs"
DEPENDS = "dbus dbus-c++-native expat"

SRC_URI = "svn://dev.openwengo.org/svn/openwengo/wengophone-ng/branches/wengophone-dbus-api/libs;module=dbus;proto=http"
#           file://fix-linking.patch;patch=1"
S = "${WORKDIR}/dbus"

inherit autotools pkgconfig

do_compile_prepend() {
	find . -name "Makefile.am" |xargs sed -i -e 's,$(top_builddir)/tools/dbusxx-xml2cpp,dbusxx-xml2cpp,'
}

FILES_${PN}-dbg += "${bindir}/dbusxx-xml2cpp ${bindir}/dbusxx-introspect"
FILES_${PN}-dev += "${bindir}/.dev"
FILES_${PN} = "${libdir}/*.so.*"


text:
---
---

@article{Journal of Medical Systems,
  abbr={JOMS},
  title={Machine Learning for Health Algorithm Auditing & Quality Control},
  author={Oala, Schörverth et al.},
  abstract={Developers proposing new machine learning for health (ML4H) tools often pledge to match or even surpass the performance of existing tools, yet the reality is usually more complicated. Reliable deployment of ML4H to the real world is challenging as examples from diabetic retinopathy or Covid-19 screening show. We envision an integrated framework of algorithm auditing and quality control that provides a path towards the effective and reliable application of ML systems in healthcare. In this editorial, we give a summary of ongoing work towards that vision and announce a call for participation to the special issue  Machine Learning for Health Algorithm Auditing & Quality Control in this journal to advance the practice of ML4H auditing.},
  journal={Journal of Medical Systems},
  volume={45},
  issue={12},
  year={2021},
  month={November},
  publisher=aps,
  doi={10.1103/PhysRev.47.777},
  url={http://link.aps.org/doi/10.1103/PhysRev.47.777},
  html={https://doi.org/10.1007/s10916-021-01783-y},
  selected={true}
}

@article{BMC2021,
  abbr={TALK},
  title={Prüfung von KI-Modellen in der Medizin},
  author={Elora Schörverth},
  journal={Bundesverband Managed Care e.V.},
  url={https://www.bmcev.de/event/webgespraech-mit-elora-schoerverth-pruefung-von-ki-modellen-in-der-medizin/},
  html={/assets/pdf/BMC.pdf},
  year={2021},
  selected={true}
}


text:
package teedy

import (
	"fmt"
	"io"
	"os"

	"github.com/go-resty/resty/v2"
)

type FileService struct {
	client   *resty.Client
	apiError *TeedyAPIError
}

func NewFileService(client *resty.Client, api string) *FileService {
	return &FileService{
		client:   client,
		apiError: NewTeedyAPIError(api),
	}
}

type File struct {
	Id         string     `json:"id"`
	Processing bool       `json:"processing"`
	Name       string     `json:"name"`
	Version    int        `json:"version"`
	MimeType   string     `json:"mimetype"`
	DocumentId string     `json:"document_id"`
	CreateDate *Timestamp `json:"create_date,omitempty"`
	Size       int        `json:"size"`
}

type FileList struct {
	Files []*File `json:"files,omitempty"`
}

type FileAddStatus struct {
	Status string `json:"status"`
	Id     string `json:"id"`
	Size   int    `json:"size"`
}

type ZippedFile struct {
	Filename string
	Content  []byte
}

func (f *FileService) GetAll() ([]*File, error) {
	resp, err := f.client.R().
		SetResult(&FileList{}).
		Get("api/file/list")

	err = checkRequestError(resp, err, f.apiError.GetAll)

	if err != nil {
		return nil, err
	}

	return resp.Result().(*FileList).Files, nil
}

func (f *FileService) Get(documentId string) ([]*File, error) {
	resp, err := f.client.R().
		SetResult(&FileList{}).
		SetQueryParams(map[string]string{
			"id": documentId,
		}).
		Get("api/file/list")

	err = checkRequestError(resp, err, f.apiError.Get)

	if err != nil {
		return nil, err
	}

	return resp.Result().(*FileList).Files, nil
}

func (f *FileService) GetData(id string) ([]byte, error) {
	resp, err := f.client.R().
		Get(fmt.Sprintf("api/file/%s/data", id))

	err = checkRequestError(resp, err, f.apiError.Custom("get file data"))

	if err != nil {
		return nil, err
	}

	return resp.Body(), nil
}

func (f *FileService) Add(documentId, previousFileId string, file *os.File) (*FileAddStatus, error) {
	params := make(map[string]string)

	if len(documentId) > 0 {
		params["id"] = documentId
	}

	if len(previousFileId) > 0 {
		params["previousFileId"] = previousFileId
	}

	fileInfo, err := file.Stat()

	if err != nil {
		return nil, fmt.Errorf("unable to get file information: %v", err)
	}

	resp, err := f.client.R().
		SetResult(&FileAddStatus{}).
		SetFormData(params).
		SetFileReader("file", fileInfo.Name(), file).
		Put("api/file")

	err = checkRequestError(resp, err, f.apiError.Add)

	if err != nil {
		return nil, err
	}

	return resp.Result().(*FileAddStatus), nil
}

func (f *FileService) AddReader(documentId, previousFileId, fileName, contentType string, reader io.Reader) (*FileAddStatus, error) {
	params := make(map[string]string)

	if len(documentId) > 0 {
		params["id"] = documentId
	}

	if len(previousFileId) > 0 {
		params["previousFileId"] = previousFileId
	}

	resp, err := f.client.R().
		SetResult(&FileAddStatus{}).
		SetFormData(params).
		SetMultipartField("file", fileName, contentType, reader).
		Put("api/file")

	err = checkRequestError(resp, err, f.apiError.Add)

	if err != nil {
		return nil, err
	}

	return resp.Result().(*FileAddStatus), nil
}

func (f *FileService) GetZippedFiles(id string) ([]byte, error) {
	resp, err := f.client.R().
		Get(fmt.Sprintf("api/file/zip?id=%s", id))

	err = checkRequestError(resp, err, f.apiError.Custom("getting zipped files"))

	if err != nil {
		return nil, err
	}

	return resp.Body(), nil
}

repository: shrideh/go-teedy

repo_name: shrideh/go-teedy


text:
SRC_URI = "http://www.kaffe.org/ftp/pub/kaffe/v1.1.x-development/kaffe-${PV}.tar.gz"
S = "${WORKDIR}/kaffe-${PV}"

include kaffe.inc

inherit native

EXTRA_OECONF += " --without-classpath-gtk-awt \
	--disable-native-awt \
	--disable-sound \
	--without-x \
	--without-kaffe-x-awt \
	--disable-debug \
	--disable-gcj"

do_stage() {
	install -m 0755 kaffe/kaffeh/kaffeh ${STAGING_BINDIR}/
}

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn


text:
function(check_expected_tool_version tool_name tool_path)
    # Function to check the tool used the expected version and warn otherwise
    set(tool_version_warning "Check Getting Started documentation or proceed at own risk.\n")
    set(tool_version_error "Check Getting Started documentation if the error continues.\n"
        "You can override this error and proceed with build by defining the IDF_MAINTAINER environment variable.\n")
    set(fixing_hint "Please try to run 'idf.py fullclean' to solve it.\n")

    idf_build_get_property(python PYTHON)
    idf_build_get_property(idf_path IDF_PATH)

    set(ENV{IDF_TOOLS_VERSION_HELPER} "1")
    # Use idf_tools.py to check if tool version is supported
    execute_process(
        COMMAND ${python} "${idf_path}/tools/idf_tools.py"
        "check-tool-supported" "--tool-name" "${tool_name}"
        "--exec-path" "${tool_path}"
        OUTPUT_VARIABLE is_version_supported
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_QUIET)

    if(is_version_supported STREQUAL "False")
        # Version is not supported. Need to get supported versions list to print them to user
        execute_process(
            COMMAND ${python} "${idf_path}/tools/idf_tools.py"
            "get-tool-supported-versions" "--tool-name" "${tool_name}"
            OUTPUT_VARIABLE tool_supported_versions
            OUTPUT_STRIP_TRAILING_WHITESPACE
            ERROR_QUIET)
        # IDF maintainers can build projects with not supported versions with just a warning
        if($ENV{IDF_MAINTAINER})
            set(message_mode "WARNING")
        else()
            set(message_mode "FATAL_ERROR")
        endif()

        message(${message_mode} "\n"
                 "Tool doesn't match supported version from list "
                "${tool_supported_versions}: ${tool_path}\n"
                 ${fixing_hint})
    elseif(NOT is_version_supported STREQUAL "True")
        message(WARNING "Can not get version for tool: ${tool_path}\n" ${tool_version_warning})
    endif()
    unset(ENV{IDF_TOOLS_VERSION_HELPER})
endfunction()

repository: KollarRichard/esp-idf

repo_name: KollarRichard/esp-idf

extension: cmake


text:
@InProceedings{bahadori15,
  supplementary = {Supplementary:bahadori15-supp.pdf},
  title = {Functional Subspace Clustering with Application to Time Series},
  author = {Mohammad Taha Bahadori and David Kale and Yingying Fan and Yan Liu},
  pages = {228-237},
  abstract = {Functional data, where samples are random functions, are increasingly common and important in a variety of applications, such as health care and traffic analysis. They are naturally high dimensional and lie along complex manifolds. These properties warrant use of the subspace assumption, but most state-of-the-art subspace learning algorithms are limited to linear or other simple settings. To address these challenges, we propose a new framework called Functional Subspace Clustering (FSC). FSC assumes that functional samples lie in deformed linear subspaces and formulates the subspace learning problem as a sparse regression over operators. The resulting problem can be efficiently solved via greedy variable selection, given access to a fast deformation oracle. We provide theoretical guarantees for FSC and show how it can be applied to time series with warped alignments. Experimental results on both synthetic data and real clinical time series show that FSC outperforms both standard time series clustering and state-of-the-art subspace clustering.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
require at91bootstrap.inc

COMPATIBLE_MACHINE = '(sama5d3xek|sama5d3-xplained|at91sam9x5ek|at91sam9rlek|at91sam9m10g45ek|sama5d4ek|sama5d4-xplained)'

SRC_URI = "https://github.com/linux4sam/at91bootstrap/archive/v${PV}.tar.gz;name=tarball \
          "
SRC_URI[tarball.md5sum] = "bde892326211cfe739e41edea2f3c5d9"
SRC_URI[tarball.sha256sum] = "c6ee66fc4dc500140633868845d0fb59bd32e010ec886bd7da1af7af06664cfa"

repository: koenkooi/meta-atmel

repo_name: koenkooi/meta-atmel


text:
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package sensors provides sensor events from various movement sensors.
package sensors

import (
	"errors"
	"sync"
	"time"
)

// Type represents a sensor type.
type Type int

var (
	Accelerometer = Type(1)
	Gyroscope     = Type(2)
	Magnetometer  = Type(3)
	Altimeter     = Type(4)
)

// Event represents a sensor event.
type Event struct {
	// Sensor is the type of the sensor the event is coming from.
	Sensor Type

	// Timestamp is the time the event happened.
	// Timestamps are not Unix times, they represent a time that is
	// only valid for the device's default accelerometer sensor.
	Timestamp int64

	// Data is the event data.
	//
	// If the event source is Accelerometer,
	//  - Data[0]: acceleration force in x axis in m/s^2
	//  - Data[1]: acceleration force in y axis in m/s^2
	//  - Data[2]: acceleration force in z axis in m/s^2
	//
	// If the event source is Gyroscope,
	//  - Data[0]: rate of rotation around the x axis in rad/s
	//  - Data[1]: rate of rotation around the y axis in rad/s
	//  - Data[2]: rate of rotation around the z axis in rad/s
	//
	// If the event source is Magnetometer,
	//  - Data[0]: force of gravity along the x axis in m/s^2
	//  - Data[1]: force of gravity along the y axis in m/s^2
	//  - Data[2]: force of gravity along the z axis in m/s^2
	//
	Data []float64
}

// Manager multiplexes sensor event data from various sensor sources.
type Manager struct {
	once sync.Once
	m    *manager // platform-specific implementation of the underlying manager
}

func (m *Manager) init() {
	m.m = &manager{}
}

// Enable enables a sensor with the specified delay rate.
// If there are multiple sensors of type t on the device, Enable uses
// the default one.
// If there is no default sensor of type t on the device, an error returned.
// Valid sensor types supported by this package are Accelerometer,
// Gyroscope, Magnetometer and Altimeter.
func (m *Manager) Enable(t Type, delay time.Duration) error {
	m.once.Do(m.init)
	if t < 1 || t > 4 {
		return errors.New("sensors: unknown sensor type")
	}
	return enable(m.m, t, delay)
}

// Disable disables to feed the manager with the specified sensor.
func (m *Manager) Disable(t Type) error {
	m.once.Do(m.init)
	if t < 1 || t > 4 {
		return errors.New("sensors: unknown sensor type")
	}
	return disable(m.m, t)
}

// Read reads a series of events from the manager.
// It may read up to len(e) number of events, but will return
// less events if timeout occurs.
func (m *Manager) Read(e []Event) (n int, err error) {
	m.once.Do(m.init)
	return read(m.m, e)
}

// Close stops the manager and frees the related resources.
func (m *Manager) Close() error {
	m.once.Do(m.init)
	return close(m.m)
}

repository: mehulsbhatt/sensors

repo_name: mehulsbhatt/sensors


text:
@article{Bunnik2014,
 abstract = {In eukaryotic organisms, packaging of DNA into nucleosomes controls gene expression by regulating access of the promoter to transcription factors. The human malaria parasite Plasmodium falciparum encodes relatively few transcription factors, while extensive nucleosome remodeling occurs during its replicative cycle in red blood cells. These observations point towards an important role of the nucleosome landscape in regulating gene expression. However, the relation between nucleosome positioning and transcriptional activity has thus far not been explored in detail in the parasite. Here, we analyzed nucleosome positioning in the asexual and sexual stages of the parasite's erythrocytic cycle using chromatin immunoprecipitation of MNase-digested chromatin, followed by next-generation sequencing. We observed a relatively open chromatin structure at the trophozoite and gametocyte stages, consistent with high levels of transcriptional activity in these stages. Nucleosome occupancy of genes and promoter regions were subsequently compared to steady-state mRNA expression levels. Transcript abundance showed a strong inverse correlation with nucleosome occupancy levels in promoter regions. In addition, AT-repeat sequences were strongly unfavorable for nucleosome binding in P. falciparum, and were overrepresented in promoters of highly expressed genes. The connection between chromatin structure and gene expression in P. falciparum shares similarities with other eukaryotes. However, the remarkable nucleosome dynamics during the erythrocytic stages and the absence of a large variety of transcription factors may indicate that nucleosome binding and remodeling are critical regulators of transcript levels. Moreover, the strong dependency between chromatin structure and DNA sequence suggests that the P. falciparum genome may have been shaped by nucleosome binding preferences. Nucleosome remodeling mechanisms in this deadly parasite could thus provide potent novel anti-malarial targets.},
 author = {Bunnik, Evelien M and Polishko, Anton and Prudhomme, Jacques and Ponts, Nadia and Gill, Sarjeet S and Lonardi, Stefano and Le Roch, Karine G},
 doi = {10.1186/1471-2164-15-347},
 file = {:Users/ant/Library/Application Support/Mendeley Desktop/Downloaded/Bunnik et al. - 2014 - DNA-encoded nucleosome occupancy is associated with transcription levels in the human malaria parasite Plasmodium.pdf:pdf},
 issn = {1471-2164},
 journal = {BMC Genomics},
 keywords = {Animal Genetics and Genomics,Life Sciences,Microarrays,Microbial Genetics and Genomics,Plant Genetics & Genomics,Proteomics,general},
 month = {may},
 number = {1},
 pages = {347},
 publisher = {BioMed Central},
 title = {DNA-encoded nucleosome occupancy is associated with transcription levels in the human malaria parasite Plasmodium falciparum},
 url = {http://bmcgenomics.biomedcentral.com/articles/10.1186/1471-2164-15-347},
 volume = {15},
 year = {2014}
}


text:
// Copyright 2018 JDCLOUD.COM
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// NOTE: This class is auto generated by the jdcloud code generator program.

package apis

import (
    "github.com/jdcloud-api/jdcloud-sdk-go/core"
    fc "github.com/jdcloud-api/jdcloud-sdk-go/services/fc/models"
)

type UpdateFunctionRequest struct {

    core.JDCloudRequest

    /* Region ID  */
    RegionId string `json:"regionId"`

    /* Service Name  */
    ServiceName string `json:"serviceName"`

    /* Function Name  */
    FunctionName string `json:"functionName"`

    /* 修改后的代码 (Optional) */
    Code *fc.Code `json:"code"`

    /* 修改后的超时时间 (Optional) */
    Timeout *int `json:"timeout"`

    /* 修改后的运行时语言 (Optional) */
    Runtime *string `json:"runtime"`

    /* 修改后的函数执行入口 (Optional) */
    Handler *string `json:"handler"`

    /* 修改后的描述 (Optional) */
    Description *string `json:"description"`

    /* 修改后的环境变量 (Optional) */
    Envs []fc.Environment `json:"envs"`

    /* 修改后的cpu (Optional) */
    Cpu *int `json:"cpu"`

    /* 修改后的内存 (Optional) */
    MemorySize *int `json:"memorySize"`

    /* 修改后的磁盘 (Optional) */
    DiskSize *int `json:"diskSize"`
}

/*
 * param regionId: Region ID (Required)
 * param serviceName: Service Name (Required)
 * param functionName: Function Name (Required)
 *
 * @Deprecated, not compatible when mandatory parameters changed
 */
func NewUpdateFunctionRequest(
    regionId string,
    serviceName string,
    functionName string,
) *UpdateFunctionRequest {

	return &UpdateFunctionRequest{
        JDCloudRequest: core.JDCloudRequest{
			URL:     "/regions/{regionId}/services/{serviceName}/functions/{functionName}",
			Method:  "PATCH",
			Header:  nil,
			Version: "v1",
		},
        RegionId: regionId,
        ServiceName: serviceName,
        FunctionName: functionName,
	}
}

/*
 * param regionId: Region ID (Required)
 * param serviceName: Service Name (Required)
 * param functionName: Function Name (Required)
 * param code: 修改后的代码 (Optional)
 * param timeout: 修改后的超时时间 (Optional)
 * param runtime: 修改后的运行时语言 (Optional)
 * param handler: 修改后的函数执行入口 (Optional)
 * param description: 修改后的描述 (Optional)
 * param envs: 修改后的环境变量 (Optional)
 * param cpu: 修改后的cpu (Optional)
 * param memorySize: 修改后的内存 (Optional)
 * param diskSize: 修改后的磁盘 (Optional)
 */
func NewUpdateFunctionRequestWithAllParams(
    regionId string,
    serviceName string,
    functionName string,
    code *fc.Code,
    timeout *int,
    runtime *string,
    handler *string,
    description *string,
    envs []fc.Environment,
    cpu *int,
    memorySize *int,
    diskSize *int,
) *UpdateFunctionRequest {

    return &UpdateFunctionRequest{
        JDCloudRequest: core.JDCloudRequest{
            URL:     "/regions/{regionId}/services/{serviceName}/functions/{functionName}",
            Method:  "PATCH",
            Header:  nil,
            Version: "v1",
        },
        RegionId: regionId,
        ServiceName: serviceName,
        FunctionName: functionName,
        Code: code,
        Timeout: timeout,
        Runtime: runtime,
        Handler: handler,
        Description: description,
        Envs: envs,
        Cpu: cpu,
        MemorySize: memorySize,
        DiskSize: diskSize,
    }
}

/* This constructor has better compatible ability when API parameters changed */
func NewUpdateFunctionRequestWithoutParam() *UpdateFunctionRequest {

    return &UpdateFunctionRequest{
            JDCloudRequest: core.JDCloudRequest{
            URL:     "/regions/{regionId}/services/{serviceName}/functions/{functionName}",
            Method:  "PATCH",
            Header:  nil,
            Version: "v1",
        },
    }
}

/* param regionId: Region ID(Required) */
func (r *UpdateFunctionRequest) SetRegionId(regionId string) {
    r.RegionId = regionId
}
/* param serviceName: Service Name(Required) */
func (r *UpdateFunctionRequest) SetServiceName(serviceName string) {
    r.ServiceName = serviceName
}
/* param functionName: Function Name(Required) */
func (r *UpdateFunctionRequest) SetFunctionName(functionName string) {
    r.FunctionName = functionName
}
/* param code: 修改后的代码(Optional) */
func (r *UpdateFunctionRequest) SetCode(code *fc.Code) {
    r.Code = code
}
/* param timeout: 修改后的超时时间(Optional) */
func (r *UpdateFunctionRequest) SetTimeout(timeout int) {
    r.Timeout = &timeout
}
/* param runtime: 修改后的运行时语言(Optional) */
func (r *UpdateFunctionRequest) SetRuntime(runtime string) {
    r.Runtime = &runtime
}
/* param handler: 修改后的函数执行入口(Optional) */
func (r *UpdateFunctionRequest) SetHandler(handler string) {
    r.Handler = &handler
}
/* param description: 修改后的描述(Optional) */
func (r *UpdateFunctionRequest) SetDescription(description string) {
    r.Description = &description
}
/* param envs: 修改后的环境变量(Optional) */
func (r *UpdateFunctionRequest) SetEnvs(envs []fc.Environment) {
    r.Envs = envs
}
/* param cpu: 修改后的cpu(Optional) */
func (r *UpdateFunctionRequest) SetCpu(cpu int) {
    r.Cpu = &cpu
}
/* param memorySize: 修改后的内存(Optional) */
func (r *UpdateFunctionRequest) SetMemorySize(memorySize int) {
    r.MemorySize = &memorySize
}
/* param diskSize: 修改后的磁盘(Optional) */
func (r *UpdateFunctionRequest) SetDiskSize(diskSize int) {
    r.DiskSize = &diskSize
}

// GetRegionId returns path parameter 'regionId' if exist,
// otherwise return empty string
func (r UpdateFunctionRequest) GetRegionId() string {
    return r.RegionId
}

type UpdateFunctionResponse struct {
    RequestID string `json:"requestId"`
    Error core.ErrorResponse `json:"error"`
    Result UpdateFunctionResult `json:"result"`
}

type UpdateFunctionResult struct {
}

repository: jdcloud-api/jdcloud-sdk-go

repo_name: jdcloud-api/jdcloud-sdk-go


text:
DESCRIPTION = "BSD replacement for libreadline"
HOMEPAGE = "http://www.thrysoee.dk/editline/"
SECTION = "libs"
LICENSE = "BSD"
DEPENDS = "ncurses"
PR = "r1"

inherit autotools

SRC_URI = "http://www.thrysoee.dk/editline/${PN}-${PV}-3.0.tar.gz"

S = ${WORKDIR}/${PN}-${PV}-3.0

SRC_URI[md5sum] = "eb4482139525beff12c8ef59f1a84aae"
SRC_URI[sha256sum] = "602b385906b6057f52922afc42cafbceadd8bae4be43c9189ea7fa870a561d86"

repository: balister/openembedded

repo_name: balister/openembedded


text:
DESCRIPTION = "GLES libraries for Rockchip SoCs for a family of Mali GPU"
SECTION = "libs"
LICENSE = "BINARY"
LIC_FILES_CHKSUM = "file://LICENSE.TXT;md5=564e729dd65db6f65f911ce0cd340cf9"
NO_GENERIC_LICENSE[BINARY] = "LICENSE.TXT"

COMPATIBLE_MACHINE = "(rk3036|rk3288|rk3399)"

# There's only hardfp version available
python __anonymous() {
    tunes = d.getVar("TUNE_FEATURES", True)
    if not tunes:
        return
    if "callconvention-hard" not in tunes:
        pkgn = d.getVar("PN", True)
        pkgv = d.getVar("PV", True)
        raise bb.parse.SkipPackage("%s-%s ONLY supports hardfp mode for now" % (pkgn, pkgv))
}

DEPENDS = "libdrm mesa"

PROVIDES += "virtual/egl virtual/libgles1 virtual/libgles2 virtual/libopencl libgbm"
PROVIDES += "${@bb.utils.contains("DISTRO_FEATURES", "wayland", " virtual/libwayland-egl", " ", d)}"

S = "${WORKDIR}/git"

SRC_URI = "git://github.com/rockchip-linux/libmali.git;branch=rockchip;"
SRCREV_pn-${PN} = "9e8cd208200107e344ac0e9212d93be18f2e881d"

INSANE_SKIP_${PN} = "already-stripped ldflags dev-so"

INHIBIT_PACKAGE_DEBUG_SPLIT = "1"
INHIBIT_PACKAGE_STRIP = "1"

USE_X11 = "${@bb.utils.contains("DISTRO_FEATURES", "x11", "yes", "no", d)}"
USE_WL = "${@bb.utils.contains("DISTRO_FEATURES", "wayland", "yes", "no", d)}"

MALI_X11_rk3036 = "arm-linux-gnueabihf/libmali-utgard-r6p0.so"
MALI_WAYLAND_rk3036 = "arm-linux-gnueabihf/libmali-utgard-r7p0-wayland.so"
MALI_GBM_rk3036 = "arm-linux-gnueabihf/libmali-utgard-r7p0-gbm.so"

MALI_X11_rk3288 = "arm-linux-gnueabihf/libmali-midgard-r9p0-r0p0.so"
MALI_WAYLAND_rk3288 = "arm-linux-gnueabihf/libmali-midgard-r13p0-r0p0-wayland.so "
MALI_GBM_rk3288 = "arm-linux-gnueabihf/libmali-midgard-r13p0-r0p0-gbm.so "

MALI_X11_rk3328 = "aarch64-linux-gnu/libmali-utgard-2th-r7p0.so"
MALI_WAYLAND_rk3328 = "aarch64-linux-gnu/libmali-utgard-2th-r7p0-wayland.so"
MALI_GBM_rk3328 = "aarch64-linux-gnu/libmali-utgard-2th-r7p0-gbm.so"

MALI_X11_rk3399 = "aarch64-linux-gnu/libmali-midgard-4th-r9p0.so"
MALI_WAYLAND_rk3399 = "aarch64-linux-gnu/libmali-midgard-4th-r9p0-wayland.so"
MALI_GBM_rk3399 = "aarch64-linux-gnu/libmali-midgard-4th-r9p0-gbm.so"

do_configure[noexec] = "1"
do_compile[noexec] = "1"

do_install () {
	# Create MALI manifest
	install -m 755 -d ${D}/${libdir}
	if [ "${USE_X11}" = "yes" ]; then
		install ${S}/lib/${MALI_X11} ${D}/${libdir}/libMali.so
	elif [ "${USE_WL}" = "yes" ]; then
		install ${S}/lib/${MALI_WAYLAND} ${D}/${libdir}/libMali.so
	else
		install ${S}/lib/${MALI_GBM} ${D}/${libdir}/libMali.so
	fi

	ln -sf libMali.so ${D}/${libdir}/libEGL.so
	ln -sf libMali.so ${D}/${libdir}/libEGL.so.1
	ln -sf libMali.so ${D}/${libdir}/libGLESv1_CM.so
	ln -sf libMali.so ${D}/${libdir}/libGLESv1_CM.so.1
	ln -sf libMali.so ${D}/${libdir}/libGLESv2.so
	ln -sf libMali.so ${D}/${libdir}/libGLESv2.so.2
	ln -sf libMali.so ${D}/${libdir}/libOpenCL.so
	ln -sf libMali.so ${D}/${libdir}/libOpenCL.so.1
	ln -sf libMali.so ${D}/${libdir}/libgbm.so
	ln -sf libMali.so ${D}/${libdir}/libgbm.so.1

	if [ "${USE_WL}" = "yes" ]; then
		ln -sf libMali.so ${D}/${libdir}/libwayland-egl.so
	fi
}

PACKAGES = "${PN}"
FILES_${PN} += "${libdir}/*.so"

RREPLACES_${PN} = "libegl libgles1 libglesv1-cm1 libgles2 libglesv2-2 libgbm"
RCONFLICTS_${PN} = "libegl libgles1 libglesv1-cm1 libgles2 libglesv2-2 libgbm"
RPROVIDES_${PN} += "libegl libgles1 libglesv1-cm1 libgles2 libglesv2-2 libgbm"

# Workaround: libMali.so provided by rk having no SONAME field in it
# so add it to fix rdepends problems
RPROVIDES_${PN} += "libwayland-egl.so libgbm.so libGLESv1_CM.so libGLESv2.so libEGL.so libOpenCL.so"

repository: rk-hgc/meta-rockchip

repo_name: rk-hgc/meta-rockchip

branch_name: refs/heads/morty


text:
// Copyright (c) 2021 The BFE Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package lib

import (
	"net/http"
	"strings"
)

func AccepLanguages(req *http.Request) []string {
	ls := []string{}

	for _, one := range strings.Split(req.Header.Get("Accept-Language"), ",") {
		ls = append(ls, strings.SplitN(one, ";", 2)[0])
	}

	return ls
}

repository: showsmall/api-server

repo_name: showsmall/api-server


text:
This BibTeX file is made available under the Public Domain Dedication and License v1.0 whose full text can be found in the accompanying README file or online at http://www.opendatacommons.org/licenses/pddl/1.0/

@Article{1996-Klosgen-RKK,
	Author = "Beate Klosgen and Christoph Reichle and Stephan Kohlsmann and Klaus D. Kramer",
	Title = "{Dielectric spectroscopy as a sensor of membrane headgroup mobility and hydration}",
	Journal = "Biophys. J.",
	Volume = "71",
	Pages = "3251–3260",
	cited = "45 (2013-04-29)",
	doi = "10.1016/S0006-3495(96)79518-8",
	localfile = {1996 - Dielectric spectroscopy as a sensor of membrane headgroup mobility and hydration.pdf},
	year = 1996
}

@Article{2002-Noguchi-Takasu,
	Author = "Hiroshi Noguchi and Masako Takasu",
	Title = "{Adhesion of nanoparticles to vesicles: a Brownian dynamics simulation}",
	Journal = "Biophys. J.",
	Volume = "83",
	Pages = "299–308",
	abstract = "We studied the interaction of bilayer vesicles and adhesive nanoparticles using a brownian dynamics simulation. The nanoparticles are simple models of proteins aor colloids. The adhering nanoparticle induces the morphological change of the vesicle: budding, formation of two vesicles in which only the outer monolayers are connected, and fission. We also show that the nanoparticle promotes the fusion process: fusion-pore opening from a stalk intermediate, a neck-like structure that only connects outer monolayers of two vesicles. The nanoparticle blends the stalk, and induces the pore opening.",
	doi = "10.1016/S0006-3495(02)75170-9",
	keywords = "biological nanocomposites; lipid bilayers; nanospheres",
	localfile = {2002 - Adhesion of nanoparticles to vesicles: a Brownian dynamics simulation.pdf},
	methods = "CG BD",
	year = 2002
}

@Article{2007-Reynwar-IHMKD,
	Author = "Benedict J. Reynwar and Gregoria Illya and Vagelis A. Harmandaris and Martin M. Müller and Kurt Kremer and Markus Deserno",
	Title = "{Aggregation and vesiculation of membrane proteins by cruvature-mediated interactions}",
	Journal = "Nature",
	Volume = "447",
	Pages = "461–464",
	abstract = "Membrane remodelling plays an important role in cellular tasks such as endocytosis, vesiculation and protein sorting, and in the biogenesis of organelles such as the endoplasmic reticulum or the Golgi apparatus. It is well established that the remodelling process is aided by specialized proteins that can sense as well as create membrane curvature, and trigger tubulation when added to synthetic liposomes. (...)",
	doi = "10.1038/nature05840",
	keywords = "biological nanocomposites; cell membranes; lipid bilayers; nanospheres",
	localfile = {2007 - Aggregation and vesiculation of membrane proteins by curvature-mediated interactions.pdf},
	methods = "CG MD",
	type = "Letter",
	year = 2007
}

@Article{2009-Monticelli-SKV,
	Author = "Luca Monticelli and Emppu Salonen and Pu Chun Ke and Ilpo Vattulainen",
	Title = "{Effects of carbon nanoparticles on lipid membranes: a molecular simulation perspective}",
	Journal = "Soft Matter",
	Volume = "5",
	Pages = "4433–4445",
	abstract = "We review recent simulation studies of carbon nanoparticles interacting with lipid membranes. We first consider the state-of-the-art methodology associated with atomistic as well as coarse-grained models of carbon nanoparticles and lipid systems, and then discuss recent simulation studies of fullerenes, carbon nanotubes and other carbon-based nanoparticles interacting with biological lipid interfaces. We close this article with a brief consideration of the future challenges guided by experiments.",
	keywords = "biological nanocomposites; fullerenes; lipid bilayers",
	localfile = {2009 - Effects of carbon nanoparticles on lipid membranes: a molecular simulations perspective.pdf},
	type = "Review",
	year = 2009
}

@Article{2009-Park-Lu,
	Author = "Jonghyun Park and Wei Lu",
	Title = "{Interaction of nanoparticles with lipid bilayers}",
	Journal = "Phys. Rev. E",
	Volume = "80",
	Pages = "021607",
	doi = "10.1103/PhysRevE.80.021607",
	keywords = "biological nanocomposites; lipid bilayers; nanospheres",
	localfile = {2009 - Interaction of nanoparticles with lipid layers.pdf},
	year = 2009
}

@Article{2011-Nicola-ZKRM,
	Author = "Antonio De Nicola and Ying Zhao and Toshihiro Kawakatsu and Danilo Roccatano and Giuseppe Milano",
	Title = "{Hybrid particle–field coarse-grained models for biological phospholipids}",
	Journal = "J. Chem. Theory Comp.",
	Volume = "7",
	Pages = "2947–2962",
	abstract = "In the framework of a recently developed scheme for a hybrid particle-field simulation technique where self-consistent field theiry (SCF) and molecular dynamics (MD) are combined, specific coarse-grained models for phospholipids and water have been developed. We optimized the model parameters, which are necessary in evaluating the interactions between the particles and the dnesity fields, so that the coarse-grained model can reproduce the structural properties of the reference particle–particle simulations. The development of these specific coarse-grained models suitable for hybrid particle-field simulations opens the way toward simulations of large-scale systems employing models with chemical specificity, especially for biological systems.",
	doi = "10.1021/ct200132n",
	keywords = "coarse graining; lipid bilayers",
	localfile = {2011 - Hybrid particle-field coarse-grained models for biological phospholipids.pdf},
	rating = "2",
	year = 2011
}

@Article{2011-Reynwar-Deserno,
	Author = "Benedict J. Reynwar and Markus Deserno",
	Title = "{Membrane-mediated interactions between circular particles in teh strongly curved regime}",
	Journal = "Soft Matter",
	Volume = "7",
	Pages = "8567–8575",
	doi = "10.1039/c1sm05358b",
	keywords = "biological nanocomposites; lipid bilayers; nanospheres",
	localfile = {2011 - Membrane-mediated interactions between circular praticles in the strongly curved regime.pdf},
	methods = "CG MD",
	year = 2011
}

@Article{2014-Sevink-Fraaije,
	Author = "G. J. A. Sevink and J. G. E. M. Fraaije",
	Title = "{Efficient solvent-free dissipative particle dynamics for lipid bilayers}",
	Journal = "Soft Matter",
	Volume = "10",
	Pages = "5129–5146",
	doi = "10.1039/c4sm00297k",
	keywords = "implicit solvent; vesicles; liposomes",
	localfile = {2014 - Efficient solvent-free dissipative particle dynamics for lipid bilayers.pdf},
	methods = "DPD",
	rating = "2",
	read = "2014-10-10",
	year = 2014
}

repository: langner/library

path: /lipid bilayers/lipid bilayers.bib

repo_name: langner/library

filename: lipid bilayers.bib


text:
// Copyright 2021 Google LLC. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package ftmap

import (
	"fmt"
	"testing"

	"github.com/apache/beam/sdks/v2/go/pkg/beam"
	"github.com/apache/beam/sdks/v2/go/pkg/beam/testing/passert"
	"github.com/apache/beam/sdks/v2/go/pkg/beam/testing/ptest"
	"github.com/google/trillian-examples/binary_transparency/firmware/api"
)

func TestAggregate(t *testing.T) {
	fwEntries := []*firmwareLogEntry{
		{Index: 0, Firmware: createFW("dummy", 400)},
		{Index: 1, Firmware: createFW("dummy", 401)},
	}
	logHead := int64(len(fwEntries) - 1)
	createAnnotationMalware := func(fwIndex int, good bool) *annotationMalwareLogEntry {
		logHead++
		return &annotationMalwareLogEntry{
			Index: logHead,
			Annotation: api.MalwareStatement{
				FirmwareID: api.FirmwareID{
					LogIndex:            uint64(fwIndex),
					FirmwareImageSHA512: fwEntries[fwIndex].Firmware.FirmwareImageSHA512,
				},
				Good: good,
			},
		}
	}
	tests := []struct {
		name               string
		treeID             int64
		annotationMalwares []*annotationMalwareLogEntry

		wantGood []string
	}{
		{
			name:   "No annotations",
			treeID: 12345,

			wantGood: []string{"0: true", "1: true"},
		},
		{
			name:   "One bad annotation",
			treeID: 12345,

			annotationMalwares: []*annotationMalwareLogEntry{
				createAnnotationMalware(1, false),
			},

			wantGood: []string{"0: true", "1: false"},
		},
		{
			name:   "Many annotations all good",
			treeID: 12345,

			annotationMalwares: []*annotationMalwareLogEntry{
				createAnnotationMalware(0, true),
				createAnnotationMalware(0, true),
			},

			wantGood: []string{"0: true", "1: true"},
		},
		{
			name:   "Many annotations one bad",
			treeID: 12345,

			annotationMalwares: []*annotationMalwareLogEntry{
				createAnnotationMalware(0, true),
				createAnnotationMalware(0, false),
				createAnnotationMalware(0, true),
			},

			wantGood: []string{"0: false", "1: true"},
		},
	}

	for _, test := range tests {
		test := test
		t.Run(test.name, func(t *testing.T) {
			p, s := beam.NewPipelineWithRoot()

			fws := beam.CreateList(s, fwEntries)
			annotationMalwares := beam.CreateList(s, test.annotationMalwares)

			entries, aggs := Aggregate(s, test.treeID, fws, annotationMalwares)

			passert.Count(s, entries, "entries", len(fwEntries))
			passert.Count(s, aggs, "aggs", len(fwEntries))

			aggregationToString := func(a *api.AggregatedFirmware) string { return fmt.Sprintf("%d: %t", a.Index, a.Good) }
			passert.Equals(s, beam.ParDo(s, aggregationToString, aggs), beam.CreateList(s, test.wantGood))

			err := ptest.Run(p)
			if err != nil {
				t.Errorf("unexpected error: %v", err)
			}
		})
	}
}

repository: google/trillian-examples

repo_name: google/trillian-examples


text:
package udwClose

import "context"

func (c *Closer) GetCloseContext() context.Context {
	ctx2, cancelFunc := context.WithCancel(context.Background())
	c.AddOnClose(cancelFunc)
	return ctx2
}

repository: daniel-henderson-ty/udw

repo_name: daniel-henderson-ty/udw


text:
@InProceedings{pmlr-v97-stickland19a,
  title = 	 {{BERT} and {PAL}s: Projected Attention Layers for Efficient Adaptation in Multi-Task Learning},
  author = 	 {Stickland, Asa Cooper and Murray, Iain},
  booktitle = 	 {Proceedings of the 36th International Conference on Machine Learning},
  pages = 	 {5986--5995},
  year = 	 {2019},
  editor = 	 {Chaudhuri, Kamalika and Salakhutdinov, Ruslan},
  volume = 	 {97},
  series = 	 {Proceedings of Machine Learning Research},
  address = 	 {Long Beach, California, USA},
  month = 	 {09--15 Jun},
  publisher = 	 {PMLR},
  pdf = 	 {http://proceedings.mlr.press/v97/stickland19a/stickland19a.pdf},
  url = 	 {http://proceedings.mlr.press/v97/stickland19a.html},
}

url: https://raw.githubusercontent.com/Hugh-Shi/DL-NLP-Readings/924e4d189e5660c5b5d4854278f3df755ae2231d/Bibtex/BERT and PALs - Projected Attention Layers for Efficient Adaptation in Multi-Task Learning.bib

repository: Hugh-Shi/DL-NLP-Readings

repo_name: Hugh-Shi/DL-NLP-Readings


text:
// MIT License
//
// Copyright (c) 2021 TFG Co
//
// 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 game_room

import "fmt"

// InstanceStatusType represents the status that a game room instance has.
type InstanceStatusType int

const (
	// InstanceUnknown has an undefined status.
	InstanceUnknown InstanceStatusType = iota
	// InstancePending is not ready yet. It will be on this state while creating.
	InstancePending
	// InstanceReady is running fine and all probes are being successful.
	InstanceReady
	// InstanceTerminating has received a termination signal and it is on process of
	// shutdown.
	InstanceTerminating
	// InstanceError has some sort of error.
	InstanceError
)

func (statusType InstanceStatusType) String() string {
	switch statusType {
	case InstanceUnknown:
		return "unknown"
	case InstancePending:
		return "pending"
	case InstanceReady:
		return "ready"
	case InstanceTerminating:
		return "terminating"
	case InstanceError:
		return "error"
	default:
		panic(fmt.Sprintf("invalid value for InstanceStatusType : %d", int(statusType)))
	}
}

type InstanceStatus struct {
	Type InstanceStatusType `json:"type"`
	// Description has more information about the status. For example, if we have a
	// status Error, it will tell us which error it is.
	Description string `json:"description"`
}

type Port struct {
	Name     string `json:"name"`
	Port     int32  `json:"port"`
	Protocol string `json:"protocol"`
}

type Address struct {
	Host  string `json:"host"`
	Ports []Port `json:"ports"`
}

type Instance struct {
	ID              string         `json:"id"`
	SchedulerID     string         `json:"schedulerId"`
	Status          InstanceStatus `json:"status"`
	Address         *Address       `json:"address"`
	ResourceVersion string         `json:"resourceVersion"`
}

repository: topfreegames/maestro

repo_name: topfreegames/maestro


text:
package file

import (
	"bytes"
	"os"
	"path/filepath"
	"testing"

	"github.com/ikki74/gotenberg/app/config"
)

func load(configurationFilePath string) {
	config.Reset()
	path, _ := filepath.Abs(configurationFilePath)
	config.ParseFile(path)
}

func TestNewFile(t *testing.T) {
	load("../../../_tests/configurations/gotenberg.yml")

	workingDir := "test"
	os.Mkdir(workingDir, 0666)

	// case 1: uses a wrong file name.
	if _, err := NewFile(workingDir, new(bytes.Buffer), "file.yml"); err == nil {
		t.Error("File should not have been instantiated with an empty buffer")
	}

	// case 2: uses a file name.
	filePath, _ := filepath.Abs("../../../_tests/file.pdf")
	r, _ := os.Open(filePath)
	defer r.Close()
	if _, err := NewFile(workingDir, r, "file.pdf"); err != nil {
		t.Errorf("File should have been instantiated using a reader of '%s'", filePath)
	}

	os.RemoveAll(workingDir)
}


text:
DESCRIPTION = "Image Renderer module"
LICENSE = "CLOSED"

inherit features_check

REQUIRED_DISTRO_FEATURES = "imr"

SRC_URI = "file://RTM8RC0000ZRRDSS00JPL3E.tar.gz"

COMPATIBLE_MACHINE = "(salvator-x|ebisu|draak|ulcb)"
PACKAGE_ARCH = "${MACHINE_ARCH}"

DEPENDS += "osal"

S = "${WORKDIR}/drivers/imr"

RCAR_SOC_r8a7795 = "h3"
RCAR_SOC_r8a7796 = "m3"
RCAR_SOC_r8a77965 = "m3n"
RCAR_SOC_r8a77990 = "e3"
RCAR_SOC_r8a77995 = "d3"

EXTRA_OEMAKE = "RCAR_SOC=${RCAR_SOC}"

do_install() {
    install -d ${D}${libdir}
    install -m 644 ${S}/libIMRDRV.so ${D}${libdir}

    install -d ${D}${includedir}/rcar-xos/imr
    install -m 644 ${S}/include/rcar-xos/imr/*.h ${D}${includedir}/rcar-xos/imr
}

PACKAGES = " \
    ${PN} \
    ${PN}-dev \
    ${PN}-dbg \
"

FILES_${PN} = " \
    ${libdir}/libIMRDRV.so \
"
FILES_${PN}-dev = " \
    ${includedir}/rcar-xos/imr/*.h \
"
FILES_${PN}-dbg += " \
    ${libdir}/.debug/libIMRDRV.so \
"

repository: renesas-rcar/meta-renesas

repo_name: renesas-rcar/meta-renesas

branch_name: refs/heads/dunfell

gha_language: BitBake


text:
package tools

import "time"

// TypefaceModel 字体模型
type TypefaceModel struct {
	// ID
	ID string
	// 名称
	Name string
	// 全拼
	TotalPinYin string
	// 首字母拼音
	FirstPinYin string
	// 下载地址
	URL string
	// 创建时间
	CreateTime time.Time
}

repository: delkyd/ShadowEditor

repo_name: delkyd/ShadowEditor