text:
## ThroughSerial

**Medium:** Hardware or software serial port -
**Pins used:** 1 or 2 -
**Inclusion constant:** `PJON_INCLUDE_TS`

With `ThroughSerial` strategy, PJON can run through a software or hardware Serial port working out-of-the-box with many Arduino compatible serial transceivers, like RS485 or radio modules like HC-12 (HCMODU0054). Take a look at the [video introduction](https://www.youtube.com/watch?v=H4jUsgvM-lw) for a brief showcase of its features. It complies with [TSDL v2.1](/src/strategies/ThroughSerial/specification/TSDL-specification-v2.1.md).

### Why PJON over Serial?
Serial communication is fast and reliable but it is often useless without all the features PJON contains. `ThroughSerial` has been developed to enable PJON communication through a serial data link. Adding PJON on top of Serial it is possible to leverage of the PJON protocol layer features like acknowledge, addressing, multiplexing, packet handling, 8 or 32-bit CRC and traffic control.

Being impossible to detect or avoid collisions over a serial port, `ThroughSerial` has been developed primarily to be used in master-slave mode. `ThroughSerial` in multi-master mode, being unable to detect or avoid collisions, operates using the slotted ALOHA medium access method. Of all contention based random multiple access methods, slotted ALOHA, which maximum data throughput is only 36.8% of the available bandwidth, is one of the least efficient and should not be applied in networks where many devices often need to arbitrarily transmit data.

### Configuration
Before including `PJON.h` it is possible to configure `ThroughSerial` using predefined constants:

| Constant                | Purpose                             | Supported value                            |
| ----------------------- |------------------------------------ | ------------------------------------------ |
| `TS_BYTE_TIME_OUT`      | Maximum byte response time-out      | Duration in microseconds (50000 by default) |
| `TS_RESPONSE_TIME_OUT`  | Maximum response time-out           | Duration in microseconds (10000 by default) |
| `TS_BACK_OFF_DEGREE`  | Maximum back-off exponential degree | Numeric value (4 by default)               |
| `TS_MAX_ATTEMPTS`     | Maximum transmission attempts       | Numeric value (20 by default)              |

Pass the `ThroughSerial` type as PJON template parameter to instantiate a PJON object ready to communicate through this Strategy.
```cpp
PJON<ThroughSerial> bus;
```
Call the `begin` method on the `Serial` or `SoftwareSerial`  object you want to use for PJON communication and pass it to the `set_serial` method:
```cpp
#include <PJON.h>

PJON<ThroughSerial> bus;

void setup() {
  Serial.begin(9600);
  bus.strategy.set_serial(&Serial);
}
```
For a simple use with RS485 serial modules a transmission enable pin setter has been added:
```cpp
bus.strategy.set_enable_RS485_pin(11);
```
If separate enable setters are needed use:
```cpp
// Set RS485 reception enable pin
bus.strategy.set_RS485_rxe_pin(11);
// Set RS485 transmission enable pin
bus.strategy.set_RS485_txe_pin(12);
```
In some cases it may be required to add a delay before disabling the RS485 pins txe and or rxe:
```cpp
// Set RS485 txe/rxe pins disable delay in milliseconds
bus.strategy.set_RS485_delay(1);
```

If you need to interface devices using RS485 see the [RS485-Blink](../../../examples/ARDUINO/Local/ThroughSerial/RS485-Blink) example.

HC-12 wireless module supports the synchronous acknowledgement, see [HC-12-Blink](../../../examples/ARDUINO/Local/ThroughSerial/HC-12-Blink), [HC-12-SendAndReceive](../../../examples/ARDUINO/Local/ThroughSerial/HC-12-SendAndReceive) and [HC-12-LocalChat](../../../examples/ARDUINO/Local/ThroughSerial/HC-12-LocalChat) examples.

All the other necessary information is present in the general [Documentation](/documentation).

### Known issues
- Being PJON not an interrupt driven, its communication can be affected and potentially disrupted by long delays added in the user's sketch. Try to reduce as possible the interval between every `receive` call.

### Safety warning
In all cases, when installing or maintaining a PJON network, extreme care must be taken to avoid any danger. Before any practical test or hardware purchase for a wireless [ThroughSerial](/src/strategies/ThroughSerial) radio setup, compliance with government requirements and regulations must be ensured.


text:
---
---
# JSX

JSX is a proprietary extension to the JavaScript/TypeScript syntax that allows mixing code with XML-like declarations. Tabris 3 supports JSX out of the box in `.jsx` and `.tsx` files with any TypeScript compiler based projects. The only requirement is that in `tsconfig.json` the
`jsx` property is set to `"react"` and `jsxFactory` to `"JSX.createElement"`.

## Usage

In Tabris, JSX is used to create UI elements in a declarative manner. Every constructor for a Widget, WidgetCollection or Popup based class can be used as an JSX element. (As of 3.0-beta1 only the ActionSheet popup supports JSX. This will change in the final release.)

Action | JavaScript/TypeScript | JSX
---|---|---
Create an instance|`new TextView()`|`<TextView />`
Set a string property*|`new TextView({text: 'foo'})`|`<TextView text='foo' />`
Set non-string property*|`new TextView({elevation: 3})`|`<TextView elevation={3} />`
Set property to true|`new TextView({markupEnabled: true})`|`<TextView markupEnabled />`
Register listener|`new TextView().onResize(cb)`|`<TextView onResize={cb} />`
Set properties object|`new TextView(props)`|`<TextView {...props} />`
Mix in properties object|`new TextView({text: 'foo', ...props})`|`<TextView text='foo' {...props} />`
Add new children|`new Composite().append(new TextView())`|`<Composite><TextView /></Composite>`
Add existing children|`new Composite().append(children)`|`<Composite>{children}</Composite>`

\* Some properties can also be set by putting the value between the opening and closing tag, like children. For `<TextView>foo</TextView>` sets the `text` property to `'foo'`. Properties that support this are marked as such in the API reference.

> :warning: In TypeScript JSX expressions themselves are type-safe, but their return type is `any`! So be extra careful when you assign them to a variable to give it the proper type.

To add multiple children to an existing parent you group them using `WidgetCollection`:

```jsx
// JavaScript/TypeScript:
contentView.append(
  new Button(),
  new TextView()
);

// JSX:
contentView.append(
  <WidgetCollection>
    <Button />
    <TextView />
  </WidgetCollection>
);
```

This is not necessary inside JSX elements:

```xml
<Composite>
  <Button />
  <TextView />
</Composite>
```

## Custom JSX Elements

JSX becomes a lot more powerful when creating your own elements. There are two ways to do this.

### Stateless Functional Components

A "stateless function component" (SFC) is essentially a factory that can be used as an JSX element. This can be any function that fits the following pattern:

* Name starts with an upper case.
* Returns a JSX supported value, e.g. a widget or array of widgets.
* Takes a plain object as the first parameter. (This represents the attributes.)
* Takes am array as the second parameter. (This represents the child elements.)

A SFC that initializes an existing widget with new default values could look like this:

```jsx
const StyledText = properties => <TextView textColor='red' {...properties} />;

// example usage:
contentView.append(<StyledText>Hello World!</StyledText>);
```

In TypeScript you need to give the proper type of the properties object and children:

```tsx
const StyledText = (properties: TextView['jsxProperties']) =>
  <TextView textColor='red' {...properties} />;
```

> :point-right: `TextView['jsxProperties']` resolves to the attributes supported by `TextView`. Explained in the next section.

### Custom Components

Any custom component (a user-defined class extending a built-in widget) can be used as a JSX element right away. The only requirement is that the constructor takes the properties object and passes it on to the base class in a `super()` call. All attributes are interpreted as either a property or a listener as you would expect.

**However, in TypeScript an extra step is needed.**

All classes that can be used as JSX elements have a special (TypeScript-only) property called `jsxProperties`. The *type* of this property defines what attributes are accepted. The assigned value is irrelevant. It should be an interface that includes some or all properties and event listeners supported by the class. All members should be marked as optional (using a `?` after the name), unless you want the attribute to be mandatory.

You can do this by manually extending the `jsxProperties` type of the base class:

```ts
class CustomComponent extends Composite {

  public jsxProperties: Composite['jsxProperties'] & {
    foo?: number;
    onMyEvent?: Listeners;
  };

  // ... constructor, members, etc...

}
```

This is a bit cumbersome and error prone, which is why there is a helper interface called `JSXProperties` that you can import from the `'tabris'` module. It's exact type is...

```ts
JSXProperties<T, U extends keyof T>
```

... where `T` is your own class, and `U` is a union of the attributes you want to support. Using this interface the above example can be written like this:

```ts
class CustomComponent extends Composite {

  public jsxProperties: Composite['jsxProperties'] & JSXProperties<CustomComponent, 'foo' | 'onMyEvent'>;

}
```

repository: Ruskanda/tabris-js

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: Ruskanda/tabris-js


text:
# Metric Selector Cheat Sheet
This example-oriented document will teach you techniques with metric selectors that will enable you to implement advanced use cases quickly.

## Add the pretty entity name to the result

If you query a metric, you'll get only the id of the entity dimensions in the result like `"HOST-0123456789ABCDEF"`. Using the [`names` transformation](https://www.dynatrace.com/support/help/shortlink/api-metrics-v2-selector#names), you can add the pretty name of the entity in your result:
```
builtin:host.cpu.user:names
```
The query result will then contain `dt.entity.host` and the `dt.entity.host.name` dimensions.

## Remove single values from the result
Let's say you want to keep only the timeslots with a value greater than zero. You can use the [`partition` transformation](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v2/metric-selector#partition) for that:
```
my_metric
    :partition(
        "status",
            value("keep", gt(0))
    )
    :merge("status")
```
The partition operator discards all timeslots not matching its conditions. Afterward, we remove the dimension `status` added in the partitioning step using the [`merge` transformation](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v2/metric-selector#merge).

## Filter series based on their time-aggregated value
Whereas you can use the `partition` transformation to filter single values, you can sift the whole series using the `series` condition of the `filter` transformation. For example, if you want to get only the series that were available over zero percent in the query timeframe, you can use the following query:
```
builtin:pgi.availability
    :filter(
        series(max,gt(0))
    )
```
To get more insights about the difference between the partition transformation and the series condition, see https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v2/metric-selector#conditions.

## Filter dimension values
Consider you have the following values for the dimension `url` of your metric `web_requests`:
- app.dynatrace.co.jp
- app.dynatrace.com
- www.dynatrace.com
- app.dynatrace.de

If you want to include only URLS starting with `app.` and filter out all URLs ending with `.co.jp`, you can use the following query:
```
web_requests
    :filter(
        and(
            prefix(url, "app."),
            not(
                suffix(url, ".co.jp")
            )
        )
    )
```
The `url` dimensions returned for this query are "app.dynatrace.com" and "app.dynatrace.de". To get all dimensions, you can leverage the `contains` condition:
```
web_requests
    :filter(
        contains(url, ".dynatrace.")
    )
```

### Entity dimension name filtering

You can use the embedded [entity selector](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/entity-v2/entity-selector) to filter `dt.entity.*` dimensions. For example,
```
builtin:host.cpu.user
    :filter(
        in("dt.entity.host",
            entitySelector("type(~"HOST~"),not(entityName.startsWith(~"dc1~"))")
        )
    )
```
returns only host entities with names that don't start with "dc1".

## Get the number of distinct dimension values
As no out-of-the-box metric gives you the number of hosts, you can use
```
builtin:host.cpu.user
    :splitBy("dt.entity.host")
    :auto
    :splitBy()
    :count
```
to figure out the number of hosts.
Similarly, you can get the number of distinct disks by the following query:
```
builtin:host.disk.avail
    :splitBy("dt.entity.disk")
    :auto
    :splitBy()
    :count
```

The approach is always:
1. Reduce the dimensions by `splitBy(<dimension>)`, so only the dimension for which you want to count the distinct values remains
1. Extract a single value for each series and timeslot using `auto`
1. Merge all dimensions using `splitBy()`
1. call the `count` aggregation

To get the total value of distinct values for the query timeframe, insert a `:fold` after the first step. For example:
```
builtin:host.cpu.user
    :splitBy("dt.entity.host")
    :fold
    :auto
    :splitBy()
    :count
```

## Calculating percentages
The query
```
builtin:service.response.time
    :avg
    :partition("latency",value("good",lt(10000)))
    :splitBy()
    :count
    :default(0)
/
builtin:service.response.time
    :avg
    :splitBy()
    :count
* 100
```
returns the percentage of the series that had an average response time over 10,000 microseconds for a timeslot. This number is not equal to the percentage of requests with a response time of over 10k microseconds as the metric data is aggregated to 1-minute buckets. To get the exact percentage of requests running longer than 10k microseconds, you'd need to create a [Calculated service metric](https://www.dynatrace.com/support/help/platform-modules/applications-and-microservices/services/service-monitoring-settings/calculated-service-metric) that only captures requests matching this criterion and use it as the dividend in the metric expression.

## Enforce a default value
Consider you have the metric `number_errors` that is only incremented when an error occurs. To fill up the empty timeslots with zeros even if there were no booking in the whole query timeframe, use [`default(0,always)`](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v2/metric-selector#default):
```
number_errors:
    :splitBy()
    :sum
    :default(0,always)
```

## Non-matching dimensions in a metric expression

For instance, when determining the store's revenue percentage within a city relative to the entire country's revenue, we can use the following expression:
```
revenue_city
    :filter("city", "Berlin")
    :splitBy("city")
/
revenue_country
    :filter("country", "Germany")
    :splitBy()
* 100
```
It is essential to use `splitBy()` without any dimension key for the `revenue_country` metric. Without this, the series can't be properly joined. For a successful metric merge in a metric expression, the dimension tuples of both metrics must be identical, or at least one of the metrics needs to be dimensionless. See the [public documentation for details](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v2/metric-expressions#resolving-expressions).

## Add the parent dimension to the result
For some entity dimensions like `PROCESS_GROUP_INSTANCE` and `SERVICE_METHOD`, you can enrich the result with the "parent" of these dimensions. For example, the metric `builtin:tech.generic.processCount` per default only provides the `dt.entity.process_group_instance` dimension. To get also the host dimension in the result, use the query:
```
builtin:tech.generic.processCount:parents
```
Moreover, you can combine the `names` and the `parents` transformations.
```
builtin:tech.generic.processCount:parents:names
```
will return both the `PROCESS_GROUP_INSTANCE` and `HOST` dimensions and the pretty names for both.

## Add further dimensions to the result
Besides enriching the metric dimensionality with the display name and the pre-configured parent of the entity dimensions, adding additional dimensions using the [`partition` transformation](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v2/metric-selector#partition) is possible. For example:
```
builtin:service.response.time
    :avg
    :partition(
        "latency",
            value("slow", gt(10000)),
            value("good", otherwise)
    )
```
Adds the dimension "latency" to the series of the result. The dimension value depends on the response time. Data points greater than 10,000 microseconds are categorized as slow and the others as good.

### Map dimensions to another one
If you want to add a new dimension based on existing dimensions, you can also use the `partition` transformation. For example, consider a metric with the HTTP status code as its dimension, and you want to map all requests to "success" unless their status code begins with 4 or 5 (that is, they have 400 or 500 as their status code).
You can achieve that by the following query:
```
http_request
    :partition("status",
        dimension("success", and(not(prefix("status_code", "4")), not(prefix("status_code", "5")))),
        otherwise("error"))
    :splitBy("status")
```

Using the metric selector query language, there is no further way to enrich the series dimensionality. You'd need to leverage the [DQL](https://www.dynatrace.com/support/help/platform/grail/dynatrace-query-language) for more advanced use cases.

repository: Dynatrace/dynatrace-api

gha_language: Python

repo_name: Dynatrace/dynatrace-api


text:
# MQTT Occupancy Estimator
By combining multiple AXIS People Counters to accumulate people walking in and out an estimation of home occupancy can be made. Using knowledge such as movement (from PIR detectors), interaction with home electronics and locking/unlocking of doors the estimation can be improved.

## Currently supported:

* Accumulate MQTT events from one or more cameras to get occupancy estimation
* Reset occupancy estimation (in database and AXIS Occupancy Estimators) using an MQTT command

## Todo:
* Implement more sensors and logic
* Clean up settings
* Move passwords to a network vault
* Kill all threads if mqtt-thread segfault, needed to trigger restart of service

# Installation
* Move the occupancy.service file to /etc/systemd/system
* Make sure the path in occupancy.service correspons to your python module's path
* Reload and start service:
```bash
sudo systemctl daemon-reload
sudo systemctl start occupancy.service
sudo systemctl enable occupancy.service
```
* Show log:
```bash
sudo journalctl -u occupancy -f
```

license: MIT

repository: daniel-falk/python-mqtt-occupancy

repo_name: daniel-falk/python-mqtt-occupancy


text:
# CoffeeHouse-AndroidApp

**Coffee House** is single screen app that displays information about a fictional small business, which includes
"Description of the Business", "Avaliable Menu", "Contact information", " Location Address" and "Hours of operation".

## Topics Explored
#### XML

 Transforming designs into layouts using LinearLayout(vertical) and LinearLayout(horizantal) ViewGroups.

 Usage of ScrollView, TextView, ImageView

 JAVA

 Switch Case uses in java

 How to find views in java and set onClick to views

## Screenshots of App
   |    |

## License
License under the MIT License

repository: manjirikolte/CoffeeHouse-AndroidApp

repo_name: manjirikolte/CoffeeHouse-AndroidApp


text:
# EAGLE CAD artwork panelizer

## What is this?

* This is simple tool for panelize EAGLE CAD artwork.
* [Motivates from this tweets](https://twitter.com/kekyo2/status/852850454740353024) "Specify X, Y on the EAGLE just make faces with Gerber in 1 shot."

## Download binary

* [Released 1.2 (for .NET 4.5 binary)](https://github.com/kekyo/EaglePanelizer/releases/download/1.2/EaglePanelizer-1.2.zip)

## Example

* Original artwork (*.brd file)

![Original artwork](OriginalArtwork.png)

* Apply this tool then:

![Panelized artwork](PanelizedArtwork.png)

## How to use

* You can see the help without some arguments:
  * Width and height units are milli-meter.

```shell
D:\PROJECT\EAGLE\BrainPadWiFi>EaglePanelizer.exe --help
EaglePanelizer - EAGLE CAD artwork panelizer 1.2
Copyright (c) 2017-2018 Kouji Matsui (@kozy_kekyo)

usage: EaglePanelizer [--dimension-layer=<value>] [--help] [--line-width=<value>] [--vcut-indicator] [--vcut-layer=<value>] [--vcut-post-length=<value>] <target-width> <target-height> <from-path> <panelized-path>
 -d, --dimension-layer=<value>  Force set layer number for dimension (contour)
 -h, --help                     Show this help
     --line-width=<value>       Dimension contour and V-Cut line width
 -i, --vcut-indicator           Draw 'V-Cut' indicator
 -v, --vcut-layer=<value>       Force set layer number for V-Cut lines
 -p, --vcut-post-length=<value> V-Cut line post length
```

* Example: With draw V-Cut indicator.

```shell
D:\PROJECT\EAGLE\BrainPadWiFi>EaglePanelizer.exe --vcut-indicator 100 100 BrainPadWiFi.brd panelized.brd
EaglePanelizer - EAGLE CAD artwork panelizer 1.2
Copyright (c) 2017-2018 Kouji Matsui (@kozy_kekyo)

Original board: Size=(25.908, 26.289), (0, 0) - (25.908, 26.289)
Dup[1]: (25.908, 0)
Dup[2]: (51.816, 0)
Dup[3]: (0, 26.289)
Dup[4]: (25.908, 26.289)
Dup[5]: (51.816, 26.289)
Dup[6]: (0, 52.578)
Dup[7]: (25.908, 52.578)
Dup[8]: (51.816, 52.578)
Totally panelized: Count=9, Size=(77.724, 78.867), (0, 0) - (77.724, 78.867)
```

* And got result:

![Example artwork](ExampleArtwork.png)

## License

* Source code copyright (c) 2017-2018 Kouji Matsui (@kozy_kekyo)
* Under Apache v2 http://www.apache.org/licenses/LICENSE-2.0

## History

* 1.2:
  * Separated contour lines and V-Cut lines.
  * Draw V-Cut indicator.
  * Support complex command-line arguments.
* 1.1:
  * Calculate contour with package's.
  * Added usage help.
  * Support .NET Core 2.0.
  * Upgraded to MSBuild 2.0.
* 1.0:
  * First public release.

repository: bubdm/EaglePanelizer

repo_name: bubdm/EaglePanelizer


text:
# Change Log

## v0.4.0

 - Update docs to use Jekyll for SCSS compiling
 - Remove `dist` directory
 - Allow hot key to be disabled by allowing the hot key to be set to null

## v0.3.0

Backwards breaking changes and steps for migrating to v0.3.0:
 - Make tracking recently used selections as easy as setting a config value
     1. Add `trackChildrenAs` property to root element or parent search item
     2. Remove calls to `tracker().sort()` and `selected.trackAs()`—these calls are now handled automatically
 - Switch style sheets source to use SCSS and add CSS dist file to build process
     1. Copy the CSS file from quick-switcher.tar.gz instead of referencing the `src` (also, keep in mind that the committed `dist` directory may go away soon)
 - Remove unused `isFuzzyMatch` function
     1. Rely on your own fuzzy-match method instead :) Feel free to copy `isFuzzyMatch` logic from the quick-switcher git history

Other changes:
 - Add distribution tarball with compiled JS & CSS assets to GitHub releases
 - Use `yarn` to lock dependency versions

## v0.2.0

 - Fix selected item's lack of highlight
 - Reset scroll to 0 when changing search callbacks
 - Re-focus search input after changing search callbacks
 - Make quick-switcher mobile friendly
 - Make it possible to manually trigger the opening of the quick switcher
 - Allow statically sorted items, bypassing tracker
 - Rename result description CSS class

## v0.1.0

 - Limit hotkey to be platform-specific (Cmd only on Mac, Ctrl on other platforms)
 - Add ability to track selection frequency of items
 - Add callback for selection of child-search items
 - Use almond to load dependencies and minify
 - Rename `subtext` to `description`
   - `description` is now treated as text by default
   - Use an object with an `html` property as the `description` value to treat
     the description as HTML
 - Fix undefined index during result processing
 - Use .text and .html as functions when relevant
 - Fix flash of "No results found" message
 - Move all callbacks to settings object

repository: lightster/quick-switcher

gha_language: JavaScript

gha_license_id: MIT

repo_name: lightster/quick-switcher


text:
# LK-SEC-2023-1

## Timeline
- 2022-12-01 [CVE-2022-1471][cve] is discovered in SnakeYAML
- 2022-03-27 A customer inquires Linkurious about the impact of [CVE-2022-1471][cve] in Linkurious Enterprise
- 2022-04-06 Linkurious discloses this document

## Description
Vulnerability in a dependency of Elasticsearch.
[Elasticsearch did not disclose any vulnerability nor patch][disclosure].

## Impact
If an administrator of Linkurious Enterprise crafts a malicious YAML configuration file for the embedded Elastisearch instance,
they might be able to execute arbitrary code on the server.
This requires direct access to the filesystem of the server on which Linkurious Enterprise is installed, as well as file-edit
permissions on the Elasticsearch configuration files.

## Severity: low
- CVSS v3.1 score: `2.5` (see [score details][score]).
- No patch is necessary.

## Who is affected?
All versions of Linkurious Enterprise except Docker builds (which do not contain Elasticsearch at all).

## How can it be patched?
- There is not patch necessary, as the vulnerability requires high system privileges to be exploited
- Docker builds of Linkurious Enterprise can be used in case of compliance necessity, since they do not contain Elasticsearch and its dependencies
- The embedded Elasticsearch server can be disabled or non-Docker builds of Linkurious Enterprise:
  - In version prior to Linkurious Enterprise 4.0.4: by not configuring any data-source with the embedded Elasticsearcg and restarting Linkurious Enterprise
  - In Linkurious Enterprise 4.0.4 and later: by stopping Linkurious Enterprise and setting `disabled: true` on the `Embedded Elasticsearch` entry in `data/manager/manager.json`, then restarting Linkurious Enterprise.

[score]: https://nvd.nist.gov/vuln-metrics/cvss/v3-calculator?vector=AV:L/AC:H/PR:H/UI:R/S:U/C:N/I:N/A:H/E:U/RL:O/RC:C/CR:H/IR:M/AR:M/MAV:L/MAC:H/MPR:H/MUI:R/MS:U/MC:N/MI:N/MA:H&version=3.1
[changelog-30]: https://doc.linkurio.us/admin-manual/3.0/release-notes/
[cve]: https://nvd.nist.gov/vuln/detail/CVE-2022-1471
[disclosure]: https://discuss.elastic.co/t/snakeyaml-vulnerability-cve-2022-1471-on-latest-es-version/327854

repository: Linkurious/documentation-resources

repo_name: Linkurious/documentation-resources


text:
---
date: 2020-06-15T15:13:44.214Z
title: Nikita Prokopov on Syncthing
draft: false
tags:
  - OSS
path: post-1592234019067
---
Nikita Prokopov sharing [his experience](https://tonsky.me/blog/syncthing/) using a free and open-source alternative to Dropbox called [Syncthing](https://syncthing.net).

> Syncthing is everything I used to love about computers.  Frankly, I almost ceased to believe it’s still possible. But it is.

It is indeed heartwarming to see products like these still exist.[^1] I gave up on Dropbox long ago, and I have the same iCloud issues Nikita outlined. I am very happy to jump ship after reading this glowing review.

[^1]: Bonus points for being made in Sweden under a non-profit!

branch_name: refs/heads/main


text:
# Lycopersicon esculentum var. racemigerum (Lange) Brezhnev VARIETY

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Zhukovskii, Kul't. Fl. SSSR 20:65. 1958

#### Original name
null

### Remarks
null

repository: mdoering/backbone

path: /life/Plantae/Magnoliophyta/Magnoliopsida/Solanales/Solanaceae/Solanum/Solanum pimpinellifolium/ Syn. Lycopersicon esculentum racemigerum/README.md

repo_name: mdoering/backbone


text:
---
schema: pacelf
title: Aedes albopictus in the Solomon and Santa Cruz Islands,South Pacific
organization: Elliott, S.A.
notes: Surveys of mosquitoes in the South Pacific up until 1977 have shown the presence of Aedes albopictus only as far east as Papua New Guinea. During the visit to the Solomon Islands in 1978 to collect members of the Aedes (Stegomyia) scutellaris complex, Ae. albopictus was found in large numbers on Guadalcanal and was also present in the Santa Cruz Islands. This species has been incriminated as a vector of dengue haemorrhagic fever.
access: Restricted

resources:
- name: Aedes albopictus in the Solomon and Santa Cruz Islands,South Pacific
  url: 'N/A'
  format: Hardcopy
  access: Restricted
  pages: 747-748

category: Scientific Papers
access: Restricted
journal: Transactions of the Royal Society of Tropical Medicine and Hygiene
publisher: N/A
language: English
hardcopy_location: JCU WHOCC Ichimori collection
work_location: Solomon Islands
year: 1980
decade: 1980
PacELF_ID: 2220
---

repository: DanielBaird/jkan

repo_name: DanielBaird/jkan


text:
# Roadmap

The current goal is to release a stable 1.0.0 version by the end of February. Details below.

## January 2022

- finish multi-store functionality [done]
- performance improvements
  - analysis [done]
  - improve the speed of communication with Magento [in progress]
    - Redis Caching [done]
    - CDNs [done]
- Design QA & improvements [done]

## February 2022

- performance improvements
  - meet web core vitals or at least 80 score
- quality assurance
- user acceptance tests

### Milestone: Release stable 1.0.0 version by the end of February

## March 2022

- Load tests
- Accessibility tests & improvements
- extensibility
  - improve docs
  - add the possibility to add plugins
  - add the possibility to install external extensions
  - theming


text:
# GIR DTS Generator (WIP)

This repository contains a CLI tool that uses [node-gir](https://github.com/Place1/node-gir)
to build TypeScript declaration files for GObject annotated libraries.

This project is a WIP. The goal is to provide automatic type declaration files for projects
consuming GObject libraries through [node-gir](https://github.com/Place1/node-gir).

## Usage
```
npm install -g gir-dts-generator
gir-dts-generator --help
```
```
Usage: gir-dts-generator [options] <libraryName> [libraryVersion]

Options:

  -V, --version        output the version number
  -o, --output <path>  A file to write the output to. Defaults to stdout
  -h, --help           output usage information
```

## In Code
_not sure yet_

## Roadmap
* Add support for types that are used from other GObject libraries
  - Currently the declaration files are broken for most libs because
    classes that extend, or functions that use types from another library
    will reference undefined symbols. These symbols will have to be resolved
    and added as extra namespaces in the output declaration file.
* Determine how generated declaration files should be used in code
  - currently the generated declaration file just exports a namespace
    but you can't use a namespace as a type. i.e. the following isn's legal
    typescript: `const GtkLib = load('Gtk', '3.0') as Gtk` where `Gtk`
    is the ambient namespace exported by the generated .d.ts
* Determine the best way to integrate directly with `node-gir`
  - ideally, typescript users consuming `node-gir` should automatically
    get types namespace objects when they `load('library')`. `node-gir`
    could probably be a consumer of this tool and use this feature
    https://github.com/Place1/node-gir/issues/8 to automatically type
    popular libraries.
* Potentially add a flag `--gjs-compat`
  - this flag would make the tool output GJS compatible declarations.
    `node-gir` follow's NodeJS's camelCase naming conventions where
    as GJS uses snake_case.


text:
---
type: rule
archivedreason:
title: Do you make your "title", "h1", and "h2" tags descriptive?
guid: 1ada1535-56a2-47c2-839d-1a671fe61cb2
uri: make-title-h1-and-h2-tags-descriptive
created: 2015-11-09T18:48:50.0000000Z
authors:
- title: Adam Cogan
  url: https://ssw.com.au/people/adam-cogan
- title: Tiago Araujo
  url: https://ssw.com.au/people/tiago-araujo
related: []
redirects:
- do-you-make-your-title-h1-and-h2-tags-descriptive

---

The  **<title>** ,  **<h1>** , and  **<h2>** tags need to be descriptive. They should briefly describe the purpose or content of the page. Have a look at the following two images. The first image is a bad example as the title bar and page heading are not very descriptive. The second image is a better example as title bar and page heading are more informative.

<!--endintro-->

::: bad
![Figure: Bad Example - non-descriptive title/headings](bad-title-headings.png)
:::

::: good
![Figure: Good Example - descriptive title/headings](good-title-headings.png)
:::

We have a program called     [SSW Code Auditor](http://codeauditor.com/) to check for this rule.

We have a program called     [SSW Link Auditor](https://sswlinkauditor.com/) to check for this rule.


text:
[![docker pulls](https://img.shields.io/docker/pulls/jupyter/octave-notebook.svg)](https://hub.docker.com/r/jupyter/octave-notebook/)
[![docker stars](https://img.shields.io/docker/stars/jupyter/octave-notebook.svg)](https://hub.docker.com/r/jupyter/octave-notebook/)
[![image metadata](https://images.microbadger.com/badges/image/jupyter/octave-notebook.svg)](https://microbadger.com/images/jupyter/octave-notebook "jupyter/octave-notebook image metadata")

# Jupyter Notebook Octave Stack

GitHub Actions in the https://github.com/jupyter/docker-stacks project builds and pushes this image
to Docker Hub.

Please visit the project documentation site for help using and contributing to this image and
others.

- [Jupyter Docker Stacks on ReadTheDocs](http://jupyter-docker-stacks.readthedocs.io/en/latest/index.html)
- [Selecting an Image :: Core Stacks :: jupyter/octave-notebook](http://jupyter-docker-stacks.readthedocs.io/en/latest/using/selecting.html#jupyter-octave-notebook)

repository: expelledboy/docker-stacks

gha_license_id: NOASSERTION

repo_name: expelledboy/docker-stacks


text:
---
title: Oat++ ORM
description: About Oat++ object-relational mapping (ORM) framework.
sidebarDepth: 2
---

# Object-Relational Mapping (ORM) Framework <seo/>

:::tip
Have got any questions - ask them in the [Devs Chat on Gitter](https://gitter.im/oatpp-framework/Lobby)
:::

Oat++ ORM framework is a set of generalized interfaces and their implementations to make it easy to work with databases.

It's based on an [object-mapping framework](/docs/components/dto/) and ensures data consistency when manipulating with data.
Also, it integrates perfectly with other Oat++ components ensuring seamless data-flow in the application
(example: from REST to database, from the database to REST).

[[toc]]

## High-Level Overview

### Declare DbClient

The main component you are going to work with is the [DbClient](/api/latest/oatpp/orm/DbClient/).
You may treat it as the main point interfacing with your data. Here you declare database queries and manage database schema migrations.

Database queries are declared with the help of code-gen macros.
DbClient code generation section must begin with
`#include OATPP_CODEGEN_BEGIN(DbClient)` and must be closed with
`#include OATPP_CODEGEN_END(DbClient)`.
*Do not forget to close the code generation section in order to avoid macro conflicts later in the code!*

```cpp
#include "oatpp/orm/SchemaMigration.hpp"
#include "oatpp/orm/DbClient.hpp"
#include "oatpp/core/macro/codegen.hpp"

#include OATPP_CODEGEN_BEGIN(DbClient) ///< Begin code-gen section

class MyClient : public oatpp::orm::DbClient {
public:

  MyClient(const std::shared_ptr<oatpp::orm::Executor>& executor)
    : oatpp::orm::DbClient(executor)
  {}

  QUERY(createUser,
        "INSERT INTO users (username, email, role) VALUES (:username, :email, :role);",
        PARAM(oatpp::String, username),
        PARAM(oatpp::String, email),
        PARAM(oatpp::Enum<UserRoles>::AsString, role))

  QUERY(getUserByName,
        "SELECT * FROM users WHERE username=:username;",
        PARAM(oatpp::String, username))

};

#include OATPP_CODEGEN_END(DbClient) ///< End code-gen section
```

### Create DbClient Component And Connect to Database

DbClient is a heavy object - you want to instantiate it once and then inject it in whatever places you are going to use it.

```cpp
#include "db/MyClient.hpp"      //< User-declared DbClient
#include "oatpp-sqlite/orm.hpp" //< SQLite adapter for oatpp ORM

class AppComponent {
public:

  /**
   * Create DbClient component.
   * SQLite is used as an example here. For other databases declaration is similar.
   */
  OATPP_CREATE_COMPONENT(std::shared_ptr<db::MyClient>, myDatabaseClient)([] {

    /* Create database-specific ConnectionProvider */
    auto connectionProvider = std::make_shared<oatpp::sqlite::ConnectionProvider>("/path/to/database.sqlite");

    /* Create database-specific Executor */
    auto executor = std::make_shared<oatpp::sqlite::Executor>(connectionProvider);

    /* Create MyClient database client */
    return std::make_shared<MyClient>(executor);

  }());

};
```

**Note:**
- `ConnectionProvider` and `ConnectionPool` objects can be reused by multiple `Executors` unless it's
prohibited by a database-specific implementation.
- `Executor` can be reused by multiple DbClients unless it's prohibited by a database-specific implementation.

### DbClient Usage Example

```cpp
/* Inject MyClient database client */
OATPP_COMPONENT(std::shared_ptr<db::MyClient>, client);

/* Create new user in the database */
client->createUser("admin"<EMAIL_ADDRESS>UserRoles::ADMIN);

/* Find user by username in the database */
auto result = client->getUserByUsername("admin");

/* Retrieve query result as a vector of UserDto objects */
/* Of cause, UserDto had to be previously defined */
/* You can also use oatpp::Fields<oatpp::Any> - instead of oatpp::Object<UserDto> for any arbitrary result */
auto dataset = result->fetch<oatpp::Vector<oatpp::Object<UserDto>>>();

/* And we can easily serialize result as a json string using json object mapper */
auto json = jsonObjectMapper.writeToString(dataset);

/* Print the resultant json */
std::cout << json->c_str() << std::endl;
```

Output:

```json
[
  {
    "name": "admin",
    "email"<EMAIL_ADDRESS>    "role": "ROLE_ADMIN"
  }
]
```

## Supported Databases

### Available Database Adaptors

|Adaptor|Database|Limitations|Example Project|
|---|---|---|---|
|[oatpp-sqlite](https://github.com/oatpp/oatpp-sqlite)|SQLite|**Full feature support**|[example-crud](https://github.com/oatpp/example-crud)|
|[oatpp-postgresql](https://github.com/oatpp/oatpp-postgresql)|PostgreSQL|Doesn't support all postgres types|[example-postgresql](https://github.com/oatpp/example-postgresql)|

### Libraries Hierarchy

The main **oatpp** module contains ORM interfaces only. In order to "plug" a specific database,
you have to link the corresponding adaptor (ex.: **oatpp-sqlite**).

```
- oatpp                     # The main oatpp module. ORM interfaces are here.
    |
    |- oatpp-sqlite         # Sqlite adapter for oatpp ORM. Sqlite-specific implementation is here.
    |- oatpp-postgresql     # PostgreSQL adapter for oatpp ORM. PostgreSQL-specific implementation is here.
    ...
    ... etc.
```

## DbClient

### Declare a Query

```cpp
QUERY(selectAllUsers, "SELECT * FROM users;")
```

### Query With Parameters

```cpp
QUERY(selectUserByUsername,
      "SELECT * FROM users WHERE username=:username;",
      PARAM(oatpp::String, username))
```

During execution the expression `username=:username` will be changed to `username='<username-parameter-value>'` and
parameter value will be properly escaped according to its type.

### Query With DTO as a Parameter

For complex queries, it's more convenient to use DTO objects as for parameters set. Thus you ensure the correct order of arguments.

```cpp
QUERY(insertUser,
      "INSERT INTO users "
      "(username, email, role) VALUES "
      "(:user.username, :user.email, :user.role);",
      PARAM(oatpp::Object<UserDto>, user))
```

**Note:**
The query template variable names are now starting with `user`, like `user.username` -
where `user` is the name of the DTO parameter, and `username` is the name of DTO field.

- **Yes**, you can specify a path to nested DTO fields like `:user.path.to.nested.field`.
- **Yes**, you can have multiple DTO parameters in the query, and you can mix DTO parameters with regular parameters.

### Query With Prepared Statement

```cpp
QUERY(selectUserByUsername,
      "SELECT * FROM users WHERE username=:username;",
      PREPARE(true), //<-- set prepare to `true` to use a prepared statement.
      PARAM(oatpp::String, username))
```

**Note**:
The database adapter may ignore this.
For example:
- SQLite is always using prepared statements to execute queries thus **oatpp-sqlite** will ignore this parameter.
- PostgreSQL has a special method to execute prepared statements thus **oatpp-postgresql** will not ignore this parameter.

### Execute An Arbitrary Query

To execute an arbitrary query use [DbClient::executeQuery()](/api/latest/oatpp/orm/DbClient/#dbclient-executequery) method.
Use this method when it's needed to dynamically build a query.

```cpp
auto dbResult = client.executeQuery("SELECT * FROM users;", {} /* empty params map */);
```

You can add parameters using parameters map:

```cpp
auto dbResult = client.executeQuery(
  "SELECT * FROM users WHERE id=:id AND username=:username;",
  {
    {"id", oatpp::Int64(23)},             ///< Yes, you have to explicitly specify parameter type here - oatpp::Int64
    {"username", oatpp::String("admin")}  ///< Yes, you have to explicitly specify parameter type here - oatpp::String
  }
);
```

When building parameters map dynamically you have to use `std::unordered_map::insert()` method.
The `[]` operator WON'T work.

```cpp
std::unordered_map<oatpp::String, oatpp::Void> params;
params.insert({"id", oatpp::Int64(23)});
params.insert({"username", oatpp::String("admin")});
auto dbResult = client.executeQuery("SELECT * FROM users WHERE id=:id AND username=:username;", params);
```

To build a query string it's recommended to use [oatpp::data::stream::BufferOutputStream](/api/latest/oatpp/core/data/stream/BufferStream/#bufferoutputstream).

```cpp
#include "oatpp/core/data/stream/BufferStream.hpp"

...

oatpp::data::stream::BufferOutputStream stream;
stream
<< "SELECT * FROM users "
<< "WHERE "
<< "id=:id" << " AND " << "username=:username" << ";"

std::unordered_map<oatpp::String, oatpp::Void> params;
params.insert({"id", oatpp::Int64(23)});
params.insert({"username", oatpp::String("admin")});

auto dbResult = client.executeQuery(stream.toString(), params);
```

### Enable Type Interpretations

When using custom or non-standard types as parameters in `QUERY` macro,
as well as when reading query results to custom/non-standard structures, you have to
explicitly enable corresponding type interpretations.

The recommended place to do it - is the constructor:

```cpp
class MyClient : public oatpp::orm::DbClient {
public:

  MyClient(const std::shared_ptr<oatpp::orm::Executor>& executor)
    : oatpp::orm::DbClient(executor)
  {
    setEnabledInterpretations({"protobuf"});
  }

  ...

};
```

#### Query With Custom Type Parameter

```cpp
QUERY(insertUser,
      "INSERT INTO users "
      "(username, email, role) VALUES "
      "(:user.username, :user.email, :user.role);",
      PARAM(oatpp::protobuf::Object<User>, user)) // Pass protobuf object
```

#### Map Query Result To Custom Type

```cpp
/* Execute query */
auto result = client->getUserByUsername("admin");

/* Map result to a vector of protobuf objects */
auto dataset = res->fetch<oatpp::Vector<oatpp::protobuf::Object<User>>>(); // Map result

for(auto& user : *dataset) {
  ...
}
```

### Transactions

Use [DbClient::beginTransaction()](/api/latest/oatpp/orm/DbClient/#dbclient-begintransaction) method to begin a transaction.
All queries MUST be executed on the same transaction connection.

```cpp
{
  auto transaction = client.beginTransaction();

  client.insertUser(user1, transaction.getConnection());
  client.insertUser(user2, transaction.getConnection());
  client.insertUser(user3, transaction.getConnection());

  transaction.commit();
}
```

**Note:**
Transaction will be automatically rollback if [Transaction::commit()](/api/latest/oatpp/orm/Transaction/#transaction-commit) method
was not called.

## Executing Queries

```cpp
/* Execute a query */
auto queryResult = client.selectAllUsers();

/* Check if the operation was successful */
if(!queryResult->isSuccess()) {
  auto message = queryResult->getErrorMessage();
  OATPP_LOGD("Query", "Error, message=%s", message->c_str());
}

/* Fetch everything as a vector of User objects */
auto dataset = queryResult->fetch<oatpp::Vector<oatpp::Object<User>>>();
```

The `queryResult` here is the [oatpp::orm::QueryResult](/api/latest/oatpp/orm/QueryResult/) object.
All queries return `oatpp::orm::QueryResult`.

### Mapping Results

Available result mappings depend on the database adapter but here are some examples (that work for oatpp-sqlite and oatpp-postgresql)...

#### Map everything using previously decalred `UserDto` and display results

For more info on how to declare a DTO - see [oatpp::DTO](/docs/components/dto/)

```cpp
auto dataset = queryResult->fetch<oatpp::Vector<oatpp::Object<oatpp::UserDto>>>();

/* Serialize result as a json string using json object mapper */
auto json = jsonObjectMapper.writeToString(dataset);

/* Print the resultant json */
std::cout << json->c_str() << std::endl;
```

Output:

```json
[
  {
    "name": "admin",
    "email"<EMAIL_ADDRESS>    "role": "ROLE_ADMIN"
  },
  {
    "name": "ivan",
    "email"<EMAIL_ADDRESS>    "role": "ROLE_GUEST"
  }
]
```

#### Map everything using `oatpp::Any` and display results

```cpp
auto dataset = queryResult->fetch<oatpp::Vector<oatpp::Fields<oatpp::Any>>>();

/* Serialize result as a json string using json object mapper */
auto json = jsonObjectMapper.writeToString(dataset);

/* Print the resultant json */
std::cout << json->c_str() << std::endl;
```

Output:

```json
[
  {
    "name": "admin",
    "email"<EMAIL_ADDRESS>    "role": "ROLE_ADMIN"
  },
  {
    "name": "ivan",
    "email"<EMAIL_ADDRESS>    "role": "ROLE_GUEST"
  }
]
```

### Managing Connections

All declared queries have an [oatpp::orm::Connection](/api/latest/oatpp/orm/Connection/) as the last parameter.
If the connection is not specified(`nullptr`), then the new connection will be opened to execute that query.

```cpp
{
  auto queryResult = client.selectAllUsers(); //< Open a new connection.
}

{
  auto connection = client.getConnection();
  auto queryResult = client.selectAllUsers(connection); //< Execute using the connection provided.
}

{
  auto queryResult = client.selectAllUsers(); //< Open a new connection.
  ...
  queryResult = client.insertUser(user, queryResult->getConnection()); //< Execute on the same connection as the last query.
}
```

**Note:**

The `queryResult` object holds a connection. The connection won't return to the connection pool until `queryResult` is destroyed.

## Connection Pool

It's always a good idea to use a connection pool when working with a database.

```cpp
#include "db/MyClient.hpp"
#include "oatpp-sqlite/orm.hpp"

class AppComponent {
public:

  /**
   * Create DbClient component.
   * SQLite is used as an example here. For other databases declaration is similar.
   */
  OATPP_CREATE_COMPONENT(std::shared_ptr<db::MyClient>, myDatabaseClient)([] {
    /* Create database-specific ConnectionProvider */
    auto connectionProvider = std::make_shared<oatpp::sqlite::ConnectionProvider>("/path/to/database.sqlite");

    /* Create database-specific ConnectionPool */
    auto connectionPool = oatpp::sqlite::ConnectionPool::createShared(connectionProvider,
                                                                      10 /* max-connections */,
                                                                      std::chrono::seconds(5) /* connection TTL */);

    /* Create database-specific Executor */
    auto executor = std::make_shared<oatpp::sqlite::Executor>(connectionPool);

    /* Create MyClient database client */
    return std::make_shared<MyClient>(executor);
  }());

};
```

**Note:**
SQLite is used as an example here. For other databases declaration is similar.

## Schema Migration

Use [SchemaMigration](/api/latest/oatpp/orm/SchemaMigration/) to do schema migrations!
The recommended place to do schema migrations is the constructor of your DbClient.

### Overview

```cpp
class MyClient : public oatpp::orm::DbClient {
public:

  MyClient(const std::shared_ptr<oatpp::orm::Executor>& executor)
    : oatpp::orm::DbClient(executor)
  {
    oatpp::orm::SchemaMigration migration(executor);
    migration.addFile(1 /* version */, "sql/initial_schema.sql" /* migration script */);
    migration.addFile(2 /* version */, "sql/schema_fix_1.sql"   /* migration script */);
    ...
    migration.migrate(); //<-- This guy will throw on error.
  }

  ...

};
```

**Note:**

- Version MUST start from `1`.
- Version MUST be incremented by `1`.
- In case of an error changes will be rolled back to the last successfully applied version.

### Schema Name

If you have multiple Schemas in your database you can manage migrations of each one independently.
For this specify a version control table suffix:

```cpp
oatpp::orm::SchemaMigration migration(executor, "suffix");
```

**Note:**
It is recommended to have one DbClient per schema!

## Examples projects

- [example-crud](https://github.com/oatpp/example-crud) - Using oatpp ORM with SQLite.
- [example-postgresql](https://github.com/oatpp/example-postgresql) - Using oatpp ORM with PostgreSQL.

repository: oatpp/website

repo_name: oatpp/website


text:
- [SVG Caster: SVG font to SVG converter](https://github.com/icons8/svg-caster)
- [SVG Font Glyphs to SVG Paths Conveter](https://scratch.mit.edu/discuss/topic/163178/?page=1#post-2077184)
- [Blog post on](https://helpfulsheep.com/2015-03-25-converting-svg-fonts-to-svg/)
- [Webfont Generator - by Font Squirrel](https://www.fontsquirrel.com/tools/webfont-generator)

# SVG Fonts

- [Font Mfizz by Fizzed](https://github.com/fizzed/font-mfizz/tree/master/src/svg)
- [Font-Awesome-SVG-PNG](https://github.com/encharm/Font-Awesome-SVG-PNG/tree/master/black/svg)
- https://openmoji.org/
- https://www.joypixels.com/

# Other interesting Pandoc filters

- [imagine - A pandoc-filter for images](https://github.com/hertogp/imagine)


text:
talker.js
=========

A tiny (<4kB minified, <1kB min+gzip), promise-based library for cross-origin communication between frames and windows.

Building
--------

```
npm install -g grunt-cli
npm install
grunt
```

repository: jackmingming/node-multiple-threads

repo_name: jackmingming/node-multiple-threads


text:
# Using Atlas

* Grab one or more Atlas files (from [here](https://www.dropbox.com/sh/54aqfbs12suqd9t/AACGxhjCaJiRcJUBuFh0iLiHa) or after [building them yourself](src/main/java/org/openstreetmap/atlas/geography/atlas/README.md#building-an-atlas-from-an-osmpbf-file)), and open them with [`AtlasResourceLoader`](src/main/java/org/openstreetmap/atlas/geography/atlas/AtlasResourceLoader.java):
```
final File atlasFile = new File("/path/to/source.atlas");
final Atlas atlas = new AtlasResourceLoader().load(atlasFile);
```
Query the data. Examples:

* Get all edges within boundaries:
```
Rectangle rectangle = ...;
atlas.edgesIntersecting(rectangle).forEach(edge -> ...);
```
* Find all the parks with less than 6 shape points:
```
Predicate<Area> filter = area -> {
    return Validators.isOfType(area, LeisureTag.class, LeisureTag.PARK)
        && area.asPolygon().size() < 6;
}
atlas.areas(filter).forEach(area -> ...);
```
or
```
Predicate<Area> filter = area -> {
    return "park".equals(area.getTags().get("leisure"))
        && area.asPolygon().size() < 6;
}
atlas.areas(filter).forEach(area -> ...);
```
* Find all buildings with a hole:
```
ComplexBuildingFinder finder = new ComplexBuildingFinder();
Iterables.stream(finder.find(atlas))
    .filter(complexBuilding -> !complexBuilding.getOutline().inners().isEmpty())
    .forEach(complexBuilding -> ...);
```
* How many `Edge`s are connected to a `Node`:
```
long identifier = 123;
int numberOfConnectedEdges = atlas.nodeForIdentifier(identifier).connectedEdges().size();
```
or
```
long identifier = 123;
int numberOfConnectedEdges = atlas.nodeForIdentifier(identifier).absoluteValence();
```

# Building an `Atlas` from an `.osm.pbf` file

Building an `Atlas` from an `.osm.pbf` file involves multiple steps, described below. First create a "Raw Atlas" that is a simple copy of all the items in the PBF file into the Atlas format. Then (optionally) apply country slicing, and finally call the way-sectioning algorithm to create the "navigable network" part of the Atlas.

Without country slicing:

```
final File pbfFile;

final Atlas rawAtlas = new RawAtlasGenerator(pbfFile).build();
final Atlas atlas = new WaySectionProcessor(rawAtlas, AtlasLoadingOption.createOptionWithAllEnabled()).run();
```

With country slicing:

```
final File pbfFile;
final Set<String> countries;
final CountryBoundaryMap boundaries;

final Atlas rawAtlas = new RawAtlasGenerator(pbfFile).build();
final Atlas slicedRawAtlas = new RawAtlasCountrySlicer(countries, boundaries).slice(rawAtlas);
final Atlas atlas = new WaySectionProcessor(slicedRawAtlas, AtlasLoadingOption.createOptionWithAllEnabled(boundaries)).run();
```

## Way Sectioning

OSM ways usually span multiple intersections in the case of roads. To make the road network a navigable network, the process of loading an `.osm.pbf` file runs "way sectioning". It will follow a set of rules to break ways at intersections, and create `Atlas` `Edge`s. For that, it pads the OSM feature identifiers with six digits starting from 1 to the number of sections. For example, way 123 would become `Edge`s 123000001, 123000002 and 123000003 if it has to be broken twice. If no sectioning takes place, the edge identifier would end in `000`.

## Country Slicing

In case of building an Atlas that is hard-cut along a polygon (usually a country boundary with boundary=administrative and admin_level=2), the process of loading an `.osm.pbf` file runs "country slicing". All the features that span outside of the boundary will be cut at the boundary and excluded. All the features that are inside will be assigned a country code tag if a country code is given with the AtlasLoadingOption.

The `AtlasLoadingOption` contains all the country boundaries, along with the country codes in a `CountryBoundaryMap`.

All feature identifiers will be padded and the first 3 digits of the 6 digit padding (described above) will be a country counter. If a `Line` 123 spans 2 countries, gets out and comes back for example, it will ship with 123001000 and 123001002 within the first country, and 123002001 in the country where it spans out (in a separate `Atlas`).

## Configuration

Way-sectioning logic, edge definition and which pbf entities (Way, Node, Relation) are brought into an `Atlas` are all configurable. The default configurations can be found in the main resources directory as json files (see atlas-way-section.json for an example of the way section configuration). These configurations are initialized and can be set in `AtlasLoadingOption`.

# Building an `Atlas` from scratch

The `PackedAtlasBuilder` is here for that. It ensures that all the data that makes its way to an Atlas is consistent (for example making sure that if an `Edge` says its start `Node` is 123, then `Node` 123 really exists) and that an Atlas is final and cannot be modified once it has been accessed once.

* First add all the `Node`s
* Then add all the `Edge`s, `Area`s, `Line`s and `Point`s in any order.
* Finally add all the `Relation`s from the lowest order (no other `Relation` is within its members) to the higher order (other `Relation`s are within its members). The `PackedAtlasBuilder` will throw an exception if a `Relation` is added and any of the listed members have not already been added.

# Saving an `Atlas`

The `Atlas` API offers a `save(WritableResource)` method, that is implemented by `PackedAtlas`. Trying to save a `MultiAtlas` will result in an exception suggesting to copy the `Atlas` to a `PackedAtlas` first.

# Copying an `Atlas`

From any `Atlas`, a `PackedAtlas` can be created and saved to a `WritableResource` (A File for example). This is done with the `PackedAtlasCloner`:

```
final Atlas atlas1;
final Atlas atlas2;
new PackedAtlasCloner().cloneFrom(new MultiAtlas(atlas1, atlas2)).save(new File("/path/to/file.atlas"));
```

# Filtering an `Atlas`

Atlas objects can be soft-filtered based on a `Predicate` or a `Polygon`.

```
final Atlas atlas;

final Predicate<AtlasEntity> predicate;
final Atlas predicateAtlas = atlas.subAtlas(predicate, AtlasCutType.SOFT_CUT);

final Polygon polygon;
final Atlas polygonAtlas = atlas.subAtlas(polygon, AtlasCutType.SOFT_CUT);
```

repository: osmlab/atlas

branch_name: refs/heads/dev

gha_language: Java

repo_name: osmlab/atlas


text:
# data-grabber

This is a simple PHP script that can be used as a cookie grabber / session stealer.

It uses MySQL to store data in a structured way (please see the data definition script).

## DISCLAIMER

**Please use this tool responsibly. I do not take responsibility for the way in which any one uses this application. I am NOT responsible for any damages caused or any crimes committed by using this tool.**

## Authors

* **Antonio Francesco Sardella** - *main implementation* - [m3ssap0](https://github.com/m3ssap0)

## License

This project is licensed under the MIT License - see the **LICENSE.txt** file for details.


text:
---
description: Description of the different modules and how they communicate with each other.
---

# System Architecture

### DroneBridge Common Library

The common library provides core functions for all DroneBridge modules. This shared code base implements the DroneBridge raw protocol and therefor handles the setup of the required sockets based on user input. The library provides convenience functions for sending & receiving data using the raw protocol, can encrypt payloads \(AES + EAX, Python only for now\), and defines structures to be used for inter-process communication between major modules.

![DroneBridge common library concept](../.gitbook/assets/db_concept-db-library.svg)

Information on how to use the library can be found in the [examples chapter](dronebridge-lib-example-usage.md).

### Startup Sequence

All DroneBridge applications are started by the `start_db.service`. Most of the startup scripts are located inside the `startup` folder. Like any service it can be started, stopped & re-started. During stopping or restarting there might still be some bugs.

![Startup Sequence of DroneBridge for Raspberry Pi](../.gitbook/assets/db_concept-start-up.svg)

### Module architecture of release v0.6

Following Block Diagram shows how the different DroneBridge modules communicate with each other on the network & long range link. Some modules that do not have complex communication paths are not displayed \(SysLogServer, OSD\). Same goes for communication via shared memory.

#### GCS connected via network

In this case a GCS like DroneBridge for Android or QGroundControl is connected via TCP to the DroneBridge GND side. A UDP data stream \(video\) is sent via unicast to `<IP_ADDRESS>`. A different destination IP can be registered by sending a UDP packet of any size and content to the video module on UDP port `5000`.

![Ground Control Station \(GCS\) connected to DroneBridge GND station via network](../.gitbook/assets/db_concept-gcs-network-configuration.svg)

#### DroneBridge for Android via USB connection

In this case of a connected android phone to the DB GND station, the USB Bridge module auto-connects to all relevant modules and forwards the messages to the phone using the Android Accessory Protocol. At this point only the DroneBridge for Android app supports this mode.

![DroneBridge for Android connected via USB](../.gitbook/assets/db_concept-usb-configuration.svg)

repository: DroneBridge/Docs

repo_name: DroneBridge/Docs


text:
# The Golang SWC Registry Library
[![CircleCI](https://circleci.com/gh/SmartContractSecurity/SWC-registry-go.svg?style=svg)](https://circleci.com/gh/SmartContractSecurity/SWC-registry-go)
[![coverage](https://gocover.io/_badge/github.com/SmartContractSecurity/SWC-registry-go/pkg?0 "coverage")](http://gocover.io/github.com/SmartContractSecurity/SWC-registry-go)
[![Go Report Card](https://goreportcard.com/badge/github.com/SmartContractSecurity/SWC-registry-go)](https://goreportcard.com/report/github.com/SmartContractSecurity/SWC-registry-go)
[![Go Doc](http://img.shields.io/badge/godoc-reference-5272B4.svg?style=flat-square)](https://godoc.org/github.com/SmartContractSecurity/SWC-registry-go/pkg)

This package aims to make the [Smart Contract Weakness Classification](https://smartcontractsecurity.github.io/SWC-registry/) (SWC) Registry accessible in Golang. To get an overview over the available methods, please check the Go Doc for this repo [here](https://godoc.org/github.com/SmartContractSecurity/SWC-registry-go/pkg).

## Example
```go
package main

import (
    swc "github.com/SmartContractSecurity/SWC-registry-go/pkg"
    "fmt"
)

func main() {
    s, err := swc.GetSWC("SWC-101")
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(s.GetMarkdown())
    }
}
```

## Behaviour
On first use of the `GetSWC` function, the SWC registry is initialized from the SWC classification repository if it's not filled already. Further queries are then relayed to the already downloaded dataset - unless an update is triggered explicitly by the user.

There are two ways to update the internal SWC registry: from a local file or a remote URL. The user will have to get the package's SWC registry instance (a singleton and thread-safe) and call one of the update methods:

### Update from URL
```go
r := GetRegistry()
err := r.UpdateRegistryFromURL()
if err != nil {
    t.Fatalf("Loading from URL failed. Got error %s", err)
}
```
Alternatively, a custom URL can be passed. Otherwise we will default to the JSON file in the official SWC Registry repo: Also contained as `DefaultGithubURL` in the package.

### Update from File
```go
r := GetRegistry()
err := r.UpdateRegistryFromFile()
if err != nil {
    t.Fatalf("Loading from file failed. Got error %s", err)
}
```
This works analogously to the above example and defaults to `DefaultFilePath` unless given another valid file path to a JSON file.

repository: sambacha/SWC-registry-go

repo_name: sambacha/SWC-registry-go


text:
Scripting
=========

Visualstatus uses QtScript as the scripting environment, which is based on ECMA script.

Custom objects and functions have been added to allow easy communication with external systems like Hudson/Jenkins servers and serial ports.

Custom script objects
---------------------

The following custom objects are available in the scripting environment:

* [Logger](Logger.md), for logging.
* [Color](Color.md), for RGB colors.
* [QTimer](QTimer.md), for repetitive timers.
* [SerialPort](SerialPort.md), for serial port communications.
* [HttpPort](HttpPort.md), for simple HTTP communications.
* [JenkinsManager](JenkinsManager.md), for interfacing with a Hudson/Jenkins build server.
* [SerialLed](SerialLed.md), for LEDs connected to a serial port.
* [SerialLedBuffered](SerialLedBuffered.md), for LEDs connected to a serial port (buffered transfer).
* [MockSerialPort](MockSerialPort.md), for mocking a serial port.
* [MockHttpPort](MockHttpPort.md), for mocking an HTTP port.
* [MockJenkinsManager](MockJenkinsManager.md), for mocking a Hudson/Jenkins build server.

Global functions
----------------

### exit()

Ends the evaluation of the script and closes the application.

Normally the application will keep running, even when evaluation of a script has ended. This is done to allow serial port connections to remain open, which is especially useful with Arduino ( an Arduino resets itself when the serial connection is closed). Calling the _exit()_ function will close the application and therefore close all serial port connections.

```javascript
var counter = 0;
var timer = new QTimer;

function timeout()
{
  if (++counter >= 10)
  {
    exit();
  }
}

timer.timeout.connect(timeout);
timer.start(500);
```

repository: oddguid/visualstatus

repo_name: oddguid/visualstatus


text:
---
permalink: /
excerpt: "About me"
author_profile: true
redirect_from:
  - /about/
  - /about.html
---

My name is Swati Meena, and I am a Data scientist at [Sprinklr](https://www.sprinklr.com/). I have worked in the area of deep learning applications to the medical images specifically for breast cancer diagnosis and prognosis at MeDAL (Medical Deep Learning and Artificial Intelligence Lab). I have worked in the area with pathology images. I also have a keen interest in the field of Computer vision, and Natural language processing.

I maintain a list of my publications and research implementations under the [Publications]({{ site.url }}/publications) tab. To get an insight into my professional life so far, you can have a look at my [CV].

## Updates

* Present: Joined [Sprinklr](https://www.sprinklr.com/) as a Data Scientist.

*  July 2020: Completed Masters in the [Department of Electrical Engineering](https://www.ee.iitb.ac.in/web) at [IIT Bombay](http://www.iitb.ac.in/).

*  June 2020: Sucessfully completed Masters thesis project on  'Pathological features discrimination in Lymph node using deep learning techniques' at [IIT Bombay](http://www.iitb.ac.in/) in collaboration with [Kings College London](https://www.kcl.ac.uk/).

*  Dec 2019: A paper 'Breast Cancer Histopathology Image Classification and Localization using Multiple Instance Learning got accepted at The 5th [IEEE](https://www.ieee.org/) [WIECON-ECE](https://wieconece.org/) conference, 2019 [Paper Link](https://ieeexplore.ieee.org/document/9019916). Congratulations to co-authors [Abhijeet patil](https://in.linkedin.com/in/abhijeet-patil-90945557), Dipesh Tamboli, [Deepak Anand](https://deepakanandece.github.io/) and [Amit Sethi](https://www.ee.iitb.ac.in/~asethi/).

*  Dec 2019: Best paper Award at the 5th [IEEE](https://www.ieee.org/) [WIECON-ECE](https://wieconece.org/) conference, 2019.

*  Dec 2018: Presented on 'Design and architecture of convolutional neural network' in M.tech. Seminar at [IIT Bombay](http://www.iitb.ac.in/).

*  July 2018: Joined [IIT Bombay](http://www.iitb.ac.in/) for Master's in Electrical Engineering as a teaching assistant.

*  June 2017: Sucessfully completed Bachelor's of technology from [IIT(ISM) Dhanbad](https://www.iitism.ac.in/).


text:
# CETgraph TO-DO list #

# Overal workplan #
    * [ ] Organizing the existing code as a package
        * [X] Create synthetic images and waterfalls
        * [X] Check if tracking works on simulated waterfalls
    * [ ] testing the core functions:
        * [X] Simulating Brownian trajectories
        * [X] Tracking waterfalls (and image cubes?)
        * [ ] Generating experiment summaries
    * [ ] Extra functions
        * [ ] Measuring mobility
        * [ ] Measuring electrophoretic delay
        * [ ] Measuring hindered diffusion

# Reported bugs #

report bugs as soon as you mention them (optional: you can guess the cause)

    [] (dd-mm-yy)User: example bug report

_last edited by_ **Sanli, 13/2/2018**

repository: nanoepics/CETgraph

repo_name: nanoepics/CETgraph


text:
# aws-cf-invalidate

A simple CLI to refresh files in cloudfront cache written in [Go.](http://golang.org)

## Configuration

Before using, ensure that you've configured credentials. The best way to configure
credentials is to use the ~/.aws/credentials file, which might look like:
```
[default]
aws_access_key_id = AKID1234567890
aws_secret_access_key = MY-SECRET-KEY
```
Alternatively, you can set the following environment variables:
```
AWS_ACCESS_KEY_ID=AKID1234567890
AWS_SECRET_ACCESS_KEY=MY-SECRET-KEY
```
## Usage

```
Description: Send a batch of url paths to AWS Cloudfront to invalidate caches.

Usage: aws-cf-invalidate [options...] [assetpaths...]

Application options:
    -d, --distribution_id            ID of the distribution (mandatory)

Common options:
    -h, --help                       Show this message
    -V, --version                    Show version

Examples:
	aws-cf-invalidate -d ABC123 /path/img1.jpg
    aws-cf-invalidate --distribution_id ABC123 /path/img1.jpg /path/img2.jpg

	aws-cf-invalidate --version
```

## Building Binaries

This code currently requires version 1.42 or higher of Go.  You'll also need to
compile different platforms. For example:
```
GOOS=windows GOARCH=amd64 go build -o aws-cf-invalidate-amd64.exe -i
GOOS=linux GOARCH=amd64 go build -o aws-cf-invalidate-linux-amd64 -i
```
Only 64 bit binaries (amd64) are distributed with this repo. To compile all versions, run the build.sh script:
```
. build.sh
```

Information on Golang installation, including pre-built binaries, is available at
<http://golang.org/doc/install>.

Run `go version` to see the version of Go which you have installed.

Run `go build` inside the directory to build.

Run `go test ./...` to run the unit regression tests.

A successful build run produces no messages and creates an executable called `aws-cf-invalidate` in this
directory.

Run `go help` for more guidance, and visit <http://golang.org/> for tutorials, presentations, references and more.

## License

(The MIT License)

Copyright (c) 2015 Pyxxel Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

 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.


text:
---
title: 'Kernel'
published: true
tags: Linux
---

The kernel is the core of an operating system. It functions on a low level
(kernelspace) interacting between the hardware of the machine and the programs
which use the hardware to run. The kernel temporarily stops programs to run
other programs in the meantime, which is known as preemption. This creates the
illusion of many tasks being executed simultaneously, even on single-core CPUs.
The kernel uses the CPU scheduler to decide which program takes priority at any
given moment.

## Reference

- [https://wiki.archlinux.org/title/Arch_boot_process#Kernel](https://wiki.archlinux.org/title/Arch_boot_process#Kernel)

gha_language: HTML


text:
# todo

## default aliases:
```
tel-todo
todo
td
```
## usage:
```
tel-todo		= show my todo list

tel-todo new task 	= add 'new task' to your todo list

tel-todo -c | --clear	= wipe todo list

tel-todo -r | --remove	= remove latest entry

tel-todo -r 2		= remove entry 2

tel-todo -e 		= open todo list in editor

tel-todo -h | --help 	= show help menu
```
## info:

tel-todo is a KISS to-do list manager.

user data is stored as a text file at: `~/.tel/data/todo`.

tel-todo intergrates with the todo status module to display your latest todo list entry.

if you would like to use tel-todo on another device (running bash) you can download tel-todo to a location in your `$PATH`, then sync the todo file using your preferred method to the same location on the other device.

can be launched into editor mode with default key combo <kc>TEL + t</kc>

## note:

tel-todo uses the `$EDITOR` env variable to read your preferred editing program. If you wish to change your default editor, look inside of file `~/.tel/configs/userprefs.sh`

repository: t-e-l/wiki

repo_name: t-e-l/wiki


text:
# clix - Changelog
## v5.0.0
- **Build Scripts Changes**
  - set travis min node version - [bf812f3]( https://github.com/royriojas/clix/commit/bf812f3 ), [Roy Riojas](https://github.com/Roy Riojas), 11/07/2019 16:05:28

  - Upgrade clix deps - [75391af]( https://github.com/royriojas/clix/commit/75391af ), [Roy Riojas](https://github.com/Roy Riojas), 11/07/2019 16:04:38

## v4.0.0
- **Refactoring**
  - upgraded the modules - [a3aa349]( https://github.com/royriojas/clix/commit/a3aa349 ), [Roy Riojas](https://github.com/Roy Riojas), 10/07/2019 05:45:54

  - Remove critical warning from audit - [9a137cc]( https://github.com/royriojas/clix/commit/9a137cc ), [Roy Riojas](https://github.com/Roy Riojas), 09/07/2019 13:00:28

## v3.0.0
- **Refactoring**
  - Remove critical warning from audit - [41c3f5c]( https://github.com/royriojas/clix/commit/41c3f5c ), [Roy](https://github.com/Roy), 11/06/2019 03:05:22

## v2.2.2
- **Refactoring**
  - Upgrade clix-logger - [792ba67]( https://github.com/royriojas/clix/commit/792ba67 ), [Roy Riojas](https://github.com/Roy Riojas), 09/08/2018 02:02:53

## v2.2.1
- **Refactoring**
  - Fix missing module - [22aafc9]( https://github.com/royriojas/clix/commit/22aafc9 ), [Roy Riojas](https://github.com/Roy Riojas), 02/01/2017 06:01:33

## v2.2.0
- **Build Scripts Changes**
  - update dev deps - [9b692e8]( https://github.com/royriojas/clix/commit/9b692e8 ), [Roy Riojas](https://github.com/Roy Riojas), 02/01/2017 03:05:44

## v2.1.0
- **Build Scripts Changes**
  - updated packages - [6ccf31a]( https://github.com/royriojas/clix/commit/6ccf31a ), [Roy Riojas](https://github.com/Roy Riojas), 31/07/2016 04:15:40

- **Features**
  - add `ext` and `rename` options similar to grunt.file.expandMapping ones - [7e810d8]( https://github.com/royriojas/clix/commit/7e810d8 ), [Roy Riojas](https://github.com/Roy Riojas), 21/08/2015 03:39:08

  - Specify more than one task to run - [08c9ede]( https://github.com/royriojas/clix/commit/08c9ede ), [royriojas](https://github.com/royriojas), 17/08/2015 04:01:57

- **Bug Fixes**
  - remove cwd when the path is expanded - [27fbba0]( https://github.com/royriojas/clix/commit/27fbba0 ), [Roy Riojas](https://github.com/Roy Riojas), 21/08/2015 01:13:36

- **Enhancements**
  - Add loadConfig method helper to load a configuration file other than the default one - [15107e9]( https://github.com/royriojas/clix/commit/15107e9 ), [royriojas](https://github.com/royriojas), 16/08/2015 00:52:07

- **Tests Related fixes**
  - Add tasks for get-target - [b9f7df7]( https://github.com/royriojas/clix/commit/b9f7df7 ), [royriojas](https://github.com/royriojas), 16/08/2015 00:39:58

- **Refactoring**
  - Extend `getTargets` to also resolve the files property using the `expandMapping` method - [81eed95]( https://github.com/royriojas/clix/commit/81eed95 ), [royriojas](https://github.com/royriojas), 15/08/2015 05:56:16

## v2.0.9
- **Features**
  - Implement expandMapping similar to the one in grunt - [7c052d8]( https://github.com/royriojas/clix/commit/7c052d8 ), [royriojas](https://github.com/royriojas), 15/08/2015 05:07:57

## v2.0.8
- **Build Scripts Changes**
  - Update optionator to get default booleans - [52712d1]( https://github.com/royriojas/clix/commit/52712d1 ), [royriojas](https://github.com/royriojas), 15/08/2015 02:53:39

## v2.0.7
- **Features**
  - Add first version of `expandMapping` - [901a1ec]( https://github.com/royriojas/clix/commit/901a1ec ), [royriojas](https://github.com/royriojas), 15/08/2015 01:29:31

- **Build Scripts Changes**
  - update `prepush` and `precommit` deps - [41ccee0]( https://github.com/royriojas/clix/commit/41ccee0 ), [royriojas](https://github.com/royriojas), 15/08/2015 01:16:57

- **Refactoring**
  - do not resolve paths by default - [8ba8b30]( https://github.com/royriojas/clix/commit/8ba8b30 ), [royriojas](https://github.com/royriojas), 15/08/2015 01:16:29

    If the full paths are needed specify the option `resolvePaths: true`

    ```javascript
    var files = cli.expandGlobs(globs, { resolvePaths: true });
    ```

  - remove unnecessary try/catch - [30791fa]( https://github.com/royriojas/clix/commit/30791fa ), [royriojas](https://github.com/royriojas), 15/08/2015 00:58:18

## v2.0.6
- **Bug Fixes**
  - missing method in cli - [ba16f22]( https://github.com/royriojas/clix/commit/ba16f22 ), [royriojas](https://github.com/royriojas), 14/08/2015 21:33:44

## v2.0.5
- **Bug Fixes**
  - missing deps - [d297129]( https://github.com/royriojas/clix/commit/d297129 ), [royriojas](https://github.com/royriojas), 14/08/2015 21:22:32

## v2.0.4
- **Features**
  - Add a convenience method to expand globs - [1f3ddf1]( https://github.com/royriojas/clix/commit/1f3ddf1 ), [royriojas](https://github.com/royriojas), 14/08/2015 21:20:25

## v2.0.3
- **Build Scripts Changes**
  - update clix dep to get nicer log output - [20af260]( https://github.com/royriojas/clix/commit/20af260 ), [royriojas](https://github.com/royriojas), 11/08/2015 19:30:06

## v2.0.16
- **Build Scripts Changes**
  - updated packages - [6ccf31a]( https://github.com/royriojas/clix/commit/6ccf31a ), [Roy Riojas](https://github.com/Roy Riojas), 31/07/2016 04:15:40

## v2.0.15
- **Features**
  - add `ext` and `rename` options similar to grunt.file.expandMapping ones - [7e810d8]( https://github.com/royriojas/clix/commit/7e810d8 ), [Roy Riojas](https://github.com/Roy Riojas), 21/08/2015 03:39:08

## v2.0.14
- **Bug Fixes**
  - remove cwd when the path is expanded - [27fbba0]( https://github.com/royriojas/clix/commit/27fbba0 ), [Roy Riojas](https://github.com/Roy Riojas), 21/08/2015 01:13:36

## v2.0.13
- **Features**
  - Specify more than one task to run - [08c9ede]( https://github.com/royriojas/clix/commit/08c9ede ), [royriojas](https://github.com/royriojas), 17/08/2015 04:01:57

## v2.0.12
- **Enhancements**
  - Add loadConfig method helper to load a configuration file other than the default one - [15107e9]( https://github.com/royriojas/clix/commit/15107e9 ), [royriojas](https://github.com/royriojas), 16/08/2015 00:52:07

## v2.0.11
- **Tests Related fixes**
  - Add tasks for get-target - [b9f7df7]( https://github.com/royriojas/clix/commit/b9f7df7 ), [royriojas](https://github.com/royriojas), 16/08/2015 00:39:58

## v2.0.10
- **Refactoring**
  - Extend `getTargets` to also resolve the files property using the `expandMapping` method - [81eed95]( https://github.com/royriojas/clix/commit/81eed95 ), [royriojas](https://github.com/royriojas), 15/08/2015 05:56:16

  - do not resolve paths by default - [8ba8b30]( https://github.com/royriojas/clix/commit/8ba8b30 ), [royriojas](https://github.com/royriojas), 15/08/2015 01:16:29

    If the full paths are needed specify the option `resolvePaths: true`

    ```javascript
    var files = cli.expandGlobs(globs, { resolvePaths: true });
    ```

  - remove unnecessary try/catch - [30791fa]( https://github.com/royriojas/clix/commit/30791fa ), [royriojas](https://github.com/royriojas), 15/08/2015 00:58:18

- **Features**
  - Implement expandMapping similar to the one in grunt - [7c052d8]( https://github.com/royriojas/clix/commit/7c052d8 ), [royriojas](https://github.com/royriojas), 15/08/2015 05:07:57

  - Add first version of `expandMapping` - [901a1ec]( https://github.com/royriojas/clix/commit/901a1ec ), [royriojas](https://github.com/royriojas), 15/08/2015 01:29:31

  - Add a convenience method to expand globs - [1f3ddf1]( https://github.com/royriojas/clix/commit/1f3ddf1 ), [royriojas](https://github.com/royriojas), 14/08/2015 21:20:25

- **Build Scripts Changes**
  - Update optionator to get default booleans - [52712d1]( https://github.com/royriojas/clix/commit/52712d1 ), [royriojas](https://github.com/royriojas), 15/08/2015 02:53:39

  - update `prepush` and `precommit` deps - [41ccee0]( https://github.com/royriojas/clix/commit/41ccee0 ), [royriojas](https://github.com/royriojas), 15/08/2015 01:16:57

  - update clix dep to get nicer log output - [20af260]( https://github.com/royriojas/clix/commit/20af260 ), [royriojas](https://github.com/royriojas), 11/08/2015 19:30:06

  - Update to latest clix-logger - [34e0fd1]( https://github.com/royriojas/clix/commit/34e0fd1 ), [royriojas](https://github.com/royriojas), 11/08/2015 15:55:36

- **Bug Fixes**
  - missing method in cli - [ba16f22]( https://github.com/royriojas/clix/commit/ba16f22 ), [royriojas](https://github.com/royriojas), 14/08/2015 21:33:44

  - missing deps - [d297129]( https://github.com/royriojas/clix/commit/d297129 ), [royriojas](https://github.com/royriojas), 14/08/2015 21:22:32

## v2.0.1
- **Enhancements**
  - Add name to the returned tasks - [0835297]( https://github.com/royriojas/clix/commit/0835297 ), [royriojas](https://github.com/royriojas), 10/08/2015 00:53:26

## v2.0.0
- **Refactoring**
  - better error handling and added helper to create task targets similar to grunt - [4337ad9]( https://github.com/royriojas/clix/commit/4337ad9 ), [royriojas](https://github.com/royriojas), 10/08/2015 00:02:39

## v1.1.6
- **Build Scripts Changes**
  - Use clix-logger module for logs, updated dependencies and build scripts - [5950e1b]( https://github.com/royriojas/clix/commit/5950e1b ), [royriojas](https://github.com/royriojas), 07/08/2015 23:39:15

## v1.1.5
- **Refactoring**
  - Prevent failing if the `env` variable is not set - [3e7d447]( https://github.com/royriojas/clix/commit/3e7d447 ), [royriojas](https://github.com/royriojas), 12/07/2015 21:24:35

## v1.1.4
- **Build Scripts Changes**
  - Update bumpery dep - [d4f5064]( https://github.com/royriojas/clix/commit/d4f5064 ), [royriojas](https://github.com/royriojas), 12/07/2015 21:06:28

- **Enhancements**
  - Added the print option to print in gray messages even if `quiet` mode is set - [e1cf344]( https://github.com/royriojas/clix/commit/e1cf344 ), [royriojas](https://github.com/royriojas), 12/07/2015 21:00:14

  - Added the print option to print in gray messages even if `quiet` mode is set - [de208f0]( https://github.com/royriojas/clix/commit/de208f0 ), [royriojas](https://github.com/royriojas), 12/07/2015 20:59:42

## v1.1.2
#### config
- **Enhancements**
  - config file can be a js module exporting a function - [760d055]( https://github.com/royriojas/clix/commit/760d055 ), [royriojas](https://github.com/royriojas), 03/07/2015 23:45:19

## v1.1.1
- **Build Scripts Changes**
  - Add do-changelog npm script entry - [61906eb]( https://github.com/royriojas/clix/commit/61906eb ), [royriojas](https://github.com/royriojas), 03/07/2015 18:28:42

## v1.1.0
- **Features**
  - turn off colorized output by default - [f51e5c3]( https://github.com/royriojas/clix/commit/f51e5c3 ), [royriojas](https://github.com/royriojas), 03/07/2015 18:24:24

    **BREAKING CHANGE**: Well not really, but it changes the way it behaved before, aesthetically speaking

    To enable the colored output pass the option `colored-ouptut` to the command line like

    ```
    ./bin/cli.js --colored-output
    ```

## v1.0.7
- **Build Scripts Changes**
  - Change the building scripts to use the cache to only beautify changed files - [660b82b]( https://github.com/royriojas/clix/commit/660b82b ), [Roy Riojas](https://github.com/Roy Riojas), 25/05/2015 06:56:59

  - Fix wrong cli bin field - [4c894b8]( https://github.com/royriojas/clix/commit/4c894b8 ), [Roy Riojas](https://github.com/Roy Riojas), 12/03/2015 20:28:38

  - Add latest esbeautifier - [1fa1b93]( https://github.com/royriojas/clix/commit/1fa1b93 ), [Roy Riojas](https://github.com/Roy Riojas), 11/03/2015 06:25:21

  - Fix dependency url - [acba4af]( https://github.com/royriojas/clix/commit/acba4af ), [Roy Riojas](https://github.com/Roy Riojas), 11/03/2015 06:16:44

  - Add validation tasks - [b241ec5]( https://github.com/royriojas/clix/commit/b241ec5 ), [Roy Riojas](https://github.com/Roy Riojas), 11/03/2015 06:01:31

- **Features**
  - Add getVersion method the object passed as a callback - [c4b8fbd]( https://github.com/royriojas/clix/commit/c4b8fbd ), [Roy Riojas](https://github.com/Roy Riojas), 13/03/2015 15:04:56

  - First commit - [5b43b09]( https://github.com/royriojas/clix/commit/5b43b09 ), [Roy Riojas](https://github.com/Roy Riojas), 11/03/2015 05:57:17

- **Bug Fixes**
  - Return the cli instance even if the config option is not provided - [8a1503e]( https://github.com/royriojas/clix/commit/8a1503e ), [Roy Riojas](https://github.com/Roy Riojas), 12/03/2015 21:19:36

- **Other changes**
  - Initial commit - [ed5d425]( https://github.com/royriojas/clix/commit/ed5d425 ), [Roy Riojas](https://github.com/Roy Riojas), 11/03/2015 05:21:10

repository: royriojas/clix

repo_name: royriojas/clix


text:
# Cognito User Pool setup

In this section we will walk-through how-to setup the Cognito User Pool that will be used by your application. The user pool will be where all of your users will be stored. This will give you the ability to have your users authenticate into our application.

To begin setting up your Cognito User Pool navigate to the Cognito service in the AWS Console of your Event Engine account. You will then see the Cognito landing page pictured below.

![npm run](../docs/images/cognito-steps/1-cognito-landing.png)

Click the **_Manage User Pools_** button. You will see screen below.

![npm run](../docs/images/cognito-steps/2-user-pool-list.png)

Click the **_Create a user pool_** button, and you should see the screen below.

## User pool name

The first thing you do is give your user pool a “Pool name”. After you have entered a pool name click the “Step through settings” button.

![npm run](../docs/images/cognito-steps/3-user-pool-step-1.png)

## Attributes

Next you will setup the user pool attributes. For the user pool attributes select the options that you see in the image below.

![npm run](../docs/images/cognito-steps/4-user-pool-attributes.png)

Click the “Next step” button at the bottom of the screen.

## Policies

For the “Policies” you can leave the default values that you see on this screen.

![npm run](../docs/images/cognito-steps/5-user-pool-policies.png)

Click the “Next step” button at the bottom of the screen.

## MFA and verifications

For “MFA and verifications” select the options that you see in the screen below.

![npm run](../docs/images/cognito-steps/6-user-pool-mfa.png)

Click the “Next step” button at the bottom of the screen.

## Message customizations

In this workshop we will not be using SES to send out emails. If you wanted to use your own email address to send out emails you could configure SES (Simple Email Service) to accomplish this. For the sake of simplicity, you will leave the below fields blank.

![npm run](../docs/images/cognito-steps/7-user-pool-ses.png)

For the other options you see in the image below you can leave the default values. If you would like you can customize your message to your users here. Don’t make changes to the options in brackets since these are placeholders that Cognito uses to dynamically fill in message information such as username and temporary passwords.

![npm run](../docs/images/cognito-steps/8-user-pool-email-message.png)

After you have completed this form click the “Next step” button at the bottom of the screen.

## Tags

On the next screen if you would like you can add tags to your user pool. For the workshop we will leave tags blank.

![npm run](../docs/images/cognito-steps/9-user-pool-tags.png)

Click the “Next step” button at the bottom of the screen.

## Devices

For the user device options below screen below leave the default value of “No”. If you were building an application where you wanted to track the devices users log in from you can give them the option “User Opt In” or you could always choose to track devices users log in from.

![npm run](../docs/images/cognito-steps/10-user-pool-device.png)

Click the “Next step” button at the bottom of the screen.

## App clients

On the next screen we will setup the app client. By configuring the “app client” you are setting up the ability for an application to connect to your user pool. In this workshop we will be connecting to the user pool via the JavaScript SDK. On the screen you see below click the “Add an app client” link.

![npm run](../docs/images/cognito-steps/app-client-home.png)

You should then see the following screen.

![npm run](../docs/images/cognito-steps/11-user-pool-app2.png)

## App client name

You will start giving your app client a name.

![npm run](../docs/images/cognito-steps/app-client-name.png)

## Token Expiration section

For the Refresh token expiration, Access token expiration, and ID token expiration you leave the default values for the workshop. If you wanted the tokens to expire before the default time-frames you can always come back and make changes.

**_Note_**: Be sure to uncheck "Generate client secret". Since you are running your code on the client-side you will not use this option. If your code was running on the server-side where users wouldn't have access to view your code you could use this option.

![npm run](../docs/images/cognito-steps/token-expiration.png)

Next click the "Create app client" button.

## Auth Flows Configuration section

For the auth flow settings be sure you select the third checkbox option, **Enable username password-based authentication (ALLOW_USER_PASSWORD_AUTH)**

This setting allows users to log into your Cognito user pool via username and password. If this option is not selected you will receive an error when you code call the authentication method.

![npm run](../docs/images/cognito-steps/auth-flow.png)

## Security Configuration

For this section you will leave the default value.

Finally click the **_“Create app client”_** button before click the “Next step” button. After your app client has been create click the “Next step” button.
![npm run](../docs/images/cognito-steps/security-config.png)

## Finalize App Client

You will now see the following screen after you have created your app client. Click the "Next step" button.

![npm run](../docs/images/cognito-steps/app-client-finalize.png)

## Triggers

For the triggers you will not be using them for this workshop. If you needed to add things such as custom logic for pre-authentication, pre-signup, post authentication, or post account confirmation you would configure those triggers here to initiate lambda functions.

A good example of taking advantage Cognito triggers are after a user confirms their account you could have default user settings record created in a backend database.

Since you will not be using triggers in this workshop you can click the “Next step” button at the bottom of the screen.

![npm run](../docs/images/cognito-steps/12-user-pool-triggers.png)

## Review

You should now see a screen similar to the image below with the “Pool name”, and the options that you select as you configured the user pool. Once you are satisfied with the options you have selected for your user pool click the “create pool” button.

![npm run](../docs/images/cognito-steps/13-user-pool-review.png)

Once your user pool has successfully been created you will see a screen similar the image below.

![npm run](../docs/images/cognito-steps/14-user-pool-success.png)

Now that you have setup your Cognito User Pool you will configure your application to use the user pool.

## [Configure application to use Cognito User Pool](CognitoConfig.md)

repository: aws-samples/amazon-cognito-vue-workshop

repo_name: aws-samples/amazon-cognito-vue-workshop


text:
Thank you for upgrading `auto-dark` to `v3.1.1` (2020-05-03)
------------------------------------------------------------

`auto-dark` made adjustments for ST4074 and `mdpopups` v3.7.0.

Please manually run:

    `PackageControl: Satisfy Dependencies`

from the Command Palette to update mdpopups to v3.7.0 or later.

There is still a known issue with auto-changing appearances on Catalina:

    https://github.com/jrappen/sublime-auto-dark/issues/3

This will be fixed hopefully soon.

---

Please restart Sublime Text manually after clearing its cache.

license: MIT,ISC

repository: adib/sublime-auto-dark

detected_licenses: MIT ISC

repo_name: adib/sublime-auto-dark