text:
# **spanish-dict-client**

[![npm version](https://badge.fury.io/js/spanish-dict-client.svg)](https://badge.fury.io/js/spanish-dict-client)

## **Disclaimer**

This is an ***unofficial*** client. This package is not endorsed by, or correlated to, SpanishDict or Curiosity Media Inc., it simply scrapes [www.spanishdict.com](https://www.spanishdict.com/) and returns data from the site.

## Info

This package currently can only translate and conjugate. I will expand the project if there is enough interest.

## Installation

Paste this into your command line:

`npm install spanish-dict-client`

Put this at the top of your JavaScript file:

`const dict = require('spanish-dict-client');`

## Functions
### Translate `.translate(<word>)`

The `translate` function translates a verb from either Spanish to English, or English to Spanish.

The function takes in one parameter, the word. This parameter can either be a `string` or an `object` with the key of `word`. It returns a promise which if resolved, returns an array with the translations, or if rejected returns an error.

**Example:**
```javascript
dict.translate('ser')
  .then(console.log)
  .catch(console.log);

//Outputs: [ 'to be' ]
```

### Conjugate `.conjugate(<options>)`

The `conjugate` function conjugates a Spanish verb, even if the verb is already conjugated.

The function takes in one `object`, options. Here are the potential keys that can be used:

* `word`: A `string` which is the verb to be conjugated.
* `tense`: A `string` which is the tense to be conjugated to. See further down for details.
* `person`: A `string` which is the person to be conjugated to. See further down for details.
* `translateOnError`: *Optional* A `boolean` which, if true, translates the word instead of conjugating it if the word is not a Spanish verb.

**Example:**
```javascript
var options = {
  word: 'hacer',
  tense: 'preteritIndicative',
  person: '4',
  translateOnError: true
};

dict.conjugate(options)
  .then(console.log)
  .catch(console.log);

//Outputs: [ 'hicisteis' ]
```

## Tenses

### Indicative Tenses

|  Verb Tense 	| Tense (Put this in your program) 	|
|:-----------:	|:--------------------------------:	|
|   Present   	|         presentIndicative        	|
|  Preterite  	|        preteritIndicative        	|
|  Imperfect  	|        imperfectIndicative       	|
| Conditional 	|       conditionalIndicative      	|

### Subjunctive Tenses

|  Verb Tense 	| Tense (Put this in your program) 	|
|:-----------:	|:--------------------------------:	|
|   Present   	|        presentSubjunctive        	|
|  Imperfect  	|       imperfectSubjunctive       	|
| Imperfect 2 	|       imperfectSubjunctive2      	|
|    Future   	|         futureSubjunctive        	|

### Imperative Tenses

|  Verb Tense 	| Tense (Put this in your program) 	|
|:-----------:	|:--------------------------------:	|
| Affirmative 	|            imperative            	|
|   Negative  	|        negativeImperative        	|

### Continuous / Progressive Tenses

|  Verb Tense 	| Tense (Put this in your program) 	|
|:-----------:	|:--------------------------------:	|
|   Present   	|         presentContinuous        	|
|  Preterite  	|        preteritContinuous        	|
|  Imperfect  	|        imperfectContinuous       	|
| Conditional 	|       conditionalContinuous      	|
|    Future   	|         futureContinuous         	|

### Perfect Tenses

|  Verb Tense 	| Tense (Put this in your program) 	|
|:-----------:	|:--------------------------------:	|
|   Present   	|          presentPerfect          	|
|  Preterite  	|          preteritPerfect         	|
|     Past    	|            pastPerfect           	|
| Conditional 	|        conditionalPerfect        	|
|    Future   	|           futurePerfect          	|

### Perfect Subjunctive Tenses

| Verb Tense 	| Tense (Put this in your program) 	|
|:----------:	|:--------------------------------:	|
|    Past    	|     presentPerfectSubjunctive    	|
|   Present  	|      pastPerfectSubjunctive      	|
|   Future   	|     futurePerfectSubjunctive     	|

### Misc. Tenses

| Verb Tense 	| Tense (Put this in your program) 	|
|:----------:	|:--------------------------------:	|
|     Any    	|                any               	|

## Persons

|        Person       	| Person code (Put this in your program) 	|
|:-------------------:	|:--------------------------------------:	|
|          Yo         	|                    0                   	|
|          Tú         	|                    1                   	|
|    Él/Ella/Usted    	|                    2                   	|
|       Nosotros      	|                    3                   	|
|       Vosotros      	|                    4                   	|
| Ellos/Ellas/Ustedes 	|                    5                   	|
|         Any         	|                    6                   	|

repository: ArkinSolomon/spanish-dict-client

repo_name: ArkinSolomon/spanish-dict-client


text:
---
id: scheduling
title: 'Scheduling'
sidebar_label: 'Scheduling'
---

Users can schedule jobs with the `every` key when defining jobs. There are two valid syntaxes: cron-like format and human-readable.

### Scheduling a job with the cron-like format

```shell
myjob:
    script: backup.sh
    every: "0 1 * * *"
```

It runs `myjob` every day at 1 AM.

### Scheduling a job with the human-readable format

```shell
myjob:
    script: backup.sh
    every: 6h
```

It runs `myjob` every 6 hours. The first execution will happen in the following 6 hours. Possible other modifiers are `s` (seconds), `m` (minutes) and `d` (days).

license: MIT

repository: dadwic/runlet

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: dadwic/runlet


text:
# pbprint

`pbprint` uses the image in your clipboard (pasteboard), resizes it to be as large as possible on an A4 page, and then prints it using your default printer.

## Requirements

Requires `pngpaste` and `identify` (imagemagick)

`pngpaste` is a tool for creating a png file out of the current copied item in your clipboard.

`imagemagick` is a tool for manipulating images from the command line.

The easist wayto install these is using [Homebrew](https://brew.sh/).

`brew install pngpaste`

`brew install imagemagick`

Make sure `pngpaste` is in your `PATH`

## Usage

1. Copy an image to your clipboard
2. Run `pbprint.sh`

Without any arguments, this will resize the image to the clipboard to maximize it on an a4 page, and then print it using your default printer (via `lp`).

`pbprint.sh --pdf` allows you to perform a dry-run by creating and open a pdf of the output so you can examine it before printing.

## Motivation

This script was written to automate the printing of coloring pages for kids. If you perform a [google image search](https://www.google.com/search?tbm=isch&q=coloring+pages+butterfly) for "coloring pages something_kid_likes", you will get lots of great pictures, which can be copied to the clipboard. `pbprint.sh` makes the re-sizing and printing part much faster.

repository: stephenlind/pbprint

repo_name: stephenlind/pbprint


text:
*** aside
See also:
[Porting Guide](/doc/porting_guide.md) |
[Build System](/doc/framework_build.md) |
[Debugging](/doc/framework_debugging.md) |
[Testing](/doc/framework_testing.md) |
[Vendor Extensions](/doc/vendor_extensions.md)
***

# CHRE Framework Overview

[TOC]

The CHRE reference implementation (hereafter referred to just as "CHRE" or "the
CHRE framework") is developed primarily in C++11 using a modular object-oriented
approach that separates common code from platform-specific code. CHRE is an
event-based system, so CHRE is built around an event loop which executes nanoapp
code as well as CHRE system callbacks. Per the CHRE API, nanoapps can’t execute
in more than one thread at a time, so CHRE is structured around a single thread
that executes the event loop, although there may be other threads in the system
that support CHRE. The EventLoopManager is a Singleton object which owns the
main state of the CHRE framework, including EventLoop and \*Manager classes for
the various subsystems supported by CHRE.

To get a better understanding of code structure and how it weaves between common
and platform-specific components, it is helpful to trace the flow through a few
example scenarios. Note that this is not meant to be an exhaustive list of
everything that happens in each case (for that, refer to the code itself), but
rather an overview of key points to serve as an introduction.

## Loading a nanoapp via the HAL

There are multiple ways by which a nanoapp can be loaded (see the relevant
section below for details), but this example traces the flow for dynamically
loading a nanoapp that has been passed in via the Context Hub HAL's
`loadNanoapp()` method.

1. The nanoapp binary reaches the HAL implementation, and it is loaded into the
   processor where CHRE is running using a platform-specific method. While the
   path this takes can vary, one common approach is to transmit the binary into
   CHRE via the platform-specific HostLink implementation, then verify its
   digital signature, and parse the binary file format (e.g. ELF) to load and
   link the code.

2. Once the nanoapp code is loaded, the platform code calls
   `EventLoopManager::deferCallback()` to switch context to the main CHRE thread
   (if needed), so it can complete loading and starting the nanoapp.
   `deferCallback()` effectively posts an event to the main event loop which
   does not get delivered to any nanoapps. Instead, the purpose is to invoke the
   supplied callback from the CHRE thread once the event is popped off the
   queue.

3. The (platform-specific) callback finalizes the newly constructed `Nanoapp`
   object as needed, and passes it to `EventLoop::startNanoapp()` - this marks a
   transition from platform-specific to common code.

4. `EventLoop` takes ownership of the `Nanoapp` object (which is a composite of
   common and platform-specific data and functions, as described in the Platform
   Abstractions section), includes it in the collection of loaded nanoapps to
   execute in the main event loop, updates `mCurrentNanoapp` to reference the
   nanoapp it's about to execute, and calls into `PlatformNanoapp::start()`.

5. Since the mechanism of supporting dynamic linkage and position independent
   code can vary by platform, transferring control from the framework to a
   nanoapp is considered part of the platform layer. So
   `PlatformNanoapp::start()` performs any necessary tasks for this, and calls
   into the `nanoappStart()` function defined in the nanoapp binary.

## Invoking a CHRE API from a nanoapp

Let's assume the nanoapp we've loaded in the previous section calls the
`chreSensorConfigure()` CHRE API function within `nanoappStart()`:

1. The nanoapp invokes `chreSensorConfigure()` with parameters to enable the
   accelerometer.

2. The Nanoapp Support Library (NSL) and/or the platform's dynamic linking
   module are responsible for handling the transition of control from the
   nanoapp binary to the CHRE framework. This can vary by platform, but we'll
   assume that control arrives in the `chreSensorConfigure()` implementation in
   `platform/shared/chre_api_sensor.cc`.

3. `EventLoopManager::validateChreApiCall()` is invoked to confirm that this
   function is being called from the context of a nanoapp being executed within
   the event loop (since associating the API call with a specific nanoapp is a
   requirement of this API and many others, and the majority of the CHRE
   framework code is only safe to execute from within the main CHRE thread), and
   fetch a pointer to the current `Nanoapp` (i.e. it retrieves `mCurrentNanoapp`
   set previosly by `EventLoop`).

4. `SensorManager::setSensorRequest()` (via
   `EventLoopManager::getSensorRequestManager()`) is called to process the
   nanoapp’s request - we transition to common code here.

5. The request is validated and combined with other nanoapp requests for the
   same sensor to determine the effective sensor configuration that should be
   requested from the platform, and the nanoapp is registered to receive
   broadcast accelerometer sensor events.

6. `SensorRequestManager` calls into `PlatformSensorManager::configureSensor()`,
   which performs the necessary operations to actually configure the
   accelerometer to collect data.

7. Assuming success, the return value propagates back up to the nanoapp, and it
   continues executing.

## Passing an event to a nanoapp

Following the example from above, let's follow the case where an accelerometer
sample has been generated and is delivered to the nanoapp for processing.

1. Starting in platform-specific code, likely in a different thread, the
   accelerometer sample is received from the underlying sensor framework - this
   typically happens in a different thread than the main CHRE thread, and within
   the fully platform-specific `PlatformSensorManagerBase` class.

2. As needed, memory is allocated to store the sample while it is being
   processed, and the data is converted into the CHRE format: `struct
   chreSensorThreeAxisData`.

3. `SensorRequestManager::handleSensorDataEvent()` is invoked (common code) to
   distribute the data to nanoapps.

4. `SensorRequestManager` calls into `EventLoop` to post an event containing the
   sensor data to all nanoapps registered for the broadcast event type
   associated with accelerometer data, and sets `sensorDataEventFree()` as the
   callback invoked after the system is done processing the event.

5. `EventLoop` adds this event to its event queue and signals the CHRE thread.

6. Now, within the context of the CHRE thread, once the event loop pops this
   event off of its queue in `EventLoop::run()`, the `nanoappHandleEvent()`
   function is invoked (via `PlatformNanoapp`, as with `nanoappStart`) for each
   nanoapp that should receive the event.

7. Once the event has been processed by each nanoapp, the free callback
   (`sensorDataEventFree()`), is called to release any memory or do other
   necessary cleanup actions now that the event is complete.

## Platform Abstractions

CHRE follows the 'compile time polymorphism' paradigm, to allow for the benefits
of `virtual` functions, while minimizing code size impact on systems with tight
memory constraints.

Each framework module as described in the previous section is represented by a
C++ class in `core/`, which serves as the top-level reference to the module and
defines and implements the common functionality. This common object is then
composed with platform-specific functionality at compile-time. Using the
`SensorRequestManager` class as an example, its role is to manage common
functionality, such as multiplexing sensor requests from all clients into a
single request made to the platform through the `PlatformSensorManager` class,
which in turn is responsible for forwarding that request to the underlying
sensor system.

While `SensorRequestManager` is fully common code, `PlatformSensorManager` is
defined in a common header file (under `platform/include/chre/platform`), but
implemented in a platform-specific source file. In other words, it defines the
interface between common code and platform-specific code.

`PlatformSensorManager` inherits from `PlatformSensorManagerBase`, which is
defined in a platform-specific header file, which allows for extending
`PlatformSensorManager` with platform-specific functions and data. This pattern
applies for all `Platform<Module>` classes, which must be implemented for all
platforms that support the given module.

Selection of which `PlatformSensorManager` and `PlatformSensorManagerBase`
implementation is instantiated is controlled by the build system, by setting the
appropriate include path and source files. This includes the path used to
resolve include directives appearing in common code but referencing
platform-specific headers, like `#include
"chre/target_platform/platform_sensor_manager_base.h"`.

To ensure compatibility across all platforms, common code is restricted in how
it interacts with platform-specific code - it must always go through a common
interface with platform-specific implementation, as described above. However,
platform-specific code is less restricted, and can refer to common code, as well
as other platform code directly.

## Coding conventions

This project follows the [Google-wide style guide for C++
code](https://google.github.io/styleguide/cppguide.html), with the exception of
Android naming conventions for methods and variables. This means 2 space
indents, camelCase method names, an mPrefix on class members and so on.  Style
rules that are not specified in the Android style guide are inherited from
Google. Additionally, this project uses clang-format for automatic code
formatting.

This project uses C++11, but with two main caveats:

1. General considerations for using C++ in an embedded environment apply. This
   means avoiding language features that can impose runtime overhead, due to the
   relative scarcity of memory and CPU resources, and power considerations.
   Examples include RTTI, exceptions, overuse of dynamic memory allocation, etc.
   Refer to existing literature on this topic including this [Technical Report
   on C++ Performance](http://www.open-std.org/jtc1/sc22/wg21/docs/TR18015.pdf)
   and so on.

2. Full support of the C++ standard library is generally not expected to be
   extensive or widespread in the embedded environments where this code will
   run. This means things like <thread> and <mutex> should not be used, in
   favor of simple platform abstractions that can be implemented directly with
   less effort (potentially using those libraries if they are known to be
   available).

repository: jiangshide/android-system

branch_name: refs/heads/main

repo_name: jiangshide/android-system


text:
# Scijson : Open-source json file definition to store metadata alongside data

* Version : 0.1b
* License : MIT License
* Support : Matlab 2014 and after (Octave)

## What's new

* 2020/05/18 - First version of the repo, and definition of the standard.

## ToDo

* Check floating point precision after json conversion and back
* Write a json schema
* Develop Python version
* Check complex number support
* Deal with string data for row and column metadata, for 1D data typically
* Develop Excel, Libre Office Calc version

## Definition of the standard

The main objective of the standard is to store data and its metadata at the same
 place. Hence ouputs of scientific and engineering codes are more robust and
 less prone to errors. In addition with a standard way to store data, it's
 possible to use functions to automate plotting for example.

Scijson is a [json] file with a typical structure to store data array with its
metadata like *name*, *unit* and optionally a *description* field. Each array
and its metadata is called hereafter a *sjdata* object. Find below an example of
 a *sjdata* json object :

```json
{
    "name": "Price",
    "unit": "euro",
    "data": [1,4,2,5,3,8],
    "description": ""
}
```

According to the dimension of the data, several *sjdata* are used to describe
the dataset. For example 2 dimensions data, represented by two 1D vectors, are
saved in a set of several *sjdata*, called a *sjset*. Find below an example with
 two vectors named `Time` and `Voltage`.

```json
{
	"row": {
		"name": "Time",
		"unit": "s",
		"data": [1,2,3,4,5,6,7,8,9,10],
		"description": ""
	},
	"array": {
		"name": "Voltage",
		"unit": "V",
		"data": [10,10.5,9,8,6,9,12,11,10.2,9.7],
		"description": ""
	}
}
```

Since json is a structured text file, it is interoperable, machine- and
human-readable.

[json]: https://www.json.org/json-en.html

The definition is summed up here after. The *sjdata* fields are:

| Field names |
|-------------|
| `name`      |
| `unit`      |
| `data`      |
|`description`|

The *sjset* field are, according to the dimension of data:

| field names | 1D data | 2D data | 3D data |
|-------------|:-------:|:-------:|:-------:|
| `row`       |         | X       |   X     |
| `col`       |         |         |   X     |
| `array`     |  X      |  X      |   X     |

## Matlab/Octave toolbox

A Matlab/Octrave toolbox has been developed to allow the creation, the storage
and the plotting of data with scijson standard.

The toolbox is named scijsonlab. The files can be download here:
[scijsonlab](./scijson_matlab/)

## Python module

To come.

## FAQ

##### I come from Matlab, I can use a struct datatype and save it to a .mat file.

Yes, but the .mat file is only machine readable and not meaned to be
interoperable. Scijsonlab uses struct to build object before saving them to
json file.

repository: FloGom/scijson

repo_name: FloGom/scijson


text:
[Home](./index.md) > [decentraland-ecs](./decentraland-ecs.md) > [PlaneShape](./decentraland-ecs.planeshape.md)

## PlaneShape class

Signature:

```typescript
export declare class PlaneShape extends Shape
```

## Properties

|  Property | Modifiers | Type | Description |
|  --- | --- | --- | --- |
|  [height](./decentraland-ecs.planeshape.height.md) |  | number | Sets the vertical length of the plane. Defaults to 1. |
|  [uvs](./decentraland-ecs.planeshape.uvs.md) |  | number[] | Sets the UV coordinates for the plane. Used to map specific pieces of a Material's texture into the plane's geometry. |
|  [width](./decentraland-ecs.planeshape.width.md) |  | number | Sets the horizontal length of the plane. Defaults to 1. |

repository: LeonardoVenezia/decentraland-Shoes-Shop

repo_name: LeonardoVenezia/decentraland-Shoes-Shop


text:
## UnZipSelected

Plugin for [fman.io](https://fman.io) to unzip a file that has been selected in fman.

Install with [fman's built-in command for installing plugins](https://fman.io/docs/installing-plugins).

### Usage

Select one file and press **Shift+u**

### Features

 - Unzips the selected file into a directory with the same name as the current file name.


text:
Small microserver that tests a docker containers ability to access SRV records on the DNS server in a marathon/mesos environment. it will do so by returning the SRV information for a given service

# build/deploy

use `make` to compile and build the docker image, `make dev` to run it locally and `make deploy` to push the image (make sure you change the organization)

Deploy the image into your mesos/marathon environment for instance by using the provided `marathon.json`

# usage

goto `http://service.domain/service/{name of service}` for a full json response

goto `http://service.domain/short/{name of service}` for a list of `ip-adress:port` text response

you should see your service and on which host/port it's instances are located

repository: gertjana/dcos-srv-resolver

repo_name: gertjana/dcos-srv-resolver


text:
We aim to release a new stable version of HHVM every 8 weeks on Mondays. The branch for a particular release is cut on the Monday 14 days prior to that and then rigorously tested. It might be delayed if there are any issues found during testing or we are otherwise not confident in the releases. Point releases will be done as needed for major bugs.

## Lifecycle

We offer "long term support" (LTS) for every third releases - so roughly twice a year. These are supported through the next 6 releases, so roughly 48 weeks. This means that there are 2 supported LTS versions at any time. Non-LTS releases are supported until the next release comes out, so only for approximately for 8 weeks each.

## Supported Releases

| Version | LTS | Release Date | Expected End Of Support |
|---------|-----|--------------|-------------------------|
| [3.29]  | No  | 2018-10-22   | 2018-11-05              |
| [3.27]  | Yes | 2018-06-18   | 2019-09-05              |
| [3.24]  | Yes | 2018-01-16   | 2018-12-17              |

## Future Releases

| Version | LTS | Branch Cut Date | Expected Release Date | Expected End Of Support |
|---------|-----|-----------------|-----------------------|-------------------------|
| 3.30    | Yes | 2018-12-03      | 2018-12-17            | 2019-11-19              |
| 3.31/4.0| No  | 2019-01-28      | 2019-02-11            | 2019-04-08              |

## Unsupported Releases

All versions not listed above are unsupported; support for the following releases has ended recently:

| Version | LTS | Release Date | End Of Support |
|---------|-----|--------------|----------------|
| [3.28]  | No  | 2018-08-28   | 2018-10-22     |
| [3.26]  | No  | 2018-05-07   | 2018-07-02     |
| [3.21]  | Yes | 2017-08-02   | 2018-07-02     |

[3.29]: https://hhvm.com/blog/2018/10/22/hhvm-3.29.html
[3.28]: https://hhvm.com/blog/2018/08/28/hhvm-3.28.0.html
[3.27]: https://hhvm.com/blog/2018/06/18/hhvm-3.27.0.html
[3.26]: https://hhvm.com/blog/2018/05/07/hhvm-3.26.html
[3.25]: https://hhvm.com/blog/2018/03/15/hhvm-3.25.html
[3.24]: https://hhvm.com/blog/2018/01/16/hhvm-3.24.html
[3.21]: https://hhvm.com/blog/2017/08/02/hhvm-3-21.html

repository: watashi/user-documentation

gha_license_id: NOASSERTION

repo_name: watashi/user-documentation


text:
---
title: Building a Flutter app
description: How to build a Flutter app with codemagic.yaml
weight: 4
aliases:
  - '../yaml/building-a-flutter-app'
startLineBreak: true
---

## Setting up a Flutter project

The apps you have available in Codemagic are listed on the Applications page. See how to add additional apps [here](./adding-apps-from-custom-sources).

1. On the Applications page, click **Set up build** next to the app you want to start building.
2. On the popup, select **Flutter App** as the project type and click **Continue**.
3. Then you can choose to either set up your builds in the **codemagic.yaml** file or select the **Workflow Editor** tab to configure the builds in the UI.

`codemagic.yaml` is a highly customizable configuration file that you can use to build, test and publish Flutter apps, widgets, and Flutter or Dart packages. The Workflow Editor is a quick way to get started building standard Flutter applications.

You can simultaneously set up workflows both in `codemagic.yaml` and the Workflow Editor. However, when a `codemagic.yaml` is detected in the repository, it is automatically used for configuring builds that are triggered in response to the events defined in the file and any configuration in the Flutter workflow editor is ignored.

{{<notebox>}}
For documentation on building Flutter projects using the workflow editor, please refer to [**Building Flutter apps via the workflow editor**](../flutter/flutter-projects).
{{</notebox>}}

## Exporting configuration from the Flutter workflow editor

You can get started with YAML easily if you have an existing project set up in Codemagic UI.

1. Navigate to your app workflow settings.
2. In the **Configuration as code** section on the right sidebar, click **Download configuration**.

{{<notebox>}}
The YAML feature currently has the following **limitations**:

* Exporting configuration from the workflow editor is supported for Flutter-based Android, iOS and web apps.
* The exported configuration is not identical to the settings in the workflow editor and lacks the configuration for some features, such as **Stop build if tests fail** and publishing to Codemagic Static Pages.
{{</notebox>}}

## Building with YAML

1. In order to use `codemagic.yaml` for build configuration in Codemagic, commit the file to the root directory of your repository.
2. Back in app settings in Codemagic, select the **`codemagic.yaml`** tab.
3. Scan for the `codemagic.yaml` file by selecting a **branch** to scan and clicking the **Check for configuration file** button at the top of the page. Note that you can have different configuration files in different branches.
4. If a `codemagic.yaml` file is found in that branch, you can click **Start your first build** and select the **branch** and **workflow** to build.
5. Finally, click **Start new build** to build the app.

## Android builds

{{<notebox>}}
You can find an up-to-date codemagic.yaml Flutter Android workflow in [Codemagic Sample Projects](https://github.com/codemagic-ci-cd/codemagic-sample-projects/blob/main/flutter/flutter-yaml-demo-project/codemagic.yaml#L2).
{{</notebox>}}

Set up local properties

```yaml
- echo "flutter.sdk=$HOME/programs/flutter" > "$FCI_BUILD_DIR/android/local.properties"
```
### Building .apk

```yaml
- flutter build apk --release
```

### Building universal .apk(s) from existing app bundle(s) with user-specified keys

If your app settings in Codemagic have building Android App Bundles enabled, we will automatically include a script for generating a signed `app-universal.apk` during the YAML export. If you are creating a YAML file from a scratch, add the following script to receive the .apk file(s):

```yaml
- android-app-bundle build-universal-apk \
  --bundle 'project_directory/build/**/outputs/**/*.aab' \
  --ks /tmp/keystore.keystore \
  --ks-pass $FCI_KEYSTORE_PASSWORD \
  --ks-key-alias $FCI_KEY_ALIAS \
  --key-pass $FCI_KEY_PASSWORD
```

Please make sure to wrap the `--bundle` pattern in single quotes. If `--bundle` option is not specified, default glob pattern `**/*.aab` will be used.

More information about Android code signing can be found [here](../code-signing-yaml/signing-android).

{{<notebox>}}
Codemagic uses the [android-app-bundle](https://github.com/codemagic-ci-cd/cli-tools/tree/master/docs/android-app-bundle#android-app-bundle) utility to build universal .apk files from Android App Bundles.
{{</notebox>}}

## iOS builds

{{<notebox>}}
You can find an up-to-date codemagic.yaml Flutter iOS workflow in [Codemagic Sample Projects](https://github.com/codemagic-ci-cd/codemagic-sample-projects/blob/main/flutter/flutter-yaml-demo-project/codemagic.yaml#L72).
{{</notebox>}}

### Building an unsigned application .app

```yaml
- flutter build ios --debug --no-codesign
```

### Building a signed iOS application archive .ipa

{{<notebox>}}
Codemagic uses the [xcode-project](https://github.com/codemagic-ci-cd/cli-tools/blob/master/docs/xcode-project/README.md#xcode-project) to prepare iOS application code signing properties for build.
{{</notebox>}}

```yaml
- xcode-project use-profiles
- xcode-project build-ipa --workspace ios/Runner.xcworkspace --scheme Runner
```

Read more about the different schemes in [Apple's documentation](https://help.apple.com/xcode/mac/current/#/dev0bee46f46).

**Note:** If you are using Flutter version 1.24.0-6.0 or higher, the recommended command for building an .ipa archive is `flutter build ipa` as shown below. Read more about it in [Flutter's documentation](https://flutter.dev/docs/deployment/ios#create-a-build-archive).

```yaml
- xcode-project use-profiles
- flutter build ipa --export-options-plist=/Users/builder/export_options.plist
```

## Web builds

```yaml
- name: Build web
  script: |
    flutter config --enable-web
    flutter build web --release
    cd build/web
    7z a -r ../web.zip ./*
```

## Testing, code signing and publishing a Flutter app

To test, code sign and publish a Flutter app:

* Testing examples for a flutter app can be found [here](../testing-yaml/testing/#flutter-test).
* All iOS and Android applications need to be signed before release. Different script examples are available [here](../publishing-yaml/distribution/).
* All generated artifacts can be published to external services. The available integrations currently are email, Slack, Google Play and App Store Connect. It is also possible to publish elsewhere with [custom scripts](../getting-started/yaml#scripts). Script examples for different options are available [here](../publishing-yaml/distribution/#publishing-a-flutter-package-to-pubdev).

repository: arbazadam/codemagic-docs

repo_name: arbazadam/codemagic-docs


text:
# Next

[diff](https://github.com/gtm-support/core/compare/1.0.0...main)

# 1.0.0

[diff](https://github.com/gtm-support/core/compare/589c63d1719d05319e9c2307397bdfb7cda5825b...1.0.0)

- Initial release

# 1.0.0-alpha.3

[diff](https://github.com/gtm-support/core/compare/1.0.0-beta.2...1.0.0-alpha.3)

- Restructured source code
- Added tests

# 1.0.0-beta.2

[diff](https://github.com/gtm-support/core/compare/1.0.0-alpha.1...1.0.0-beta.2)

- Export everything through `index`

# 1.0.0-alpha.1

[diff](https://github.com/gtm-support/core/compare/589c63d1719d05319e9c2307397bdfb7cda5825b...1.0.0-alpha.1)

- Initial alpha release

repository: akolov/core

gha_license_id: MIT

repo_name: akolov/core


text:
---
layout: default
---

# 1995-07-31 - Customer Service?

## Header Data

From<EMAIL_ADDRESS>(Robert Hettinga)

To<EMAIL_ADDRESS>Message Hash: 75c0fe44842a75efd99c87479817747de7d178c9aa0d4bd5e413240c93902935

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-07-31 18:17:51 UTC

Raw Date: Mon, 31 Jul 95 11:17:51 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Robert Hettinga)
Date: Mon, 31 Jul 95 11:17:51 PDT
To<EMAIL_ADDRESS>Subject: Customer Service?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Veracity suspect, but an interesting crypto story nonetheless...

>Subject: Tech support story (fwd)
>
>---------- Forwarded message ----------
> [Urban legend of the day...]
>
> Subject: Stressful tech call
> To: Customer Service; TechSports
>
> This falls into the "Why did it have to happen on *MY* shift?" category.
>
> A friend of mine is a chief engineer at SuperMac, and he related this
> story to me.
>
> SuperMac records a certain number of technical support calls at random,
> to keep tabs on customer satisfaction.  By wild "luck", they managed to
> catch the following conversation on tape.
>
> Some poor SuperMac TechSport got a call from some middle level official
> from the legitimate government of Trinidad.  The fellow spoke very good
> English, and fairly calmly described the problem.
>
> It seemed there was a coup attempt in progress at that moment.  However,
> the national armoury for that city was kept in the same building as the
> Legislature, and it seems that there was a combination lock on the door
> to the armoury.  Of the people in the capitol city that day, only the
> Chief of the Capitol Guard and the Chief Armourer knew the combination to
> the lock, and they had already been killed.
>
> So, this officer of the government of Trinidad continued, the problem is
> this.  The combination to the lock is stored in a file on the Macintosh,
> but the file has been encrypted with the SuperMac product called Sentinel.
> Was there any chance, he asked, that there was a "back door" to the
> application, so they could get the combination, open the armoury door,
> and defend the Capitol Building and the legitimately elected government
> of Trinidad against the insurgents?
>
> All the while he is asking this in a very calm voice, there is the sound
> of gunfire in the background. The Technical Support guy put the person on
> hold. A phone call to the phone company verified that the origin of the
> call was in fact Trinidad.  Meanwhile, there was this mad scramble to see
> if anybody knew of any "back doors" in the Sentinel program.
>
> As it turned out, Sentinel uses DES to encrypt the files, and there was
> no known back door.  The Tech Support fellow told the customer that aside
> from trying to guess the password, there was no way through Sentinel, and
> that they'd be better off trying to physically destroy the lock.
>
> The official was very polite, thanked him for the effort, and hung up.
> That night, the legitimate government of Trinidad fell.  One of the BBC
> reporters mentioned that the casualties seemed heaviest in the capitol,
> where for some reason, there seemed to be little return fire from the
> government forces.
>
> O.K., so they shouldn't have kept the combination in so precarious a
> fashion. But it does place, "I can't see my Microsoft Mail server"
> complaints in a different sort of perspective, does it not?
>

Cheers,
Bob Hettinga

-----------------
Robert Hettinga<EMAIL_ADDRESS>Shipwright Development Corporation, 44 Farquhar Street, Boston, MA 02131
USA<PHONE_NUMBER>
"Reality is not optional." --Thomas Sowell
>>>>Phree Phil: Email<EMAIL_ADDRESS>http://www.netresponse.com/zldf <<<<<

{% endraw %}
```

## Thread

+ Return to [July 1995](/archive/1995/07)

+ Return to<EMAIL_ADDRESS>(Robert Hettinga)](/authors/rah_at_shipwright_com_robert_hettinga_)"

+ 1995-07-31 (Mon, 31 Jul 95 11:17:51 PDT) - Customer Service? -<EMAIL_ADDRESS>(Robert Hettinga)_


text:
PayPal Funding Components
-------------------------

[![npm version](https://img.shields.io/npm/v/@paypal/funding-components.svg?style=flat-square)](https://www.npmjs.com/package/@paypal/funding-components) [![build status](https://img.shields.io/travis/paypal/paypal-funding-components/master.svg?style=flat-square)](https://travis-ci.org/paypal/paypal-funding-components)

[![dependencies Status](https://david-dm.org/paypal/paypal-funding-components/status.svg)](https://david-dm.org/paypal/paypal-funding-components) [![devDependencies Status](https://david-dm.org/paypal/paypal-funding-components/dev-status.svg)](https://david-dm.org/paypal/paypal-funding-components?type=dev)

PayPal JavaScript SDK module to deal with funding sources and eligibility.

## Remember a funding source from the client-side

Note: your client-id and domain must be approved to call this function

```javascript
paypal.rememberFunding([ paypal.FUNDING.VENMO ]);
```

## Remember a funding source from the server-side

```javascript
import { rememberFunding } from '@paypal/funding-components';
import { FUNDING } from '@paypal/sdk-constants';

rememberFunding(req, res, [ FUNDING.VENMO ]);
```

## Check a remembered funding source from the server-side

```javascript
import { isFundingRemembered } from '@paypal/funding-components';
import { FUNDING } from '@paypal/sdk-constants';

if (isFundingRemembered(req, FUNDING.VENMO)) {
    // ...
}
```

Pass in a custom set of cookies:

```javascript
isFundingRemembered(req, FUNDING.VENMO, { cookies })
```

Quick Start
-----------

#### Installing

```bash
npm install --save @paypal/funding-components
```

#### Getting Started

- Fork the module
- Run setup: `npm run setup`
- Start editing code in `./src` and writing tests in `./tests`
- `npm run build`

#### Building

```bash
npm run build
```

#### Tests

- Edit tests in `./test/tests`
- Run the tests:

  ```bash
  npm test
  ```


text:
+++
title = "On the (Statistical) Detection of Adversarial Examples"
authors = ["Kathrin Grosse, Saarland University"]
date = 2017-04-05  # Schedule page publish date.
draft = false

# Talk start and end times
time_start = 2017-04-05T15:00:00Z
time_end = 2017-04-05T16:00:00Z

# Optional shortened abstract
abstract="" # ignore this
abstract_short = ""

# Name of event and optional event URL.
event = "Machine Learning Seminar"
event_url = ""

# Location of event.
location = "Ada Lovelace (Regent Court COM-108)"

# Seminar host
host="Mike Smith"

# Is this a selected talk? (true/false)
selected = false

tags = ["seminar"]

# Links (optional).
url_pdf = ""
url_slides = ""
url_video = ""
url_code = ""

# Does the content use math formatting?
math = false

# Does the content use source code highlighting?
highlight = true

# Featured image
# Place your image in the `static/img/` folder and reference its filename below, e.g. `image = "example.jpg"`.
[header]
image = ""
caption = ""

+++

## Abstract

Imagine meeting a dear friend and thinking he is your mother, because he is wearing some glasses. Wait, what? Out of question for most of us, however reality for many machine learning models. So called adversarial examples are original samples where an adversary computes an optimal perturbation, leading to a different classification. To humans, however, the two examples are in most cases not distinguishable. The automated detection of such adversarial examples remains an open problem, since the perturbations are a consequence of an inherent property of all classifiers: the gradient of the decision function.

In this talk, we will first briefly review how adversarial examples are computed (using the example of malware data). We then move to our work on how to detect adversarial examples, presenting two approaches. One confidently detects adversarial examples, however only when presented in a batch. Another approach works as well for a single example, yet is does not work as a reliable defence in all cases: In some cases, it only increases the cost of the attack.

## Biography

I studied cognitive sciences at Osnabrück (Lower Saxony, Germany). I specialized in computer science, AI and neurobiology. In my term abroad at the Universidad del Sur in Bahia Blanca, Argentina, we (joint work with Carlos Chesñevar) started to work on opinion mining on Twitter. Around then I decided to work in Data Mining and ML, and continued my studies at Saarland University (since there is a lot of Data Mining/ML specialists there). I wrote my master thesis on text mining in Jilles Vreeken's group, who does Minimum Description Length based exploratory data analysis. Although always enjoying data mining and machine learning in itself, I became interested in security, particularly the security of ML. Due to this interest, I started working (as a PhD student) on this topic at Michael Backes group at CISPA.

branch_name: refs/heads/source

gha_language: HTML


text:
---
title: "validatePersonForAllRegistrars"
description: "Validates this person detail against all supported external registrars (APNIC/ARIN/RIPE). The validation uses the most r... "
layout: "method"
tags:
    - "method"
    - "sldn"
    - "Account"
classes:
    - "SoftLayer_Account_Regional_Registry_Detail"
aliases:
    - "/reference/services/softlayer_account_regional_registry_detail/validatePersonForAllRegistrars"
---
# [SoftLayer_Account_Regional_Registry_Detail](/reference/services/SoftLayer_Account_Regional_Registry_Detail)::validatePersonForAllRegistrars

Validate an existing person detail object.

## Overview
Validates this person detail against all supported external registrars (APNIC/ARIN/RIPE). The validation uses the most restrictive rules ensuring that any person detail passing this validation would be acceptable to any supported registrar.

The person detail properties are validated against - Non-emptiness - Minimum length - Maximum length - Maximum words - Supported characters - Format of data

If the person detail validation succeeds, then an empty list is returned indicating no errors were found and that this person detail would work against all three registrars during a subnet registration.

If the person detail validation fails, then an array of validation errors (SoftLayer_Container_Message[]) is returned. Each message container contains error messages grouped by property type and a message type indicating the person detail property type object which failed validation. It is possible to create a subnet registration using a person detail which does not pass this validation, but at least one registrar would reject it for being invalid.

-----

### Parameters
|Name | Type | Description |
| --- | --- | --- |

### Required Headers
* authenticate
* SoftLayer_Account_Regional_Registry_DetailInitParameters

### Return Values
* <a href='/reference/datatypes/SoftLayer_Container_Message'>SoftLayer_Container_Message[] </a>


text:
---
title: "Create bookingCustomer"
description: "Create a new bookingCustomer object."
ms.localizationpriority: medium
author: "arvindmicrosoft"
ms.prod: "bookings"
doc_type: apiPageType
---

# Create bookingCustomer

Namespace: microsoft.graph

 [!INCLUDE [beta-disclaimer](../../includes/beta-disclaimer.md)]

Create a new [bookingCustomer](../resources/bookingcustomer.md) object.
## Permissions
One of the following permissions is required to call this API. To learn more, including how to choose permissions, see [Permissions](/graph/permissions-reference).

|Permission type      | Permissions (from least to most privileged)              |
|:--------------------|:---------------------------------------------------------|
|Delegated (work or school account) |  BookingsAppointment.ReadWrite.All, Bookings.ReadWrite.All, Bookings.Manage.All   |
|Delegated (personal Microsoft account) | Not supported.   |
|Application | Not supported.  |

## HTTP request
<!-- { "blockType": "ignored" } -->
```http
POST /bookingBusinesses/{id}/customers

```
## Request headers
| Name       | Description|
|:---------------|:----------|
| Authorization  | Bearer {code}. Required.|

## Request body
In the request body, supply a JSON representation of a [bookingCustomer](../resources/bookingcustomer.md) object.

## Response
If successful, this method returns a `201 Created` response code and a [bookingCustomer](../resources/bookingcustomer.md) object in the response body.

## Example
### Request
The following is an example of the request.

# [HTTP](#tab/http)
<!-- {
  "blockType": "request",
  "name": "create_bookingcustomer_from_bookingbusiness",
  "sampleKeys"<EMAIL_ADDRESS>}-->
```http
POST<EMAIL_ADDRESS>Content-type: application/json

{
    "displayName": "Joni Sherman",
    "emailAddress"<EMAIL_ADDRESS>    "addresses": [
        {
            "postOfficeBox":"",
            "street":"4567 Main Street",
            "city":"Buffalo",
            "state":"NY",
            "countryOrRegion":"USA",
            "postalCode":"98052",
            "type":"home"
        },
        {
            "postOfficeBox":"",
            "street":"4570 Main Street",
            "city":"Buffalo",
            "state":"NY",
            "countryOrRegion":"USA",
            "postalCode":"98054",
            "type":"business"
        }
    ],
    "phones": [
        {
            "number": "206-555-0100",
            "type": "home"
        },
        {
            "number": "206-555-0200",
            "type": "business"
        }
     ]
}
```

# [C#](#tab/csharp)

```csharp

GraphServiceClient graphClient = new GraphServiceClient( authProvider );

var bookingCustomer = new BookingCustomer
{
	DisplayName = "Joni Sherman",
	EmailAddress =<EMAIL_ADDRESS>	Addresses = new List<PhysicalAddress>()
	{
		new PhysicalAddress
		{
			PostOfficeBox = "",
			Street = "4567 Main Street",
			City = "Buffalo",
			State = "NY",
			CountryOrRegion = "USA",
			PostalCode = "98052",
			Type = PhysicalAddressType.Home
		},
		new PhysicalAddress
		{
			PostOfficeBox = "",
			Street = "4570 Main Street",
			City = "Buffalo",
			State = "NY",
			CountryOrRegion = "USA",
			PostalCode = "98054",
			Type = PhysicalAddressType.Business
		}
	},
	Phones = new List<Phone>()
	{
		new Phone
		{
			Number = "206-555-0100",
			Type = PhoneType.Home
		},
		new Phone
		{
			Number = "206-555-0200",
			Type = PhoneType.Business
		}
	}
};

await graphClient.BookingBusinesses["{bookingBusiness-id}"].Customers
	.Request()
	.AddAsync(bookingCustomer);

```

 [!IMPORTANT]
 Microsoft Graph SDKs use the v1.0 version of the API by default, and do not support all the types, properties, and APIs available in the beta version. For details about accessing the beta API with the SDK, see [Use the Microsoft Graph SDKs with the beta API](/graph/sdks/use-beta).

 For details about how to [add the SDK](/graph/sdks/sdk-installation) to your project and [create an authProvider](/graph/sdks/choose-authentication-providers) instance, see the [SDK documentation](/graph/sdks/sdks-overview).

### Response
The following is an example of the response.

>**Note:** The response object shown here might be shortened for readability.
<!-- {
  "blockType": "response",
  "truncated": true,
<EMAIL_ADDRESS>"microsoft.graph.bookingCustomer"
} -->
```http
HTTP/1.1 201 Created
Content-type: application/json

{
<EMAIL_ADDRESS>"https://graph.microsoft.com/beta/$metadata#bookingBusinesses('Contosolunchdelivery%40contoso.onmicrosoft.com')/customers/$entity",
    "id": "36038f36-634e-44e4-9415-d7d59c2347aa",
    "displayName": "Joni Sherman",
    "emailAddress"<EMAIL_ADDRESS>    "addresses": [
        {
            "postOfficeBox":"",
            "street":"4567 Main Street",
            "city":"Buffalo",
            "state":"NY",
            "countryOrRegion":"USA",
            "postalCode":"98052",
            "type":"home"
        },
        {
            "postOfficeBox":"",
            "street":"4570 Main Street",
            "city":"Buffalo",
            "state":"NY",
            "countryOrRegion":"USA",
            "postalCode":"98054",
            "type":"business"
        }
    ],
    "phones": [
        {
            "number": "206-555-0100",
            "type": "home"
        },
        {
            "number": "206-555-0200",
            "type": "business"
        }
     ]
}
```

<!-- uuid: 8fcb5dbc-d5aa-4681-8e31-b001d5168d79
2015-10-25 14:57:30 UTC -->
<!--
{
  "type": "#page.annotation",
  "description": "Create bookingCustomer",
  "keywords": "",
  "section": "documentation",
  "tocPath": "",
  "suppressions": [
  ]
}
-->

repository: microsoftgraph/msgraph-beta-sdk-dotnet

gha_language: C#

repo_name: microsoftgraph/msgraph-beta-sdk-dotnet


text:
# fetch-app-rn
Fetching Data from an API Endpoint in React Native.

Simple React Native Fetch App

Requirements
[Git] (https://git-scm.com/)
[Node] (https://nodejs.org/en/)
[React Native] (http://facebook.github.io/react-native/)

Setup
Clone this repository:

git clone https://github.com/MdSazzadIslam/fetch-app-rn.git

Install dependencies:

npm install

Be sure to have the corresponding SDK for each platform. Install app on device:

react-native run-ios For Android please run bellow command

License
MIT

repository: MdSazzadIslam/fetch-app-rn

repo_name: MdSazzadIslam/fetch-app-rn


text:
---
meta:
  - name: description
    content: Login component (Guard)
---

# Login Component (Guard)

<LastUpdated/>

The Authing login component (Guard) is an embeddable login form that can be configured according to your needs and is recommended for single-page applications. It allows you to easily add various social login methods so that your users can log in seamlessly and have a consistent login experience on different platforms. Guard shields many implementation details of low-level authentication for developers, as well as cumbersome UI development.

Guard can be integrated into your React, Vue.js, Angular, and native JavaScript projects. You can use this component to quickly implement the login authentication process.

![Guard demo](../../images/reference/guard-demo.jpg)

## Function list

#### Rich login and registration methods

Built-in rich login and registration methods for developers to choose:

- Account password login (including mobile phone number + password, email + password, user name + password);
- SMS login;
- APP scan code login ([need to access APP scan code login first](/guides/authentication/qrcode/use-self-build-app/overview.md)）；
- Social login, such as GitHub login ([need to be configured in the background](/guides/connections/social.md)）；
- Enterprise identity source login ([needs to configure enterprise identity source](/guides/connections/enterprise.md)）；

#### Built-in forgot password process

The Guard has a built-in interactive UI for forgetting the password, so you don't need to write any additional code.

#### Built-in multi-factor authentication (MFA) capability

Guard has built-in multi-factor authentication (MFA) function. When your application enables multi-factor authentication, users can use this component to complete multi-factor authentication. You don't need to write any additional code.

#### Responsive layout

Responsive layout, perfectly compatible with mobile and PC terminals, and you can easily customize the login box style through custom CSS.

#### Compatible with all mainstream front-end frameworks

- [Native JavaScript call](./native-javascript.md);
- [Vue components](./vue.md);
- [React components](./react.md);
- [Angular components](./angular.md).

## Online example

<iframe src="https://codesandbox.io/embed/red-microservice-6613h?fontsize=14&hidenavigation=1&theme=dark"
     style="width:100%; height:500px; border:0; border-radius: 4px; overflow:hidden;"
     title="authing-react-guard"
     allow="accelerometer; ambient-light-sensor; camera; encrypted-media; geolocation; gyroscope; hid; microphone; midi; payment; usb; vr; xr-spatial-tracking"
     sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
   ></iframe>

## Use in React project

You can include the `@authing/react-ui-components` package in your React project. For details, please refer to the[React login component usage documentation](./react.md).

## Use in Vue.js project

You can include the `@authing/vue-ui-components` package in your Vue.js project. For details, please refer to the [ Vue.js login component usage documentation](./vue.md).

## Use in Angular project

You can include the `@authing/ng-ui-components` package in your Vue.js project. For details, please refer to the [Angular login component usage documentation](./angular.md).

## Use in native JavaScript projects

You can include the `@authing/native-js-ui-components` package in your native JavaScript project. For details, please refer to the [Native JavaScript login component usage documentation](./native-javascript.md).

## Get help

请访问 [Authing Chat](https://forum.authing.cn/)。

repository: Authing/docs

gha_language: JavaScript

repo_name: Authing/docs


text:
# Explanation

## Problem Statement

Breaks are hectic at APU, the food buses, etc. Students need to wait for long periods of time, and cooks struggle to take orders in real time while preventing students from taking the food without giving the token. We’ll make a site so students can order beforehand. There will be two sites, one for cooks, and one for students.

## Site for Students

This site will show the food points available (APU, Snacks Food Bus, Meals Food Bus). Once a food point gets selected, the available items will be displayed. The student will be able to order several items (e.g., one order could be a juice and two bun samosas) before purchasing. Upon purchasing, they’ll receive a token (e.g., `8udj1f77bcf86cd799439i23`) which they can show the cook to pick up their order. This token will be displayed as a QR code, and when the cook scans it, the order will be marked as _picked up_. The site will show whether the order has been completed yet.

## Site for Cooks

This site will be for APU, and the food buses. The cooks will log in every day to list the items for sale. Each item will consist of:

|Item Detail|Item Detail Example|Mandatory to Enter|
|:---:|:---:|:---:|
|Item name|Mexican sandwich|Yes|
|Pic|![Mexican sandwich](sandwich.jpg)|No|
|Quantity|50|No|
|Price|Rs. 25|Yes|

This site will also show the token numbers of students who have ordered along with what they’ve ordered. The student will have to pay when they come to the counter. Once an order has been prepared, the cook can indicate such so that the student knows they can come to pick it up.

repository: neelkamath/khana-backend

gha_language: TypeScript

repo_name: neelkamath/khana-backend


text:
# TwoWire Simulator

I have been working on a project in which I worked with several I2C sensors that gave me information. However, for testing purposes I wrote this extension of the library “Wire.h” to let me simulate with an Arduino the behaviour of several I2C devices.

## Use

See *example.ino* file for an implementation in an arduino that will act as multiple I2C slave devices. The implementation in the master device is the same as it would be in normal use.
There are two ways to configure the class object WireSim:
- By giving the addresses (the mask will be calculated accordingly).
  - Be careful!! When submitting addresses make sure that most bits are common. If not the mask calculated will be big and lots of addresses will be disabled.

- By directly providing the mask and one address (there is no importance in which address is given).

The mask may disable more addresses than you need. Make sure these addresses are not used by other devices.

## Requirements

- *Wire.h* library (from arduino's official repository)

## How does it work?

If you want to understand the code I wrote you will have to learn a little about the Arduino’s hardware architecture.
A micro controller has several registers, that usually consist of a small amount of fast storage quickly accessible location available to a computer's central processing unit (CPU). We are going to focus on the Two Wire registers (TW).

The micro controller used by the Arduino Uno is called ATMega 328. There will be much more information in the section 22 - 2 wire Serial Interface - of the controller datasheet, if you are interested. This document is attached at the end of the article.

I will keep things simple. Here are the most important registers we need to understand. They are all 8 bits registers.

- **TWAR**:The TWI Address Register checks if the seven bits received are the slave address. In the affirmative case it triggers an interrupt routine. Here is where the “Wire.h” sets our address.

- **TWDR**: The Data and Address Shift Register. Contains the address or data bytes to be transmitted, or the address or data bytes received. Here is where we will check which address is called by the master.

- **TWAMR**: The TWI Address Mask can be set to mask (disable) the corresponding address bits in the TWI Address Register (TWAR). If the mask bit is set to one then the address match logic ignores the compare between the incoming address bit and the corresponding bit in TWAR.

Here is a diagram of what is happening (even if it is not in the order, this is the idea):

![Diagram](https://github.com/alexisgaziello/TwoWireSimulator/blob/master/imgs/diagram.png)

**Idea**

By putting one bit to the value 1 in the TWAMR address we are allowing two addresses to be read.
(Letters represent 1 or 0, however they must be the same on all addresses)

Mask:     	0	0	0	1	0	0	0
Address 1:	A	B	C	0	D	E	F
Address 2:	A	B	C	1	D	E	F

If we mask 2 bits then we have 4 addresses:

Mask:     	0	0	0	1	1	0	0
Address 1:	A	B	C	0	0	E	F
Address 2:	A	B	C	1	0	E	F
Address 3:	A	B	C	0	1	E	F
Address 4:	A	B	C	1	1	E	F

For 3 bits 8 addresses, etc. You get the idea. 2(bits masked) = number of addresses we can use.

However, be careful, some addresses are not allowed to be used because the I2C protocol needs them to work properly. You should only use addresses between 8 and 119. The first and last 8 are reserved.

repository: EthanBinkley/FEMTAFYESIMBOXsoftware

gha_language: C

repo_name: EthanBinkley/FEMTAFYESIMBOXsoftware


text:
# HugoModo

[![Waffle.io - Columns and their card count](https://badge.waffle.io/hugomodo/hugomodo.svg?columns=all)](https://waffle.io/hugomodo/hugomodo)

The base theme for HugoModo's modular approach to Hugo website design. It provides the asset precompilation pipeline and bundler data files, clean and semantic HTML, and well-organised partials for ease of developing child themes.

It provides minimal styling, so is best used as the base for a child theme. HugoModo themes which depend on it will include this theme automatically.

## Installation

```bash
git submodule add https://github.com/hugomodo/hugomodo themes/hugomodo
```

```toml
themes = ["hugomodo"]
```

## Support on Patreon
[![Patreon](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/bePatron?u=4780882)

## Support on Beerpay
Hey dude! Help me out for a couple of :beers:!

[![Beerpay](https://beerpay.io/hugomodo/hugomodo/badge.svg?style=beer-square)](https://beerpay.io/hugomodo/hugomodo)  [![Beerpay](https://beerpay.io/hugomodo/hugomodo/make-wish.svg?style=flat-square)](https://beerpay.io/hugomodo/hugomodo?focus=wish)

repository: hugomodo/hugomodo

repo_name: hugomodo/hugomodo


text:
### MeteorJS Framework

#### Overview

[Meteor](http://docs.meteor.com/#/full/quickstart) [39] is a JavaScript platform, offering a complete full-stack framework for delivering web and mobile apps;

![Figure @sota-meteor Meteor Plataform Overview](meteor-platform.png)

**Main Features**

-	It allows rapid prototyping and produces cross-platform code (Web, Android, iOS).
-	Meteor uses Blaze library for the front-end which fulfills the same purpose as Angular, Backbone or Ember but is much simpler to use and can be used with any of these libraries.
-	Blaze is also faster than Angular in high-throughput rendering tests.
-	Meteor works well with REST APIs using DDP, a simple protocol for fetching structured data from a server, and receiving live updates when that data changes.
-	The underlying database is MongoDB which Meteor works in real-time.
-	While Angular is a front-end library and Sails a backend one, Meteor is a full-stack framework, comparable with Derby.
-	The MVC model is replaced by MVM (Model-View-Mapper) which replace controller by ORM code that supports what views need to display data. Meteor controllers are on the client side.

#### Special directories

With this directories we can split the server code from the client code, for a better code organization, and also, what we want to share from what we want to make private;

-	**/client** Any files here are only served to the client. This is a good place to keep your HTML, CSS, and UI-related JavaScript code.

-	**/server** Any files in this directory are only used on the server, and are never sent to the client. Use /server to store source files with sensitive logic or data that should not be visible to the client.

-	**/public** Files in /public are served to the client as-is. Use this to store assets such as images. For example, if you have an image located at /public/background.png, you can include it in your HTML with or in your CSS with background-image: url(/background.png). Note that /public is not part of the image URL.

-	**/private** These files can only be accessed by server code through Assets API and are not accessible to the client.

**or** we can, in same JavaScript file, wrapping our code in

```JavaScript
app.js

if (Meteor.isClient) {
  // code will run only on client side
}

if (Meteor.isServer) {
  // code will run only on server side
}

```

#### Code convention

Client connection:

```JavaScript
Tasks = new Mongo.Collection("tasks");
```

Insert:

```JavaScript
Template.body.events({
  "submit .new-task": function (event) {
    // This function is called when the new task form is submitted
    var text = event.target.text.value;
    Tasks.insert({
      text: text,
    });
  }
```

Query:

```JavaScript
Template.body.helpers({
    tasks: function () {
      // Show newest tasks first
    return Tasks.find({}, {sort: {createdAt: -1}});
    }
)};
```

Delete:

```JavaScript
Template.task.events({
  "click .delete": function () {
    Tasks.remove(this._id);
  }
)};
```

#### Evaluation

##### Positive

-	Full Stack package system
-	Mobile version with Cordova/Phonegap
-	Multiplataform Distribution
-	Sofisticaded UI
-	[Atmosphere Tool](https://atmospherejs.com/) list all available packages to MeteorJS

##### Negative

-	Meteor Development Group has built specifically for a reactive front-end experience
-	For applications with very large numbers of concurrent connections (like facebook), Meteor might require larger amounts of RAM than other solutions, but can be optimized

#### Requirement Analysis

-	[Service Framework **MUST** be Messaging Node agnostic](https://github.com/reTHINK-project/core-framework/issues/44): **No**

	It has its own "Messaging Node", who is called [DDP (distributed Data Protocol)](https://www.meteor.com/ddp).

-	[The Service Framework **MUST** avoid any JavaScript conflicts](https://github.com/reTHINK-project/core-framework/issues/43): **Yes**

	The platform is constructed in pure JavaScript, don't have any other frameworks dependencies;

-	[Service Framework **MUST** be Modular in nature](https://github.com/reTHINK-project/core-framework/issues/42): **Yes**

	The platform is complete modular, we can write our own modules or import third party modules.

-	[The Service Framework **MUST** be open source](https://github.com/reTHINK-project/core-framework/issues/39): **Yes**

	> “Meteor is a complete open source platform for building web and mobile apps in pure JavaScript.”

-	[Service Framework **SHOULD** be device agnostic](https://github.com/reTHINK-project/core-framework/issues/38): **Yes**

-	[Service Framework **MUST** be light weight and fast](https://github.com/reTHINK-project/core-framework/issues/37): **yes**

	Meteor is build on top of Node.js and MongoDB, and both are fast;

-	[Service Framework **SHOULD** support Model-View-Controller design pattern](https://github.com/reTHINK-project/core-framework/issues/36): **Yes/No**

	**No**, it isn't MVC pattern is more a MVM(Model-View-Mapper), but **Yes** we can have MVC, in other way:

	> "The MVC pattern in Meteor is dead simple. The Model is coded up in HTML, the Controller is coded in JavaScript, and the View is coded up in CSS. It's that simple."

	```
	Model          HTML         What Is Displayed
	View           CSS          How It Is Displayed
	Controller     JavaScript   When It Is Displayed
	```

repository: reTHINK-project/core-framework

repo_name: reTHINK-project/core-framework


text:
# Changelog

All notable changes to `laravel-enum` will be documented in this file.

Updates should follow the [Keep a CHANGELOG](http://keepachangelog.com/) principles.

## v1.2.0 - 2019-09-07

### Added
- Support for Laravel 6.

## v1.1.0 - 2019-06-09

### Added
- Option `--keys` to generate keys automatically.

## v1.0.0 - 2019-04-19

### Added
- Artisan command to generate enum classes.


text:
# Proxmox-Terraform-Ansible

This repo can be used to set up your own mini-cloud. The idea is to use dedicated infrastructure and install
our own virtualization engine, This engine can then be used in combination with Terraform and Ansible to
create an experience similar to just using any other cloud service provider.

# End goal:
Once the proxmox host and env has been setup correctly, a user can use terraform to create a series of VMs/containers
in any of the hosts and later use ansible to configure the VM.

# How to use this repo:
- Follow the numbered guides in order

license: Unlicense


text:
# BootPolish

[![Build Status](https://travis-ci.org/zephyr-dev/boot_polish.png)](https://travis-ci.org/zephyr-dev/boot_polish)

Boot time introspection to help you get under the heroku 60 second timeout.

## Installation

Add this line to your application's Gemfile:

    gem 'boot_polish'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install boot_polish

## Usage

Add the following line to your 'config/boot.rb' right after the require 'rubygems'

    require 'boot_polish'

I personally wrap it in a guard:

    if ENV["BENCHMARK_REQUIRES"] && ENV["BENCHMARK_REQUIRES"] == 'true'
      require 'boot_polish'
    end

During startup, you'll see all the requires and their associated times.
The default renderer is leaf-first, where the very deepest require is shown first,
with each subsequent outdentation showing the aggregate time for the require and
its children.

For example:

      0.0020 for require c/4
      0.0187 for require c/3
      0.0009 for require c/2
        0.0002 for require c/1/z
      0.0015 for require c/1
    0.0250 for require c
    0.0002 for require b
    0.0002 for require a

'a' and 'b' had no children requires
'c' required c/1 (which required c/1/z), c/2, c/3 and c/4

'c' had a time of 0.0250 which was a cumulative of it's time and all it's child requires.

## Todo

 * Make it possible to specify the renderer used by the require_benchmark
 * Introduce some basic network logging (on socket)
 * Introduce basic HTTP logging
 * Introduce a plugin architecture for testing specific hogs (fog, postgress, etc)


text:
# Exchange Rate Calculator

## Description

Exchange Rate Calculator is a front end micro project built with vanilla javascript and a 3rd party exchange rate API

## Screenshots

<img width="1243" alt="Screen Shot 2021-01-20 at 9 58 52 AM" src="https://user-images.githubusercontent.com/64296192/105215508-3611ce00-5b06-11eb-86df-1f76207f00b5.png">

## Table of Contents

* [Installation](#installation)
* [Usage](#usage)
* [Credits](#credits)
* [License](#license)

## Installation

N/A

## Usage

This application allows users to calculate exchange rates for a certain dollar value between different forms of currency.

## Credits

Brad Traversy

## License

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

## Contributing

N/A

## Questions

Contact me at the following for questions:

https://github.com/NickMardon

<EMAIL_ADDRESS>
## Tests

N/A

repository: NickMardon/Exchange-Rate-Calculator

repo_name: NickMardon/Exchange-Rate-Calculator


text:
helllo world with bazel
==============

This is sample java project build with bazel
For more detail information of bazel http://bazel.io/

# Install bazel

This project can be built with Bazel 0.1.1
See at http://bazel.io/docs/install.html

# Run

## debug mode
```
bazel run :runner
```

or

```
bazel run --define mode=debug :runner
```

## release mode
```
bazel run --define mode=release :runner
```

repository: tomorrowkey/hello-world-with-bazel

gha_language: Python

repo_name: tomorrowkey/hello-world-with-bazel


text:
## Cinder-AzureKinect

Cinder support for the Microsoft Azure Kinect. Supports:

- Multiple cameras
- Multiple bodies
- Merging tracked bodies
- Netowrked cameras via socket.io (temporarily disabled)
- Depth and color buffers
- Debug render views and ImGui interface
- Experimental: Gesture tracking such as hand waiving and pointing.

### Sample

Note that the sample currently lives in my mason repository due to dependencies there that I haven't yet taken care of.
You can find it [here](https://github.com/richardeakin/mason/tree/ck4a/test/AzureKinectTest).

![screenshot](doc/images/screenshot.png)

repository: redpaperheart/Cinder-AzureKinect

repo_name: redpaperheart/Cinder-AzureKinect


text:
# Query String Rule

```groovy

rule {
    //...
    params = [
            index: "logstash-*",
            queryString: "message:Error"
    ]

    reaction { messages -> // All messages that match the query
            // Your logic here
    }

}

```

You can find more about query string [here](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/query-dsl-query-string-query.html)

gha_language: Scala


text:
---
title: "Medifast Quest Nutrition High Protein Low Carb"
date: 2021-02-14T11:22:16+06:00
images:
  - "images/prod/medifast-Quest Nutrition.png"

# meta description
description : "Quest Nutrition High Protein Low Carb, Gluten Free, Keto Friendly, Peanut Butter Cups, 17.76 Ounce"

# product Price
price: "28.99"
discount_price: "24.99"

# product variation
colors : ["Peanut Butter"]
sizes : ["1.48 Ounce (Pack of 12)"]

draft: false
---

[Click Me To Buy From Our Amazon Store](https://amzn.to/2NqW6Tc)

|Item|Flavor|Brand|Size|Weight|Price|Check Amazon|
|----|------|------|------|------|-----|--------|
|High Protein|Peanut Butter Cups|Quest Nutritionm|Pack of 12|1.48 Ounce|$24.99|[Check Amazon Price](https://amzn.to/2NqW6Tc)|

Ingredients: WHEY PROTEIN ISOLATE, ERYTHITOL, UNSWEETENED CHOCOLATE, COCOA BUTTER, PEANUTS, PALM KERNEL OILM SOLUBLE CORN FIBER, SODIUM CASEINATE. CONTAINS LESS THAN 2% OF THE FOLLOWING: SUNFLOWER LECITHIN, SEA SALT, BUTTERFAT, NATURAL FLAVOR, PEANUT OIL, SUCRALOSE. CONTAINS: MILK, PEANUTS. PROCESSED IN A FACILITY THAT ALSO PROCESSES SOY, WHEAT, AND TREE NUTS..

About this item:

Quest Peanut Butter Cups are indulgent treats that satisfy your sweet tooth with less than 1g of sugar and 1g of net carbs per serving. The Quest Peanut Butter Cups are made with complete, dairy-based proteins to provide your body with 9 essential amino acids.


text:
# bc-prometheus-ruby - Drop-in Prometheus metrics

[![CircleCI](https://circleci.com/gh/bigcommerce/bc-prometheus-ruby.svg?style=svg&circle-token=fc3e2c4405a1f53a31e298f0ef981c2d0dfdee90)](https://circleci.com/gh/bigcommerce/bc-prometheus-ruby) [![Gem Version](https://badge.fury.io/rb/bc-prometheus-ruby.svg)](https://badge.fury.io/rb/bc-prometheus-ruby) [![Documentation](https://inch-ci.org/github/bigcommerce/bc-prometheus-ruby.svg?branch=main)](https://inch-ci.org/github/bigcommerce/bc-prometheus-ruby?branch=main) [![Maintainability](https://api.codeclimate.com/v1/badges/4a06277c738245e8bac1/maintainability)](https://codeclimate.com/github/bigcommerce/bc-prometheus-ruby/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/4a06277c738245e8bac1/test_coverage)](https://codeclimate.com/github/bigcommerce/bc-prometheus-ruby/test_coverage)

## Installation

```ruby
gem 'bc-prometheus-ruby'
```

Then in your `application.rb`, prior to extending `Rails::Application` or any initializers:

```ruby
require 'bigcommerce/prometheus'
```

You can then view your metrics at: http://<IP_ADDRESS>:9394/metrics

## Puma

For extra Puma metrics, add this to `config/puma.rb`:

```ruby
after_worker_fork do
  Rails.application.config.after_fork_callbacks.each(&:call)
end
```

## Resque

In your `task 'resque:setup'` rake task, do:

```ruby
require 'bigcommerce/prometheus'
Bigcommerce::Prometheus::Instrumentors::Resque.new(app: Rails.application).start
```

## Configuration

After requiring the main file, you can further configure with:

| Option | Description | Default | Environment Variable |
| ------ | ----------- | ------- | -------------------- |
| client_custom_labels | A hash of custom labels to send with each client request | `{}` | None |
| client_max_queue_size | The max amount of metrics to send before flushing | `10000` | `ENV['PROMETHEUS_CLIENT_MAX_QUEUE_SIZE']` |
| client_thread_sleep | How often to sleep the worker thread that manages the client buffer (seconds) | `0.5` | `ENV['PROMETHEUS_CLIENT_THREAD_SLEEP']` |
| puma_collection_frequency | How often to poll puma collection metrics (seconds) | `30` | `ENV['PROMETHEUS_PUMA_COLLECTION_FREQUENCY']` |
| server_host | The host to run the exporter on | `"<IP_ADDRESS>"` | `ENV['PROMETHEUS_SERVER_HOST']` |
| server_port | The port to run the exporter on | `9394` | `ENV['PROMETHEUS_SERVER_PORT']` |
| server_thread_pool_size | The number of threads used for the exporter server | `3` | `ENV['PROMETHEUS_SERVER_THREAD_POOL_SIZE']` |
| process_name | What the current process name is (used in logging) | `"unknown"` | `ENV['PROCESS']` |
| railtie_disabled | Opt out flag for Railtie; use `Bigcommerce::Prometheus::Instrumentors::Web.new(app: Rails.application).start` in your app's code to start it up yourself  | `0` | `ENV['PROMETHEUS_DISABLE_RAILTIE']` |

## Custom Collectors

To create custom metrics and collectors, simply create two files: a collector (the class that runs and collects metrics),
and the type collector, which runs on the threaded prometheus server and

### Type Collector

First, create a type collector. Note that the "type" of this will be the full name of the class, with `TypeCollector`
stripped. This is important later. Our example here will have a "type" of "app".

```ruby
class AppTypeCollector < ::Bigcommerce::Prometheus::TypeCollectors::Base
  def build_metrics
    {
      honks: PrometheusExporter::Metric::Counter.new('honks', 'Running counter of honks'),
      points: PrometheusExporter::Metric::Gauge.new('points', 'Current amount of points')
    }
  end

  def collect_metrics(data:, labels: {})
    metric(:points).observe(data.fetch('points', 0))
    metric(:honks).observe(1, labels) if data.fetch('honks', 0).to_i.positive?
  end
end
```

There are two important methods here: `build_metrics`, which registers the different metrics you want to measure, and
`collect_metrics`, which actually takes in the metrics and prepares them to be rendered so that Prometheus can scrape
them.

Note also in the example the different ways of observing Gauges vs Counters.

### Collector

Next, create a collector. Your "type" of the Collector must match the type collector above, so that bc-prometheus-ruby
knows how to map the metrics to the right TypeCollector. This is inferred from the class name. Here, it is "app":

```ruby
class AppCollector < ::Bigcommerce::Prometheus::Collectors::Base
  def honk!
    push(
      honks: 1,
      custom_labels: {
        volume: 'loud'
      }
    )
  end

  def collect(metrics)
    metrics[:points] = rand(1..100)
    metrics
  end
end
```

There are two types of metrics here: on-demand, and polled. Let's look at the first:

#### On-Demand Metrics

To issue an on-demand metric (usually a counter) that then automatically updates, in your application code, you would
then run:

```ruby
app_collector = AppCollector.new
app_collector.honk!
```

This will "push" the metrics to our `AppTypeCollector` instance, which will render them as:

```
# HELP ruby_honks Running counter of honks
# TYPE ruby_honks counter
ruby_honks{volume="loud"} 2
```

As you can see this will respect any custom labels we push in as well.

### Polling Metrics

Using our same AppCollector, if you note the `collect` method: this method will run on a 15 second polled basis
(the frequency of which is configurable in the initializer of the AppCollector). Here we're just spitting out random
points, so it'll look something like this:

```
# HELP ruby_points Current amount of points
# TYPE ruby_points gauge
ruby_points 42
```

### Registering Our Collectors

Each different type of integration will need to have the collectors passed into them, where appropriate. For example,
if we want these collectors to run on our web, resque, and hutch processes, we'll need to:

```ruby
::Bigcommerce::Prometheus.configure do |c|
  c.web_collectors = [AppCollector]
  c.web_type_collectors = [AppTypeCollector.new]
  c.resque_collectors = [AppCollector]
  c.resque_type_collectors = [AppTypeCollector.new]
  c.hutch_collectors = [AppCollector]
  c.hutch_type_collectors = [AppTypeCollector.new]
end
```

#### Custom Server Integrations

For custom integrations that initialize their own server, you'll need to pass your TypeCollector instance via the
`.add_type_collector` method on the prometheus server instance before starting it:

```ruby
server = ::Bigcommerce::Prometheus::Server.new
Bigcommerce::Prometheus.web_type_collectors.each do |tc|
  server.add_type_collector(tc)
end

# and for polling:

AppCollector.start
```

## License

Copyright (c) 2019-present, BigCommerce Pty. Ltd. All rights reserved

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.

 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.

repository: bigcommerce/bc-prometheus-ruby

gha_language: Ruby

repo_name: bigcommerce/bc-prometheus-ruby


text:
# Converter

A simple Unit Converter Angular app using the [convert-units](https://www.npmjs.com/package/convert-units) npm-module
Until now, length, mass and area conversions are possible.

## Development server

Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

## Build

Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.

repository: flwall/Unit-Converter

repo_name: flwall/Unit-Converter


text:
# Emacs Qt Creator Theme

[![MELPA](https://melpa.org/packages/qtcreator-theme-badge.svg)](https://melpa.org/#/qtcreator-theme)

An Emacs color theme that mimics the default theme of the Qt Creator IDE.

## Samples
### Emacs Lisp
![Screenshot for Emacs Lisp](https://raw.githubusercontent.com/LesleyLai/emacs-qtcreator-theme/master/screenshot-elisp.png "Screenshot for Emacs Lisp")

### [C++](https://isocpp.org/)
![Screenshot for C++](https://raw.githubusercontent.com/LesleyLai/emacs-qtcreator-theme/master/screenshot-cpp.png "Screenshot for C++")

### [Elm](https://elm-lang.org/)
![Screenshot for Elm](https://raw.githubusercontent.com/LesleyLai/emacs-qtcreator-theme/master/screenshot-elm.png "Screenshot for Elm")

repository: emacsmirror/qtcreator-theme

repo_name: emacsmirror/qtcreator-theme


text:
# Feast

**tl; dr;** A [combinator](https://combinator.ml) data component that installs [Feast](https://feast.dev), a feature store.

- [Introduction](#introduction)
- [Test Drive](#test-drive)
- [Usage](#usage)

## Introduction

[Feast](https://feast.dev) is an open-source feature store. A feature store allows you to manage, govern, and trace features derived from raw data. This is useful because it helps to unify and standardise, which reduces waste, improves quality, and makes models more reproducible.

Feast does not perform any computation. You can think of it as a meta-database; a database that manages other databases. It effectively creates a cache of feature data, keyed by time. The Feast libraries and CLIs provide a consistent way of pushing or streaming new data into the cache. Downstream systems use a similar interface to access point-in-time data. [Learn more about feast in the documentation.](https://docs.feast.dev)

## Test Drive

The fastest way to get started is to use the test drive functionality provided by [TestFaster](https://testfaster.ci). Click on the "Launch Test Drive" button below (opens a new window).

:computer: Launch Test Drive :computer:

### Launch Jupyter

Once the component has launched, click on the Jupyter link. Feast does not come with a UI. You will use Jupyter to interact with Feast via its API.

### Example Notebook

Once inside Jupyter, browse to the minimal notebook, which is the [official example](https://github.com/feast-dev/feast/tree/v0.9-branch/examples/minimal). Follow the instructions in the notebook.

## Usage

### Prerequisites

Start by preparing your Kubernetes cluster using one of the [infrastructure components](https://combinator.ml/infrastructure/introduction/) or use your own cluster.

### Component Usage

```terraform
module "feast" {
  source  = "combinator-ml/feast/k8s"
  # Optional settings go here
}
```

See the full configuration options below.

gha_language: HCL


text:
# Adjoint Optimization software for Lumerical from UC Berkeley

## Intro

This is a matlab implementation of a Continuous Adjoint Optimization method for Lumerical FDTD. This code was developped in the EECS department of UC Berkeley between 2008 and 2013 by sudents in Prof. Eli Yablonovitch's group. It is distributed under the MIT License.

Presentations of the code here:
http://optoelectronics.eecs.berkeley.edu/PhotonicInverseDesign/index.html

Graduate Students having worked on this code:
  - Owen Miller
  - Samarth Bhargava
  - Vidya Ganapati
  - Christopher Lalau-Keraly

## Some Resources

### Thesis:

 - Owen Miller: Photonic Design: From Fundamental Solar Cell Physics to Computational Inverse Design
    http://optoelectronics.eecs.berkeley.edu/ThesisOwenMiller.pdf
 - Samarth Bhargava: Heat-Assisted Magnetic Recording: Fundamental Limits to Inverse Electromagnetic Design
    http://optoelectronics.eecs.berkeley.edu/BhargavaDissertation.pdf
 - Vidya Ganapati: Optical Design Considerations for High Conversion Efficiency in Photovoltaics
    http://optoelectronics.eecs.berkeley.edu/GanapatiDissertation.pdf
 - Christopher Lalau-Keraly: Optimizing Nanophotonics: from Photoreceivers to Waveguides
    https://www2.eecs.berkeley.edu/Pubs/TechRpts/2017/EECS-2017-20.pdf

### Papers:

 - Adjoint shape optimization applied to electromagnetic design
    https://www.osapublishing.org/oe/abstract.cfm?uri=oe-21-18-21693
 - Shape optimization of nanophotonic devices using the adjoint method
    http://ieeexplore.ieee.org/document/6989970/

The examples provided have been tested and work with Matlab 2016a and Lumerical, on Mac OS High Sierra, and Red Hat 7. It should also work with Windows with a little tweaking.

 ## Installation

Optimization code download:
In a terminal, go to the folder where you would like to install and run:

`git clone https://github.com/chriskeraly/BerkeleyPhotonicInverseDesign.git`

Matlab and Lumerical must be installed.

The only tricky part in the installation is to get Lumerical and Matlab to talk to each other correctly. In particular, both Matlab and Lumerical need to be able to launch each other.

An AWS AMI will be provided very shortly, so that you can get the software working almost 'out of the box'.

### Lumerical --> Matlab

Follow these instructions: https://kb.lumerical.com/en/install_matlab_integration.html

For Mac it is a little tricky to find the executable. After a simple installation on High Sierra, it is here: `/Applications/Lumerical/FDTD Solutions/FDTD Solutions.app/Contents/MacOS`
For the Red Hat AWS AMI, if you follow the instructions given in the following section, it is here: `/usr/local/bin`

### Matlab --> Lumerical

In `Optimization_software/runOpt_params.m` you must tell matlab where your Lumerical FDTD executable is. In linux, typing `which fdtd-solutions` in a terminal should give you the path. For a normal Mac install: `/Applications/Lumerical/FDTD\ Solutions/FDTD\ Solutions.app/Contents/MacOS/fdtd-solutions`

## Start by running one of the example optimizations

Once you have set everything up correctly, open Matlab, go to `/Optimization_software` and run `runOpt.m`. A window should pop out, asking you to select a 'setupFile.m'. This is a matlab file containing all the information about the type of optimization we wish to run (Figure of Merit, Geometry representation, etc...).  Navigate to `/Optimization_software/examples/EZSiPh_compactsplitter` and choose `setup_EZSiPh_params.m`. Then you are asked to select a 'baseFile.fsp'. This is a Lumerical file which contains all the geometry information about your simulation. Navigate to `/Optimization_software/examples/EZSiPh_compactsplitter` and choose `base_compactsplitter.fsp`. Then, sit back and enjoy!

## More general optimizations

You need a setupFile and a Lumerical file. For the former, take a look at `/OptimizationSoftware/doc_setupTemplates.m` for what goes in there and what it means. (The merit function part is explained at `/Optimization_software/doc_meritFunction.pdf`.) The examples in the example folder all basically use the specific setupFile `/OptimizationSoftware/InverseDesignMethods/setup_EZSiPh.m`, which in turn pulls information from `/OptimizationSoftware/examples/(blah)/setup_EZSiPh_params.m` and from the applicable Lumerical simulation file via `/OptimizationSoftware/LumericalMethods/setup_EZSiPh.lsf`.

## AWS install (still work in progress)

In order to facilitate the setup and use of the software, an Amazon AMI machine is available. In a few steps, you can launch a powerfull machine on AWS with Lumerical and Matlab (almost...) pre-installed and preconfigured, which will be able to run these simulations for you. This is a good way to run optimizations, since you can simply get them started and then let them run without the need for your personal computer ot be always on.

### Launching and connecting to the AMI.

You will need an AWS account. Go to the EC2 dashboard and start a machine, in Oregon (this is where the AMI is stored). c4.large is a great starting point, but you can choose much bigger machines if you want. You will have to save the ssh key that is given to you in a safe location (.ssh/keys/ is a nice place), and change the access rights to it: `chmod 400 mykey.pem`. (All this info is given to you if you click `Connect` in the EC2 dashboard, although aws suggests using root, when you should really use ec2-user)

Once your machine is up, I strongly recommend setting up your ssh config file (located at ~/.ssh/config) and adding these lines to it (obviously replacing with the right values for your HostName and Identityfile)
```
Host BerkeleyOpt
	Hostname ec2-xxx-xxx-xxx-xxx.us-west-2.compute.amazonaws.com
	User ec2-user
	IdentityFile ~/.ssh/keys/mykey.pem
```

At this point check if your ssh access is working by typing `ssh BerkeleyOpt` in a terminal. If you connect: Congrats! You are in your new machine.

Now connect to it again using these commands instead: `ssh -v -C -L 5901:localhost:5901 BerkeleyOpt`. This will do port forwarding to your machine, so that you can use vnc. A vncserver should already be running on the machine, but if it doesnt, just type `vncserver` in your ssh session and that should boot it up.

Using your favorite VNC client, connect to localhost:5901. (In macOs, there is a native client called ScreenSharing, you can even just type localhost:5901 in the address bar of safari and that should boot it up for you). If you see your linux Desktop, you can go to the next step

### Finishing the installation of matlab and Lumerical

#### Matlab
While the installation files for matlab are on the AMI, it is not installed yet: start a terminal in your vnc session, and type `sudo matlab/matlab_R2016a_glnxa64/install`, then follow the instructions and activate matlab with an appropriate license.

#### Lumerical
Lumerical is pre-installed, but you must still get your license in. In a terminal, type `fdtd-solutions`, and then enter the correct license info for lumerical with your license server information. If you have a temporary license dedicated for this machine, then you can follow the instuctions here: https://kb.lumerical.com/en/install_linux_instructions_fdtd.html

WARNING: Do not install a fixed license on this machine!  You can start a small machine (t2.micro) with the same AMI, and create a license server there, although you will need to open a few ports in aws to make your licenses available to the outside world.

#### Clone the repo

The branch with the settings for the aws install is appropriatly named `aws`
```bash
cd
git clone https://github.com/chriskeraly/BerkeleyPhotonicInverseDesign.git
git checkout aws
```

At this point your machine should be all set, and you can run your first optimization!


text:
---
layout: project
type: project
image: images/Logo.jpg
title: Uhire
permalink: projects/uhire
# All dates must be YYYY-MM-DD format!
date: 2017-12-08
labels:
  - Uhire
  - Javascript
  - semantic-meteor-react
  - Intellij
summary: Group developed a working application that connects students and companies.
---
---

## Background
This program was created with the intention of linking students and companies together. The students are able to look for companies that they are interested in and apply for the positions that they are qualified for. The companies can look at the student profiles and contact the students if they are interested. The students are able to search for companies using interest tags as well as by company name, while the companies can search for students by last name and interest tags.

## Experience
I worked on the validation of the forms on our page as well as the student homepage and admin homepage. The student homepage was later combined with another page because the two pages seemed like they would go together. On my form validations I used different event handlers depending on what I wanted the event handler to do. By completing this project I learned different ways to use the event handlers as well as learn how to use the autoform validation. This was important to me because this was something that was not previously touched on in class and had to do some research about to apply it properly.

Here is an example of the form validation.
<img class="" src="/images/FinalSignUp.png">

Link to Uhire on Github: [Uhire](https://github.com/uhire)


text:
---
uid: Uno.Contributing.Wasm
---

# How Uno works on WebAssembly

This article explores WebAssembly-specific details of Uno's internals, with a focus on information that's useful for contributors to Uno. For an overview of how Uno works on all platforms, see [this article](uno-internals-overview.md).

## What is WebAssembly actually?

> [WebAssembly is a new type of code](https://developer.mozilla.org/en-US/docs/WebAssembly) that can be run in modern web browsers — it is a low-level assembly-like language with a compact binary format that runs with near-native performance and provides languages such as C/C++ and Rust with a compilation target so that they can run on the web. It is also designed to run alongside JavaScript, allowing both to work together.

WebAssembly (Wasm) allows .NET code, and hence Uno, to run in the browser. It's supported by all major browsers, including mobile browser versions.

Wasm in the browser runs in the same security sandbox as JavaScript does, and has exactly the same capabilities and constraints. Note that for now there's no means of accessing browser APIs, including the DOM, directly from Wasm (though this is [expected to become available in the future](https://github.com/WebAssembly/interface-types/blob/master/proposals/interface-types/Explainer.md)). All communication to and from the DOM must be done by interop with JavaScript.

## UIElements map to DOM elements

There is for the most part a 1:1 mapping between managed XAML elements and DOM elements. The element tag associated with a XAML type is set by a `UIElement` constructor overload which takes the tag as a string, with "div" as the default.

## Typescript layer

Part of Uno for WASM is defined in Typescript (which transpiles to JavaScript), since going through JavaScript is currently the only way to manipulate the DOM and access other browser APIs from WebAssembly. The TypeScript layer is located in the Uno.UI.Wasm project. The most important class here is `WindowManager.ts`.

## JavaScript interop in Uno

Calls into JavaScript from C# generally access methods in the `WindowManagerInterop` .NET class, which calls methods on the `WindowManager` TypeScript class using the `WebAssemblyRuntime.InvokeJS()` method.

Callbacks into C# from JavaScript can be defined using the `mono_bind_static_method` wrapper. C# methods that will be called from JavaScript must be added to the [LinkerDefinition](https://github.com/unoplatform/uno/blob/master/src/Uno.UI/LinkerDefinition.Wasm.xml) file.

repository: weiplanet/uno

repo_name: weiplanet/uno


text:
---
title: Uploading NFT images
subTitle: You can now upload images for your NFT collection in advance before minting.
authorName: searchableguy
publishDate: 23 Feburary, 2023
description: You can now upload images for for your NFT collection in advance before minting.
image: /images/blog/support-for-uploading-images/image_upload.png
---

![Metadata Editor](/images/blog/support-for-uploading-images/image_upload.png)

We're excited to announce support for uploading images in the metadata editor. This will make it easier for you to build rich NFT collections by uploading images in advance before minting. If you want to learn more about how to use the metadata editor, check out our earlier [post](https://unlock-protocol.com/blog/key-metadata-configurator).

For those who still want to host their image collection using services like Pinata, you can provide the image URL in the metadata editor.

repository: unlock-protocol/unlock

repo_name: unlock-protocol/unlock


text:
# Changelog

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

## [1.2.0](https://github.com/barretem/last-release-git-info-plugin/compare/v1.1.0...v1.2.0) (2021-07-06)

### Features

* 🎸 添加access ([6539e75](https://github.com/barretem/last-release-git-info-plugin/commit/6539e75f3cf5686eda6892bce5986ae4674cf227))
* 🎸 支持在构建的时候输出最新commit构建信息 ([4347767](https://github.com/barretem/last-release-git-info-plugin/commit/4347767da5895d579a754d3240d3ba95cd459a99))

## 1.1.0 (2021-07-03)

### Features

* 🎸 完成插件开发 ([330b0e1](https://github.com/barretem/last-release-git-info-plugin/commit/330b0e100571202511ad661be1b56fac078e679e))

repository: Barretem/last-release-git-info-plugin

repo_name: Barretem/last-release-git-info-plugin