text:
# Woodside - AI causes growth in jobs

Go to [[Week 2 - Introduction]] or back to the [[Main AI Page]]
Also Featured in the [[Master of Philosophy - Main Page]]

The notes in this page come from [IBM's feature story on Woodside petroleum](https://www.ibm.com/watson/stories/woodside/)

Institutional knowledge is lost due to retirements and layoffs:

	To ensure precision, they rely heavily on historical context and procedural information. Unfortunately, every time an expert with years of knowledge and knowhow retires, that experience walks out the door with them.

So how do you avoid layoffs or retain knowledge from unstructured data?

- IBM's Watson was their solution.

**Idea** Don't be afraid to engage retired staff in knowledge collation.

	“You can’t build a cognitive system without context.”

## Incentivise contributing to the knowledge pool

	Beyond helping Woodside capture critical knowledge, Watson has also fundamentally changed employee mindsets, making them eager to leave their knowledge behind for future use. “They’re aware their knowledge will be beneficial for other engineers who might face similar challenges in the future,” said Neil Maxfield, Woodside’s General Manager for Project Capabilities.

## 5 steps of Watsons Launch

**Refer to the link above for key details about each of these rollout steps**

1. Watson was trained on their existing corpus of documentation, reports, and correspondence
2. Watson was tested and updated
3. Watson was launched
4. Watson began getting results
5. Watson keeps learning

#AIBusinessCase

## Case Study - Woodside

Woodside is Australia's largest independent oil and gas company. It’s an industry requiring absolute accuracy, and previously Woodside has relied on historical context and procedural information to ensure precision. The problem is, that historical context is being lost as the older generation of workers retires. So, the question for Woodside is how to retain that information in a way that is accessible and useful for the current workers.

Woodside began a company-wide initiative to gather information, especially from workers with years of experience nearing retirement. They recognized the value in spending time to train Watson with that data, and to teach Watson the natural language the staff use to pose and respond to questions. This effort enabled engineers to quickly become fully informed of what has been done and how an issue was managed in the past. With Watson, time spent on researching has been reduced by 75%.

At Woodside, Watson has engendered a change of mindset – retiring workers are proud to leave their knowledge as a legacy, and younger workers still benefit from their years of experience while making their own contributions to the company knowledge base.

Like Bradesco, Watson at Woodside learned in five steps:

    Trained with over 600,00 pages of documentation.
    Tested the machine learning model was continuously updated to be able to analyze a higher volume of records.
    Launched Over 80% of employees adopted Watson for their day-to-day work.
    Got results Employees used to spend 80% of their time researching problems and 20% fixing it. Watson has reversed that.
    Keeps learning Employees are encouraged to provide feedback, whether they’re brand new or have years of experience.

The aim for Watson at Woodside is to be innovative and grow. “The biggest thing in oil and gas is health and safety, and Watson can help us make better decisions to ensure that,” said Alexander Russo, an IBM Cognitive Engineer.

url: https://raw.githubusercontent.com/KGBicheno/KGB_Agora/70ea95c9d38ab2f31abbd510691bb4c050a6cb3b/Artificial Intelligence/Introduction to AI/Week 2 - Introduction/Woodside - AI causes growth in jobs.md

filename: Woodside - AI causes growth in jobs.md


text:
***************
WARNING: THIS PROJECT IS DEPRECATED
====================================
It will not receive any future updates or bug fixes. If you are using it, please migrate to another solution.
***************

Purpose
--------------

FXJSON is a lightweight, reasonably fast JSON parser for iOS and Mac OS. It's not the fastest but it's fast enough (see performance benchmarks below), and it has some neat features:

- Optional SAX-style parsing for large files or where order matters
- Fully ARC compatible (also works without ARC)
- Simple - just one class and the code is easy to understand
- No compiler warnings
- Can optionally strip null values from dictionaries or arrays
- Can optionally use NSJSONSerialization on iOS 5 and above
- Can handle JSON with dangling commas in arrays/objects

Supported iOS & SDK Versions
-----------------------------

* Supported build target - iOS 6.1 / Mac OS 10.8 (Xcode 4.6, Apple LLVM compiler 4.2)
* Earliest supported deployment target - iOS 5.0 / Mac OS 10.7
* Earliest compatible deployment target - iOS 4.3 / Mac OS 10.6

NOTE: 'Supported' means that the library has been tested with this version. 'Compatible' means that the library should work on this iOS version (i.e. it doesn't rely on any unavailable SDK features) but is no longer being tested for compatibility and may require tweaking or bug fixes to run correctly.

ARC Compatibility
------------------

FXJSON automatically supports both ARC and non-ARC projects through conditional compilation. There is no need to exclude FXJSON files from the ARC validation process, or to convert FXJSON using the ARC conversion tool.

Installation
---------------

To use FXJSON, just drag the class files into your project. The FXJSON methods are static so there's no need to create an instance of the FXJSON class.

Configuration
-----------------

FXJSON has the following configurations constants. These can be set as preprocessor macros in the build settings if you wish to override the defaults:

    FXJSON_OMIT_NULL_OBJECT_VALUES

This option will disable generation of NSNull objects for null values inside JSON {...} objects. This is often desirable because a program that receives an NSNull when it expects another object type may crash, whereas no value (nil) is usually handled gracefully. With this option enabled, null values in arrays will still output as NSNull because removing these would affect the array indexes. Defaults to YES. Does not apply when using delegate-based enumeration.

    FXJSON_OMIT_NULL_ARRAY_VALUES

This option will disable generation of NSNull objects for null values inside JSON [...] arrays. This is often desirable because a program that receives an NSNull when it expects another object type may crash. Defaults to NO because it might mess up the expected array indexes or item count. Does not apply when using delegate-based enumeration.

    FXJSON_USE_NSJSON_IF_AVAILABLE

This option will cause FXJSON to make use of the NSJSONSerialization class on iOS5 and above. This is desirable because the NSJSONSerialization class is faster than FXJSON in most benchmarks. Does not apply when using delegate-based enumeration.

Methods
----------------

FXJSON has the following static methods:

    + (void)enumerateJSONData:(NSData *)data withDelegate:(id<FXJSONDelegate>)delegate;

Parses JSON data using a SAX-style parser where the values are returned via a delegate instead of as a hierarchical object. The advantages of this approach are that very large files can be parsed without consuming a lot of memory (because the entire object graph doesn't need to be stored in memory) and that keys within JSON objects (aka dictionaries) are guaranteed to be returned in the same order they appear in the file (the order of keys in an NSDictionary is arbitrary and undocumented). Delegate methods are called synchronously, however the method is thread safe so you can perform the parsing on a background thread to avoid blocking the UI. The FXJSONDelegate methods are documented below.

    + (id)objectWithJSONEncodedString:(NSString *)string;

Parses a string as JSON data and returns the object. Note that this is less efficient than using `objectWithJSONData` as the string must first be converted from UTF16 to UTF8 bytes before parsing.

    + (id)objectWithJSONData:(NSData *)data;

Parses a string of UTF8 JSON data and returns the object.

FXJSONDelegate Methods
-------------------------

    - (void)didStartJSONParsing;

This is called immediately before parsing begins.

    - (void)didStartJSONArray;

This is called when the parser encounters the beginning of a JSON array.

    - (void)didStartJSONObject;

This is called when the parser encounters the beginning of a JSON object (aka a dictionary).

    - (void)didFindJSONKey:(NSString *)key;

This is called when the parser encounters a key within a JSON object.

    - (void)didFindJSONValue:(id)value;

This is called when the parser encounters a value within a JSON object or array (or the root object of the file). Note that this is only called for non-collection type values. When JSON objects or arrays are encountered then the `didStart...` methods will be called instead.

    - (void)didEndJSONObject;

This is called when the parser encounters the end of a JSON object.

    - (void)didEndJSONArray;

This is called when the parser encounters the end of a JSON array.

    - (void)didEndJSONParsing;

This is called when the end of the document is reached. This may not be called in the event of an error being encountered.

Notes
----------------

FXJSON always returns mutable container objects (NSMutableArray or NSDictionary) so you can efficiently manipulate the data after it is returned.

FXJSON always returns *immutable* strings.

FXJSON will accept any root object type as long as it is valid JSON, so the object returned may be an NSMutableDictionary, NSMutableArray, NSString, NSNumber or NSNull.

Performance
-----------------

FXJSON is not the fastest JSON parser, but it's far from the slowest. In stats it ranked 4th out of the 6 most popular 3rd party JSON parsers.

It's worth noting that since FXJSON automatically defaults to using NSJSONSerialization on iOS5, it would actually rank second if that option was enabled (as it is by default).

    JSONKit                     10.942 ms
    NextiveJson                 37.001 ms
    YAJL                        55.896 ms
    FXJSON                      65.618 ms
    SBJson                      78.108 ms
    TouchJSON                  113.995 ms

    NSJSONSerialization         32.044 ms

Comparison performed on iOS 5.1 on an iPhone 4S. Tests were conducted with the `FXJSON_OMIT_NULL_OBJECT_VALUES`, `FXJSON_OMIT_NULL_ARRAY_VALUES` and `FXJSON_USE_NSJON_IF_AVAILABLE` options disabled. Check out the benchmark app for yourself here:

https://github.com/nicklockwood/json-benchmarks

license: Zlib

repository: nicklockwood/FXJSON

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: nicklockwood/FXJSON


text:
# MultiVariate Polygenic Mixture Model (MVPMM)
## Christopher DeBoever and Manuel A. Rivas
This directory contains the MultiVariate Polygenic Mixture Model (MPVMM) for
estimating genetic parameters as described in
[DeBoever et al. 2019](https://www.biorxiv.org/content/10.1101/738856v2).

MVPMM takes as input GWAS summary statistics (estimated effect sizes and
standard errors) for two phenotypes and estimates genetic parameters such as
genetic correlation, polygenicity, and scale of genetic effects for the
phenotypes. Please see [the manuscript](https://www.biorxiv.org/content/10.1101/738856v2) for more
information on MVPMM.
<img src="https://www.biorxiv.org/content/biorxiv/early/2019/08/21/738856/F4.large.jpg"  />

## Running MVPMM

MVPMM is specified in the `mvpmm.stan` file. We've included a helper script
`mvpmm.R` for running MVPMM using [rstan](https://cran.r-project.org/package=rstan).
`mvpmm.R` has the following arguments:

1. `data.fn`: File containing summary statistics.
data.fn
2. `out.fn`: File to save output to.
out.fn
3. `hdf5`: Save to HDF5. If FALSE, save as RData file.
4. `mcmc`: If `mcmc=TRUE`, then do an MCMC run. Otherwise, use Stan's
   optimization function to perform maximum a posteriori estimation.
5. `niter`: Number of MCMC iterations or number of draws for optimization.
6. `warmup`: Number of MCMC warmup iterations. Ignored for optimization.
7. `chains`: Number of MCMC chains. Ignored for optimization.
8. `cores`: Number of cores (should probably be the same as the number of
chains). Ignored for optimization.
9. `mvpmm.fn`: Stan file to use.

## Input File Format

An input file is a tab-separated file with an index column followed by these
columns:

* `ID`: Variant ID (e.g. rsID)
* `BETA`: GWAS effect size estimate
* `SE`: Standard error of GWAS effect size
* `P`: Unadjusted p-value from GWAS
* `code`: Phenotype label

The variant IDs contained in the `ID` column should not be repeated within a
phenotype. Each variant should be present for each phenotype. Take care to LD
prune variants prior to creating the input file and make sure that the effect
alleles are consistent between GWAS studies.

This is an example of a few lines from an input file:

```
              ID      BETA        SE         P code
1085   rs1001495 -0.072786  0.036405  0.045570   RA
6055   rs1001495  0.029559  0.051766  0.567996  SLE
1530  rs10025152 -0.021224  0.024549  0.387300   RA
6500  rs10025152 -0.020203  0.030855  0.512618  SLE
1385  rs10031922  0.075478  0.046814  0.106900   RA
6355  rs10031922  0.009950  0.103314  0.923273  SLE
```

There is an example input file included at `example/mvp_input.tsv.gz`.

## Example

The file `example/mvp_input.tsv.gz` is an example input file created from
GWAS summary statistics for family history of high blood pressure and essential
hypertension in the UK Biobank. Note that the variants included in this file
have been LD-pruned.

We can run MVPMM using Stan's optimization function for 100 iterations for
these GWAS summary statistics using the following command:

	Rscript mvpmm.R example/mvp_input.tsv.gz mvp_output.RData FALSE FALSE 100 0 1 1 mvpmm.stan

We can perform an MCMC with 100 burn-in iterations run as follows:

	Rscript mvpmm.R example/mvp_input.tsv.gz ra_sle.RData FALSE TRUE 400 100 1 1 mvpmm.stan

You can change into the `example` directory and use `bash run.sh` to run an
optimization example.

license: MIT

repository: Leandromvelez/mvpmm

repo_name: Leandromvelez/mvpmm


text:
![Change Colors](../../week-2/imgs/screenshot1.png)
![Column Change](../../week-2/imgs/screenshot2.png)
![Row Change](../../week-2/imgs/screenshot3.png)
![Make Equidistant](../../week-2/imgs/screenshot4.png)
![Make Squares](../../week-2/imgs/screenshot5.png)
![Change Footer](../../week-2/imgs/screenshot6.png)
![Move Header](../../week-2/imgs/screenshot7.png)
![Make Sidebar](../../week-2/imgs/screenshot8.png)
![Get Creative](../../week-2/imgs/screenshot9.png)

How can you use Chrome's DevTools inspector to help you format or position elements?
We can open the DevTools inspector on a Mac from the main application manu bar select View than Developer than Developer Tools once there we select the Element tab that is the structure of the we page, there we can add or change the  positions of any elements of that page.It is fast way of showing us how the page will look like , once we love how it was styled we save the changes.
How can you resize elements on the DOM using CSS?
I think add a height and width properties or if they had it already change the number of it instead height:5em; make them height:8em; same for the width ,
What are the differences between absolute, fixed, static, and relative positioning? Which did you find easiest to use? Which was most difficult?
Absolute -positions to the top-left of its nearest parent,
Fixed -positions kinda sticks to the browser window , it doesn't scroll together with the document .
Static- positions the way the element will appear in its normal flow , it will pretty much not make any diference if you add a static position or not ...please corect me if i am wrong that is how i got it.
Relative-positions relative to the page margins of the document,(i also need and additional explanation on tis one).
The easiest to use was the fixed and the most difficult is the relative i definitely  need to do some more research on this.
What are the differences between margin, border, and padding?
Padding is the space thats inside the element between the content and the border and goes around all four sides of the content, Border is the space between the padding and the margin same as padding goes around all four sides of the content, Margin is the space between the border and the next content, that space outside the border  is called margin.
What was your impression of this challenge overall? (love, hate, and why?)
It is not easy for sure , but i would love to have more time to play with it, so much more to learn , and i love it because you can do so many things, it is just amazing.

gha_language: HTML


text:
[![Build Status](https://travis-ci.org/dgarlitt/release_notes_generator.svg?branch=master)](https://travis-ci.org/dgarlitt/release_notes_generator)
[![Coverage Status](https://coveralls.io/repos/github/dgarlitt/release_notes_generator/badge.svg?branch=master)](https://coveralls.io/github/dgarlitt/release_notes_generator?branch=master)

# Release Notes Generator
***

This is a python based library for generating release notes (in markdown) from a project's commit log (for a given tag) and pushing the release notes to a wiki repository. A tag is compared to the previous tag (if one exists) to get a list of commits. These commits are then parsed to extract ticket/issue numbers, messages and author info to be used for the generated release notes. The cleaner and more relevant the commit messages are, the more useful the generated release notes become. This encourages developers to provide clean, meaningful commit history that summarize their work and associates it with an issue before merging it into a mainline branch.

### Setup
***

 - Clone the project you want to generate release notes from
 - Clone the wiki where you want to post release notes to
 - Clone and `cd` into this project `git clone git@github.com:dgarlitt/release_notes_generator.git && cd $_`
 - Edit the ```props.json``` file
    - Paths specified in this file can be absolute or relative and can optionally have a slash on the end
    - Update any regex patterns to fit your project needs

### Usage
***

The `main.py` script is the main script that triggers the generation of release notes. There is a props.json file in the same directory that can be used to configure the script to fit an individual's development environment. The main script can take one of two arguments.

To generate release notes for all release tags past to present, it can be run as:

```sh
./main.py all
```

To generate release notes for an individual release tag, run:

```sh
./main.py <IP_ADDRESS>
```

where __<IP_ADDRESS>__ would be substituted for an individual release number.

Each time release notes are generated, the index file is updated to contain a link to the newly created release notes.

After the release notes are generated, the script will automatically add, commit and push the changes to the wiki.

Release notes are derived from the release tags in your git repository. It is assumed that release tags in your project contain the release's version number. A regex pattern can be specified to recognize your version numbers. Also, a __prefix__ and/or a __suffix__ can be set to identify release tags.

For instance, if the prefix is __project-v__ and the suffix is __-release__ and the version number pattern is __\\d.\\.\\d\\.\\d\\.\\d__, then the generator will find all tags matching the pattern:

```
project-v\d.\.\d\.\d\.\d-release
```

Therefore, you can conclude that the following tag names will match the pattern:

```
project-v<IP_ADDRESS>-release

project-v<IP_ADDRESS>-release

project-v<IP_ADDRESS>-release
```

### Running the unit tests
***

You will need the following python libraries installed to run the tests:

```
nose
mock
coverage
```

These can be installed either through [easy_install](https://pythonhosted.org/setuptools/easy_install.html) or [pip](https://pypi.python.org/pypi/pip). If you are using pip,
then simply run the following command from the same directory as ```main.py```:

```
pip install -r requirements.txt
```

To run the tests, ```cd``` into the ```scripts/release_notes_gen``` directory and then run:

```
nosetests --nocapture
```

To see a coverage report, run:

```
nosetests --nocapture --with-coverage --cover-erase --cover-package=lib
```


text:
---
permalink: /1.18/core/v1/persistentVolumeClaimSpec/
---

# package persistentVolumeClaimSpec

PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes

## Index

* [`fn withAccessModes(accessModes)`](#fn-withaccessmodes)
* [`fn withAccessModesMixin(accessModes)`](#fn-withaccessmodesmixin)
* [`fn withStorageClassName(storageClassName)`](#fn-withstorageclassname)
* [`fn withVolumeMode(volumeMode)`](#fn-withvolumemode)
* [`fn withVolumeName(volumeName)`](#fn-withvolumename)
* [`obj dataSource`](#obj-datasource)
  * [`fn withApiGroup(apiGroup)`](#fn-datasourcewithapigroup)
  * [`fn withKind(kind)`](#fn-datasourcewithkind)
  * [`fn withName(name)`](#fn-datasourcewithname)
* [`obj resources`](#obj-resources)
  * [`fn withLimits(limits)`](#fn-resourceswithlimits)
  * [`fn withLimitsMixin(limits)`](#fn-resourceswithlimitsmixin)
  * [`fn withRequests(requests)`](#fn-resourceswithrequests)
  * [`fn withRequestsMixin(requests)`](#fn-resourceswithrequestsmixin)
* [`obj selector`](#obj-selector)
  * [`fn withMatchExpressions(matchExpressions)`](#fn-selectorwithmatchexpressions)
  * [`fn withMatchExpressionsMixin(matchExpressions)`](#fn-selectorwithmatchexpressionsmixin)
  * [`fn withMatchLabels(matchLabels)`](#fn-selectorwithmatchlabels)
  * [`fn withMatchLabelsMixin(matchLabels)`](#fn-selectorwithmatchlabelsmixin)

## Fields

### fn withAccessModes

```ts
withAccessModes(accessModes)
```

AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1

### fn withAccessModesMixin

```ts
withAccessModesMixin(accessModes)
```

AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1

**Note:** This function appends passed data to existing values

### fn withStorageClassName

```ts
withStorageClassName(storageClassName)
```

Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1

### fn withVolumeMode

```ts
withVolumeMode(volumeMode)
```

volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.

### fn withVolumeName

```ts
withVolumeName(volumeName)
```

VolumeName is the binding reference to the PersistentVolume backing this claim.

## obj dataSource

TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.

### fn dataSource.withApiGroup

```ts
withApiGroup(apiGroup)
```

APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.

### fn dataSource.withKind

```ts
withKind(kind)
```

Kind is the type of resource being referenced

### fn dataSource.withName

```ts
withName(name)
```

Name is the name of resource being referenced

## obj resources

ResourceRequirements describes the compute resource requirements.

### fn resources.withLimits

```ts
withLimits(limits)
```

Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/

### fn resources.withLimitsMixin

```ts
withLimitsMixin(limits)
```

Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/

**Note:** This function appends passed data to existing values

### fn resources.withRequests

```ts
withRequests(requests)
```

Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/

### fn resources.withRequestsMixin

```ts
withRequestsMixin(requests)
```

Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/

**Note:** This function appends passed data to existing values

## obj selector

A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.

### fn selector.withMatchExpressions

```ts
withMatchExpressions(matchExpressions)
```

matchExpressions is a list of label selector requirements. The requirements are ANDed.

### fn selector.withMatchExpressionsMixin

```ts
withMatchExpressionsMixin(matchExpressions)
```

matchExpressions is a list of label selector requirements. The requirements are ANDed.

**Note:** This function appends passed data to existing values

### fn selector.withMatchLabels

```ts
withMatchLabels(matchLabels)
```

matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.

### fn selector.withMatchLabelsMixin

```ts
withMatchLabelsMixin(matchLabels)
```

matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.

**Note:** This function appends passed data to existing values

gha_language: Jsonnet


text:
---
title: "049"
fact: "The name 'Noel' means 'Christmas'. It derives from the old French 'Noël' (Christmas), which itself derives from the Latin word 'natalis' (birth). Churches used 'natalis dies' (birth day) when they talked about the birth of Christ."
---

repository: boyum/noel

repo_name: boyum/noel


text:
# Überauth Paypal

> Paypal OAuth2 strategy for Überauth.

## Installation

1. Setup your application at [https://developer.paypal.com](https://developer.paypal.com).

1. Add `:ueberauth_paypal` to your list of dependencies in `mix.exs`:

    ```elixir
    def deps do
      [{:ueberauth_paypal, "~> 0.2.0"}]
    end
    ```

1. Add the strategy to your applications:

    ```elixir
    def application do
      [applications: [:ueberauth_paypal]]
    end
    ```

1. Add Paypal to your Überauth configuration:

    ```elixir
    config :ueberauth, Ueberauth,
      providers: [
        paypal: {Ueberauth.Strategy.Paypal, []}
      ]
    ```

1.  Update your provider configuration:

    ```elixir
    config :ueberauth,
      Ueberauth.Strategy.Paypal.OAuth, [
        client_id: System.get_env("PAYPAL_CLIENT_ID"),
        client_secret: System.get_env("PAYPAL_CLIENT_SECRET"),
        sandbox: false
      ]
    ```
    Note: the sandbox option, in your dev and test you might want to set this to true. The sandbox has different API credentials.

1.  Include the Überauth plug in your controller:

    ```elixir
    defmodule MyApp.AuthController do
      use MyApp.Web, :controller
      plug Ueberauth
      ...
    end
    ```

1.  Create the request and callback routes if you haven't already:

    ```elixir
    scope "/auth", MyApp do
      pipe_through :browser

      get "/:provider", AuthController, :request
      get "/:provider/callback", AuthController, :callback
    end
    ```

1. Your controller needs to implement callbacks to deal with `Ueberauth.Auth` and `Ueberauth.Failure` responses.

For an example implementation see the [Überauth Example](https://github.com/ueberauth/ueberauth_example) application.

## Calling

Depending on the configured URL you can initialize the request through:

    /auth/paypal


text:
# Pandoc

Most of the Dockerfile to build pandoc is taken from [portown/alpine-pandoc](https://github.com/portown/alpine-pandoc),
adding the stylesheet, `doc-docs.sh` and heads and tails.

## Building the image

Building pandoc may take a while. Only the `gfm` part is needed, so this image could (should)
probably be made a lot smaller (currently ~231MB). Only the first build is slow.

To compile pandoc from source, adding doc-docs configs:

`docker build -t doc-docs .`

Changing `doc-docs.sh`, or page heads/tails won't take much time. `run.sh` will rebuild your image,
so you can adjust those quickly.

## Converting pages

`doc-docs.sh` will recursively convert `*.md` in the current directory to static `*.html`
files, put them into `static_files` and create an index. It keeps the directory structure and
takes care of updating paths to `style.css`, so everything looks pretty when you view it :smile:

To only convert the files, run:

`docker run -v $PWD:/data:ro -v $PWD/static_files:/data/static_files:rw doc-docs`

You can then navigate to your `*.html` files in the browser.

# Infra setup

To launch Nginx to view your files:

`docker run -v $PWD/static_files:/usr/share/nginx/html:ro -p 8080:80 nginx`

To enable search, you also need PHP and the included code. Have a look at the included
`compose_infra.yml`, `run.sh`, `config/php/search.php` and `config/nginx/sites.conf`. All code is
very basic, so you can adjust those to your needs.

repository: jbauers/doc-docs

repo_name: jbauers/doc-docs


text:
# async-array-wrapper

This lib wraps an array object and intercepts all iterable functions and also them to be run asynchronously.

What this is not, is a lib like [async-array](https://www.npmjs.com/package/async-array). When an array is iterated with
`async-array-wrapper`, the callback function provided on the array is executed **synchronously**, but provides a `done`
function to call to signal the the iterator function is truly finished.

This lib is designed to allow for arrays to be iterated then processed with asynchronous functions.

## Install

Add `async-array-wrapper` to your package.json.

```bash
    npm install async-array-wrapper --save
```

## Example

```javascript
const fs = require('fs');
const AsyncArray = require('async-array-wrapper');

/*
 Here we want to list all sub directories within a directory. fs lends itself to asynchronous execution which we normally
 would be unable to do with the out of the box Array.map. Here, this lib is favoured over other libs, as it initiates all
 calls to the filesystem synchronously, instead of waiting for each one to finish before initiating the next one. Thus
 improving speed of execution in these kinds of situations (similarly benefits http requests).
 */

const directory = './';
const directoryMap = null;
fs.readdir(directory, 'utf-8', (err, files) => {
  new AsyncArray(files)
    .filter((done, _) => _.substr(0, 1) !== '.')
    .map((done, file) => {
      fs.stat(`${directory}/${file}`, (err, stats) => {
        if (stats.isDirectory()) {
          done(file);
        } else {
          done(null);
        }
      });
    })
    .filter((done, directory) => directory !== null)
    .then(function (done, result) {
      /* Will list all directories under `directory` */
      console.log('Found these directories:');
      console.log(result);
    });
});

```

## Usage

The following functions are intercepted (where available):
* forEach
* map
* every
* filter
* find
* findIndex
* reduce - use only with an object as an initialValue (no primitives)
* reduceRight - use only with an object as an initialValue (no primitives)
* some

The only difference to their Array.* equivalent is that they are passed a `done` function as the first argument, the
standard arguments are then passed after. See [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
for standard arguments that follow on each function.

You then have two options, either return a value from your callback, or use the `done` function. If you return any value
other than `undefined`, the `done` function is implicitly called for you.

Other non-callback taking functions on array won't automatically be queued. This is on purpose, as they **aren't**
chainable. If you need to do something with these, you must use the new `AsyncArray.then` function.

This can be inserted anywhere in the chain, and as such is chainable. This exposes a `done` function, then a `result`
array. For example;

```javascript
const AsyncArray = require('async-array-wrapper');
const { async } = AsyncArray.utils;

new AsyncArray([1, 2, 3, 4])
  .filter((done, entry, i) => {
    /* pretend to do something asynchronous... */
    async(() => {
      /* keep odd entries only... */
      const shouldFilterOut = i % 2 === 0;
      done(shouldFilterOut);
    })
  })
  .then((done, result) => {
    console.log(`The first entry is: ${result.slice(0, 1)}`);
    /*  The first entry is: 1 */

    console.log(`The last entry is now: ${result.slice(result.length - 1)}`);
    /*  The last entry is now: 3  */

    console.log(`Our result is: [${result.join(',')}]`);
    /*  Our result is: [1,3] */
  });

```

## Todo

* Test all remaining wrapped methods
    * map
    * every
    * filter
    * find
    * findIndex
    * reduce
    * reduceRight
    * some

repository: raininglemons/async-array-wrapper

repo_name: raininglemons/async-array-wrapper


text:
# Project summary
## One-sentence description
Crowd-controlled venue DJ system where users can suggest, vote for, or skip songs.
## Project overview
A voting-based system to determine the next song(s) to play enables
the crowd to control what they listen to; the most popular song (desired
by the most people) will always be played. Additionally, a skip feature can
enable users to vote to skip the current song being played. Some venues
may want to limit the type of music being played, e.g. a middle school
dance would likely only want non-explicit songs to be played. Users of
the app, not only enterprise/business partners can host their own ad-hoc
"venues" where other users can connect and vote on the next few songs.
Hosts can choose the threshold for number of votes required to skip the
current song and/or queue the next song. In certain cases, the host can
grant permission to only a handful of specific users to vote or select the
next song. A scoring system will reward users for consistently suggesting
songs that have been selected by voters or punish users for selecting songs
that are frequently skipped, in the form of cosmetic flairs. A scoreboard
will serve as a means of comparing user contributions and keep users engaged and motivated in the service. Per-venue statistics exposed to the
host after an event will allow the host to get insightful data about the music played and the engagement of the audience.
# Components
## [facilitator](https://github.com/cs48-next/facilitator)
Facilitates interaction between clients and venues.
## [frontend](https://github.com/cs48-next/frontend)
Connects with music player API to enumerate songs and sends vote/skip requests to facilitator.
# Installation
See installation details in each of the above repositories.
# License
[Apache License 2.0](LICENSE)
<!---
Add a README.md file. It must have the following headings that you will fill in as you develop your project:
"Project summary" with subsections "One-sentence description" and "Project overview" with 1-2 paragraphs of project specifics
"Installation" with subsections "Prerequisites" and "Installation Steps"
"Functionality and Known Issues"
"License" -- add details here on your choice of license and a link to your LICENSE file.
-->


text:
Dev: [![CircleCI](https://circleci.com/gh/mastoj/protoactor-fsharp.svg?style=shield)](https://circleci.com/gh/mastoj/protoactor-fsharp)
Master: [![CircleCI](https://circleci.com/gh/mastoj/protoactor-fsharp/tree/master.svg?style=shield)](https://circleci.com/gh/mastoj/protoactor-fsharp)

# FSharp wrapper on top of proto.actor

Functional languages usually fits quite well with the actor framework, so having
a good support for F# in proto.actor make sense.

Proto.actor: https://github.com/AsynkronIT/protoactor-dotnet/

## Getting started

Most of the examples below is from the `example01basicactors` example in the
`examples` folder. There are also some other examples in the `examples` folder
if you need it.

### Simple actor

After you have added `Proto.FSharp` from nuget it is super easy to get started,
so let us start our first actor:

    let pid = Actor.create (printfn "Hello from actor: %A") |> Actor.initProps |> Actor.spawn
    "Hello world" >! pid

The first line spawns and actor and returns the `pid`, on the next we send a
message to `pid`.

### Responding actor

If you want to reply back to the sender you need to use another helper to create
the actor:

    let handler (context: Proto.IContext) (msg: obj) =
        match msg with
        | :? String as s -> sprintf "You said: %s" s >! context.Sender
        | x -> printfn "Unhandled message: %A" x

    let pid = Actor.create2 handler |> Actor.initProps |> Actor.spawn
    "Hello world" >? pid |> Async.RunSynchronously |> printfn "Response: %A"

`Actor.create2` expects a function that takes `IContext` in addition to the
message as input. When you have the `IContext` you can just send a message back
to `IContext.Sender`, or use `IContext.Repond(...)`.

### Simple actor with state

There is also a simple helper that you can use if you want to create an actor
that has state.

    let handler msg state =
        let state' = sprintf "%s %s" (state.ToString()) (msg.ToString())
        printfn "Current state: %A" state'
        state'

    let pid = Actor.withState handler "" |> Actor.initProps |> Actor.spawn
    "Hello world" >! pid
    "Hello world again" >! pid

`Actor.withState` creates an actor with an initial state that you pass in after
the handler function. The returning state from that function will be passed as
argument to the next message handling.

### Responding actor with state

This example combines all of the above to one slightly more complex example.

    let handler (context: Proto.IContext) (msg: obj) state =
        let state' =
            match msg with
            | :? String as s ->
                let state' = sprintf "%s %s" (state.ToString()) (msg.ToString())
                sprintf "Current state: %A" state' >! context.Sender
                state'
            | x -> state
        state'
    let pid = Actor.withState2 handler "" |> Actor.initProps |> Actor.spawn
    "Hello world" >? pid |> Async.RunSynchronously |> printfn "Response: %A"
    "Hello world again" >? pid |> Async.RunSynchronously |> printfn "Response: %A"

Here we use the `Actor.withState2` to both have state, and also have access to
the `IContext` so we can send a message back to the sender.

### Taking more control

If you need to take even more control and the helpers `Actor.create`,
`Actor.create2`, `Actor.withState` and `Actor.withState2` isn't enough you can
use the `proto { ... }` computation expression do control how you receive a
message. The following example is the same as above, but here we use `proto`
instead.

    let handler (actor: Actor<obj>) =
        let rec loop state =
            proto {
                let! (ctx, msg) = actor.Receive()
                let state' =
                    match msg with
                    | :? String as s ->
                        let state' = sprintf "%s %s" (state.ToString()) (msg.ToString())
                        sprintf "Current state: %A" state' >! ctx.Sender
                        state'
                    | x -> state
                return! loop state'
            }
        loop ""

    let pid = handler |> Actor.initProps |> Actor.spawn
    "Hello world" >? pid |> Async.RunSynchronously |> printfn "Response (comp): %A"
    "Hello world again" >? pid |> Async.RunSynchronously |> printfn "Response (comp): %A"

It is not much more complicated, but by using the `proto` computation expression
we can now wait for messages with `actor.Receive`. This approach also makes it
easier to create some initial state or do other setup steps in the actor.

## Cluster

No helpers has been implemented around the cluster at the moment, since it is
easy to use the regular .NET API works fine at the moment.

repository: mastoj/protoactor-fsharp

branch_name: refs/heads/dev

gha_language: F#

gha_license_id: MIT

repo_name: mastoj/protoactor-fsharp


text:
# Drayton Wiser Home Assistant Integration v3.0.20

## IMPORTANT - PLEASE READ 'UPDATING TO V3.0' BELOW BEFORE UPGRADING!

This repository contains a Home Assistant component + platforms, for the awesome Drayton Wiser Heating solution.

For the latest version of the Wiser Home Assistant Platform please use the master branch or better still install via HACS. if you want bleeding edge then checkout the dev branch, or look out for beta releases via HACS. Depending on what you choose you may need to use the Manual Code Installation described below.

For more information checkout the AMAZING community thread available on https://community.home-assistant.io/t/drayton-wiser-home-assistant-integration/80965

---
## Contents

- [Minimum Requirements](#minimum-requirements)
- [Updating to v3.0 from v2.x](#updating-to-v30---important-please-read)
- [V3.0 New Features](#v30-new-features)
- [Issues & Questions](#issues-and-questions)
- [Functionality of this Integration](#functionality)
- [Installing](#code-installation)
- [Configuration](#configuration)
- [Managing Schedules with Home Assistant](#managing-schedules-with-home-assistant)
- [Network Topology](#network-topology)
- [Battery Values](#battery-values)
- [Community and Recipes](#community)
- [Contributors](#contributors)
- [Change Log](#change-log)

## Minimum Requirements

Requires a minimum of HA 2021.12.  This is needed to support the new button functionality and changes to config flow.
Requires the new WiserHeatAPIv2 api.

## Updating to v3.0 - IMPORTANT PLEASE READ!

Some of the great new functionality below has only been possible by making some major changes to the integration code and how HA entities are registered.  As such, when upgrading a number of existing entities in v2 will be replaced with new ones and the old ones will show unavailable.

If you have custom scripts or automations for this integration, they are likely to break.  Equally, your Lovelace dashboards will also need updating with the new entities.

We have tried hard to find a way to not have this as such a disruptive change but are unable to do so.  As such, please understand you may have quite a bit of work to reset your setup after upgrading to this.

In most cases, it will be easier to remove the old integration and add this from new.

However, we hope that many of the things our community has had to create with scripts or automations will now have a much simpler way to do it anyway and we can better maintain this setup going forward so future upgrades will be straight forward.

## v3.0 New Features

We are very excited to bring you this massive update to our Wiser integration for Home Assistant.  Our user community has been hugely helpful in suggesting enhancements and sharing the way they use this integration and we love that you love it.

We have had a number of open issues for new feature requests for some time and the integration and the api were getting a little cumbersome to keep adding in these requests.

As such, this v3.0 release is pretty much a full rewrite of both the api and the integration to enable us to more quickly and easily add new functionality as either our user community requests it or Wiser themselves add new things to the hub.

Below is a list of the new features in this upgrade (these are in addition to the already existing great functionality!):

- System Setup
  - Hub discovery via zeroconf. Once you add the integration via HACs and restart, HA will discover the hub and display it in the integrations page.
  - Support for multiple Wiser Hubs.  If you are lucky enough to have more than one house, you can add your multiple hubs to one HA instance.

- Hub/System
    - Button to boost all rooms
    - Button to cancel all heating overrides
    - Daylight saving setting can now be controlled
    - Number slider to view and set Away Mode target temperature
    - Attributes on Heating Operation sensor to monitor hub update success
    - Support for Wiser Moments - see Moments below
    - Long term stats sensors for heating channel and hotwater demand - see LTS sensors below

- Hot Water
    - Button to boost hot water
    - Button to cancel hot water overrides
    - Button to toggle on/off.  In auto mode this is an override until next schedule time.
    - Hot water mode selector to allow setting via UI instead of just service
    - Hot water operation mode sensor to show boost (with remaining time), override, away mode, auto or manual

- Rooms
    - New switches to control open window detection in each room
    - Ability to advance the room schedule via the presets
    - Long term stats sensors for temp, target_temp and room demand - see LTS sensors below
    - Displays remaining boost time for room on climate entity
    - Shows if EcoIQ or Comfort mode is driving room demand on climate entity
    - Arributes now show next temp setting and time from schedule
    - Attributes for is_boosted, is_override and is_heating to help with automations

- Devices
    - Turn on/off device lock
    - Enable identify function to flash leds on TRV
    - Device attributes now shows which smartplug is the zwave repeater
    - Signal entity renamed to be more explanatory

- SmartPlugs
  - Drop down selector to set smartplug mode
  - Switch to set smartplug to turn off when in away mode
  - Power sensors for current and total power

- Services
    - Majority of services now utilise new HA functionality to make using them in scripts and automations much easier through the UI.
    - New service to remove devices from HA if you have removed Rooms or Devices from Wiser
    - New service to boost hotwater for custom time period
    - New service to set smartplug mode
    - Schedule save, set and copy are now split between heating and onoff schedules
    - All new buttons, switches and selectors can be used with the relevant services for these entity types.

- Moments
    - Wiser have created a new feature called moments which are basically scenes.  Any moments you setup on the app will have a button within HA to activate too (you will need to restart HA to add new ones).  We don't enable this by default so you will need to enable moments in the integration config first.

- Long Term Stats
    - As listed in the categories above, we have added a number of LTS sensors for those in our community wanting to do more analysis of how their heating is performaing.  As HA only support these currently via sensors, this functionality can create a lot of entities.  Therefore, we have made it an optional feature that can be turned on and off in the integration config.

## Breaking Changes

- Many entity names and unique ids have changed meaning new entities will be created and the old ones will show as unavailable
- Standardisation of entity attribute names format meaning some attribute names are now different
- The structure and naming of some services has changed therefore scripts and automations will need updating

## Issues and Questions

As you can see, we have been oh so very busy adding new functions and trying to make it simple and intuitive.  We have done a lot of testing on this v3.0 release but as always, it is very hard to test all the possible setups out there.

As such, if you find an issue or have a how do I question, please feel free to raise a github issue on our repo or post you query to our HA Community page.

Issues
https://github.com/asantaga/wiserHomeAssistantPlatform/issues

Questions
https://community.home-assistant.io/t/drayton-wiser-home-assistant-integration/80965

Hope you enjoy it!
Mark & Angelo

## Functionality

- Support for [Home Assistant Component Store](https://community.home-assistant.io/t/custom-component-hacs/121727)

- Support for hub discovery and UI config.  No YAML editing.

- Support for multiple hubs
- Support for Wiser Hub, iTRVs, Roomstats, Heating Actuators and SmartPlugs
- Basic sensor support for Dimmable Lights and Shutters

- **Hub (System) Device**
    - Various switches to control hub settings (Away Mode, Comfort Mode, Daylight Saving, Eco Mode, Valve Protection)
    - Button to boost all rooms (time and temp in config)
    - Button to cancel all overrides
    - Slider to set Away Mode target temperature
    - Sensors for Cloud status, Heating on/off, Heating mode (Normal, Away), Wifi signal.
    - Long Term Statistics sensor for Heating Channel demand %
    - Many attributes available
    - Heating Operation Mode sensor has attributes to monitor update status

- **Climate Devices**
    - Climate entities for each Room
    - Supports iTRVs, Roomstats and Heating Actuators (for electric heating)
    - Animated icons for the Rooms to let you know which rooms are actually being heated (credit @msp1974)
    - Allows setting of heat mode (Auto, Heat/Manual, Off)
    - Allows setting of temperatures from HA
    - Allows setting of boost temperature using Home Assistant Presets
    - Climate card shows countdown of boost time
    - Allows advancing schedule
    - Allows setting Window Detection
    - Long Term Stats sensors for Target Temp, Current Temp and Demand
    - Many attributes available
    - Fires wiser_room_heating_status_changed event when room starts or stops heating

- **Hot Water**
    - Sensor to show if hot water is on or off
    - Sensor to show operation mode (Auto, Manual, Boost, Override etc)
    - Selector to set hot water mode (Auto, Manual)
    - Button to Boost hot water
    - Button to override hot water
    - Button to cancel hot water overrides

- **iTRV, Roomstat, Heating Actuator, Smart Plug, Lights & Shutter Devices***
    - Devices for the HeatHub, each iTRV, Roomstat, Heating Actuator, Smart Plug, Light & Shutter
    - Switches for Device Lock and Identify
    - Sensor for battery (if device is battery powered)
    - Sensor for Zigbee signal
    - Switches to set Away Mode action and On/Off for Smart Plug
    - Selector to set mode (Auto, Manual) for Smart Plug
    - Many attributes available

- **Moments**
    - Buttons to activate Moments configured in the Wiser App

- **Services**
    - Supports standard services for entity types
      - i.e. climate.set_temperature, climate.set_preset, climate.set_hvac_mode, button.press, select.option, switch.turn_on etc
    - Following custom services are available for use with automation
    - Service `boost_heating` : Provides ability to boost the heating in a particular room
    - Service `boost_hotwater` : Provides ability to boost the heating in a particular room
    - Service `get_heating_schedule/set_heating_schedule/copy_heating_schedule`: Provides ability to get/set/copy schedules for rooms
    - Service `get_onoff_schedule/set_onoff_schedule/copy_onoff_schedule`: Provides ability to get/set/copy schedules hot water and smartplugs
    - Service `set_smartplug_mode`: Provides ability to set the mode of a specific smartplug. It can be set to either `manual` or `auto` , the latter means it follows any schedule set.
        - NB : Setting the smartplug "state" is done by setting the state of the switch component.
    - Service `set_hotwater_mode`: Provides ability to set hot water mode to **manual** or **auto**. Valid values include `manual` or `auto` Setting it to auto makes it follow the current schedule
    - Service `remove_orphaned_entries`: Provides ability to remove HA devices for rooms/devices that have been removed from your hub.  Must have no entities.

## Sample Images

![](docs/screenshot.PNG)

![](docs/hub.PNG)

![](docs/room.PNG)

![](docs/trv.PNG)

![](docs/roomstat.PNG)

![](docs/smartplug.PNG)

![](docs/heatingactuator.PNG)

# Code Installation

We highly recommend using [HACS Home Assistant Community Store](https://github.com/hacs), for more information on how to install HACS please see their documentation website at https://hacs.xyz/

## Manual Code Installation

This method is best used when you want to play with the "latest and greatest" from the repository. Moving forward (post 1.9) , the github repository will contain two primary branches, **master** and dev. Master is the latest released, and hopefully most stable branch, whereas **dev** is the branch that we're currently working on.

1. On your server clone the github repository into a suitable directory using the following command
   git clone https://github.com/asantaga/wiserHomeAssistantPlatform.git

2. Switch to either the master or dev branch as per your requirements.
   e.g.
   `git checkout master`
   or
   `git checkout dev`

3. Create a `custom_components` directory within your Home Assistant directory config directory

4. Within the custom components directory copy the wiser folder, from the directory where you github cloned the wiser component, to your installations ```custom components``` directory.

# Configuration

## Find your HeatHub Secret key
Reference https://it.knightnet.org.uk/kb/nr-qa/drayton-wiser-heating-control/#controlling-the-system

Before you can use the component you need to find the HeatHub secret key, this involves a couple of steps.

1. On your hub, press the setup button and the led should flash.
2. Use your phone or tablet and connect to the wifi SSID (you should now see available) that is Wiserxx_xxxxxx
3. Once connected to this wifi network, open your browser and go to http://<IP_ADDRESS>/secret 1.
4. You can then copy your key to an email to send to another device or copy and paste into the HA config if setting up integration via your phone/tablet.
5. When finished, either wait for hub to revert to led on constant or repower it (quicker to repower). Must be in non flashing mode to setup integration.

6. Configure using Home Assistant Configuration -> Integrations where your hub should have been auto discovered

![](docs/discovery.PNG)

## Config Options
Select the configure link from the integrations page.  This will then show the config screen - now configure it appropriately.

![](docs/config.PNG)

`Default Heating Boost Temperature` is the delta temperature above the current room temperature the radiator should be set to when boosted, default is 2

`Default Heating Boost Duration` is the time (in minutes) for which a heating boost should be active for, default is 60 mins

`Default Hot Water Boost Duration` is the time (in minutes) for which a hot water boost should be active for, default is 60 mins

`Scan Interval` is the interval in second that the integration will update form the hub.  Do not set this too low as the hub will not be able to cope and you will see errors.  Default is 30.

`Enable Moments Buttons` is to create buttons for Moments you have setup on the wiser app.  Default is unticked.

`Enable LTS Sensors` is to create sensors for LTS for rooms and hub heating and hot water demand.  Default is unticked.

`Setpoint Mode` modifies the way setpoint works. If left to default then the functionality is the same as the Wiser app, if set to 'boost' then when you set a new setpoint it will only take affect for the default "boost" time.

## Managing Schedules with Home Assistant

### Getting a Schedule
Use the service `Save Schedule To File`

This will require you to provide the entity ID of the wiser device and a file to copy this schedule to.
It is recommended to create a directory in your config directory to store these.
See below for information on selecting the correct entity.

Note : If you are running HA within a docker container then the directory will be absolute to the container, if you have mapped the config directory to a local directory then all is good but the directory name given to the service must be a docker container address.

E.g. if you specify the filename as `/config/schedule.yaml` then `Save Schedule to File` writes the file into the directory within the container. Providing you have mapped the config directory (using the -v or volumes: in docker-compose) then you can read this from a host directory (e.g. /home/haconfig.

### Setting a Schedule
Use the service `Set Schedule From File`

This will require you to provide the entity ID of the wiser device and a file containing the schedule.
See below for information on selecting the correct entity.

A good place to start is to get a schedule from a device and see the file structure.  You can add times and temps within each day as you see fit.  As file created using the `Save Schedule To File` service looks like below:
```yaml
Name: Dining Room
Description: Schedule for Dining Room
Type: Heating
Monday:
  - Time: 07:30
    Temp: 21
  - Time: 08:30
    Temp: 15
  - Time: 16:30
    Temp: 20
  - Time: 22:30
    Temp: 15
Tuesday:
  - Time: 07:30
    Temp: 21
  - Time: 08:30
    Temp: 15
  - Time: 16:30
    Temp: 20
  - Time: 22:30
    Temp: 15
Wednesday:
  - Time: 07:30
    Temp: 21
  - Time: 08:30
    Temp: 15
  - Time: 16:30
    Temp: 20
  - Time: 22:30
    Temp: 15
Thursday:
  - Time: 07:30
    Temp: 21
  - Time: 08:30
    Temp: 15
  - Time: 16:30
    Temp: 20
  - Time: 22:30
    Temp: 15
Friday:
  - Time: 07:30
    Temp: 21
  - Time: 08:30
    Temp: 15
  - Time: 16:30
    Temp: 20
  - Time: 22:30
    Temp: 15
Saturday:
  - Time: 07:00
    Temp: 19
  - Time: 10:00
    Temp: 17
  - Time: 16:00
    Temp: 20
  - Time: 23:00
    Temp: 15
Sunday:
  - Time: 08:30
    Temp: 21
```
If you are creating your own file (or editing one you have copied from a wiser device), you can use the 2 special day
names of 'Weekdays' and 'Weekends' instead of listing individual days.

e.g.

```yaml
Name: Test Room
Description: Schedule for Test Room
Type: Heating
Weekdays:
  - Time: 07:30
    Temp: 21.5
  - Time: 08:30
    Temp: 15
  - Time: 16:30
    Temp: 20
  - Time: 22:30
    Temp: 15
Weekends:
  - Time: 07:00
    Temp: 19
  - Time: 10:00
    Temp: 17
  - Time: 16:00
    Temp: 20.5
  - Time: 23:00
    Temp: 15
```
You can also use a mixture of these special day names and normal days to override a specific day (providing the specific days names are below these special ones!).
```yaml
Name: Test Room
Description: Schedule for Test Room
Type: Heating
Weekdays:
  - Time: 07:30
    Temp: 21.5
  - Time: 08:30
    Temp: 15
  - Time: 16:30
    Temp: 20
  - Time: 22:30
    Temp: 15
Weekends:
  - Time: 07:00
    Temp: 19
  - Time: 10:00
    Temp: 17
  - Time: 16:00
    Temp: 20.5
  - Time: 23:00
    Temp: 15
Tuesday:
  - Time: 08:00
    Temp: 21.5
  - Time: 20:00
    Temp: 18.0
```

For hotwater and smartplugs (to make reading the schedule file easier) you can use time and state keys like below.  Note for both hot water and smartplugs, the Type parameter must be set to HotWater in your file.
```yaml
Name: Hot Water
Description: Schedule for Hot Water
Type: HotWater
Weekdays:
  - Time: 06:30
    State: On
  - Time: 10:30
    State: Off
  - Time: 16:30
    State: On
  - Time: 22:30
    State: Off
Weekends:
  - Time: 06:30
    State: On
  - Time: 10:30
    State: Off
  - Time: 16:30
    State: On
  - Time: 22:30
    State: Off
Tuesday:
  - Time: 08:00
    State: On
  - Time: 20:00
    State: Off
```

### Copying a Schedule
Use the service `Copy Schedule`

This will require you to provide an entity ID of the device to copy from and the entity ID of the device to copy to and will copy the schedule between them.

### What Entity Should I Choose?
- Room heating schedules - use the climate entity of the room.  eg climate.lounge
- Hot water on/off schedule - use the sensor.hotwater entity
- Smartplug on/off schedules - use the switch entity of the smart plug eg switch.smartplug1

## Network Topology

With V1.9 for TRVs you can now determine if the TRV is connected to the heathub directly or via a smartplug repeater.

Each TRV sensor now has three special network related attributes

| Attribute        | Meaning                                                      |
| ---------------- | ------------------------------------------------------------ |
| `Node Id`        | The node Id of the device                                    |
| `Parent Node Id` | If this value is zero (0) then the device is connected direct to the heathub. A non zero value points to the smartplug/repeater for which this device is being routed through. Smartplugs always have this value as zero |
| `Hub Route`      | Calculated convenience attribute which evaluates to either `direct` or `repeater` based on if the device is connected direct or not to the heathub |
| `Repeater` | Which actual device is acting as repeater |

## Battery Values

For each battery driven device sensor the following attributes are available `Battery Voltage`, `Battery Percentage` and `Battery Level`. From conversations with Wiser technical support they recommend changing the batteries for any TRV when it reaches battery voltage of "26" or *OneThird* battery level. Given that RoomStats do not need to drive a valve, their battery levels can be lower.

An obvious ideal candidate for a Home Assistant automation to remind you to change the batteries :-)

Note : If you power cycle your HomeHub, with more than a minute or so when it is off, we've noticed that the devices will not have the battery info for a short period of time (maybe 30mins to 1hr) , just wait and the battery values will appear.

# Community

I've been totally amazed at the community which has sprung up contributing and supporting this component.  The [recipes](Recipes.md) following page contains some community contributed ideas / YAML files for Home Assistant.

Checkout the community thread on https://community.home-assistant.io/t/drayton-wiser-home-assistant-integration/80965 for loads of input, comment and participate in our community

# Run, Play

***Run, Play*** and let us know if there are any bugs, enhancements etc via the github issues system

Special thanks for many contributors to this project!

Angelo, Mark and Team

# Contributors

Special thanks to all the contributors to this project.  Special shout to

- @msp1974     : V3, Animated graphics showing which rooms are being heated, Display Presets, support boost (PR38), Async Mode rewrite and loads more! Mark is now part of the core team helping me out whilst I deal with screaming babies wanting food :-)
- @angrycamel  : Home/Away Sensor
- @jchasey     : Doc changes and support for custom component updater
- @sjtbham     : Debugging
- @djbanks     : Home/Away switch (v 1.31)
- @nofuse       : Constantly helping people out on the community thread

And many many more, please see github pull requests for more info

Moving forward (post 1.9) there will be two primary branches, `master` and `dev` . Master will be the primary "production" branch and "dev" will be the branch used for development. Other branches will likely exist where we build code into and then merge into dev, which in turn gets merged into master when all is good and dandy.

# Change log
- 3.0.20
    * Bump api to 0.0.17
    * Improvements to connection handling and error reporting
    * Added attribute on climate entity for current schedule temperature setting
    * Added event to fire when room heating status changes (wiser_room_heating_status_changed)
    * Fix - switches do not always show state at restart
    * Fix - only update delivered power on SmartPlugs if above 0 to fix sporadic issue where value goes to 0 on hub update.
- 3.0.19
    * Fix error on load if SmartPlug does not belong to a room - issue #209
    * Added iTRV measured temperature to iTRV signal entity attributes (to be made sensor entities in a future release) - issue [#211](https://github.com/asantaga/wiserHomeAssistantPlatform/issues/211)
    * Fixed issue where boost service did not default to config boost temp if no temperature_delta or temperature value passed - issue [#216](https://github.com/asantaga/wiserHomeAssistantPlatform/issues/216)
    * Fixed issue whereby UI temp increase step was x.1 due to min value issue
    * Added additional wifi information attributes to Hub signal entity
    * Reverted connection to hub to use IP address instead of DNS name due to high number of issues using this method - issue #210
    * Removed unnecessary hub update on component load during server restart
    * Improved error handling for set_hvac and set_preset_mode if invalid option passed
    * Bump api to 0.0.16
- 3.0.18
    * Fix for devices that have no room association
    * Added back humidity and temp attributes to RoomStat signal sensor (to be made sensor entities in a future release)
- 3.0.17
    * Fix for room not having a schedule causes climate entity to fail to load
    * Fix for unknown device acting as repeater
    * Added back controller signal sensor that was removed in v3.0
    * Improved attributes for signal sensors
    * Bumped api to 0.0.14
    * Fix for HACs not properly showing documentation
- 3.0.16
    * Added support for heating actuators in devices
    * Added basic support for Shutters and Lights in devices
    * Bump api to 0.0.13
    * Improved handling of battery data
    * Changed model to use product_type as model_identifier not consistantly supplied for all devices
- 3.0.15
    * Fix for issue with single TRV device if multiple in a room - issue [#194](https://github.com/asantaga/wiserHomeAssistantPlatform/issues/194)
    * Fix for boost_all_rooms not setting temp correctly - issue [#180](https://github.com/asantaga/wiserHomeAssistantPlatform/issues/180)
    * Add ability to set target temp or temp delta for boost - like in v2.7
- 3.0.14
    * Fix error with smartplug total power not available in energy config - issue [#192](https://github.com/asantaga/wiserHomeAssistantPlatform/issues/192)192
    * Fix issue with zeroconf not using hostname
    * Fix issues with zeroconf not reporting errors on setup - issue #189
    * Add away mode target temperature number slider to view and set away mode temp - issue [#190](https://github.com/asantaga/wiserHomeAssistantPlatform/issues/190)
    * Removed last_updated attribute from device signal entities
    * Added last updated, mins since last updated and last update status attributes to Heating Operation sensor - issue [#191](https://github.com/asantaga/wiserHomeAssistantPlatform/issues/191)
- 3.0
    * See above for long list of new functionality
= 2.7
   * Various bug fixes and prep for V3 :-)
- 2.6beta6
    * Fix for broken scheduler services - sorry all!
- 2.6beta5
    * Amended manifest version to include 2 dot notation
    * Fixed label issue on config for setpoint mode
- 2.6beta4
   * Fixed issue caused by removal of ruamel.yaml from core
   * Added last updated attribute to wiserhub sensor
- 2.6beta3
   * Added setpoint mode to allow boosting on temp change instead of setting temp until next scheduled event
- 2.6beta
   * Added version to manifest.json
   * When cancelling boost the setpoint is returned correctly
   * New setpoint mode added (thanks @charlesomer)
- 2.5
   * Added water scheduling support
   * Fixed wiserhub doesnt update on server start
   * Upgraded to wiserapi 1.0.10
   * Added some new recipies to docs
- 2.4
   * Fixed deprecated devices
   * code changes to support publishing as a native HA component
   * Fixed issues with older firmware
   * Fixed issues with hubs with no rooms (new installs)
   * Added ability to manage schedules for all device types - rooms, hot water, smart plugs
   * Implemented new attribute on climate entities to show remaining boost duration
   * Improved handling of hub connection errors at startup
   * Fixed issue where component does not request update from wiser hub at startup

- 2.3
   * Fix for error given by latest HA highlighting that I/O Detected in event loop (issue 97)[https://github.com/asantaga/wiserHomeAssistantPlatform/issues/97]
   * Fix for climate graph not showing true state (issue 98)[https://github.com/asantaga/wiserHomeAssistantPlatform/issues/98]
   * Fixed heating boost (issue 101)[https://github.com/asantaga/wiserHomeAssistantPlatform/issues/101]
- 2.2
    * Battery voltage across sensor types now consistent (1 decimal place no v)
    * Implemented what we think is correct battery percentages depending on device (itrv or roomstat)
    * Regression of itrv sensors not having battery voltage fixed
- 2.1

    * Minor bug fixes and documentation fixes
- 2.0
    * Now supports Home Assistant Config Flow (credit @msp1974)
    * Fix/error for when there is no smartplug present, also error if smartplug exists but offline
    * Documented some community inspired (non obvious) recepies
    * Uptake of new wiser-heating-api (1.7.1)

- 1.9

    * Component rewritten to use Async to ensure the component is more robust and HA friendly

    * Ability to control SmartPlugs

    * Zigbee Network info now available

    * Ability to control hotwater (using a service)

    * Ability to get/set schedule using services

    * Ability to set/get system settings , like auto mode, eco mode etc

    * and Many more

      **BREAKING CHANGE** : We no longer support the custom component updater, please use HACS instead

- 1.8.1

    * Multiple fixes to timeouts, boost and upgrade to wiserapi 1.0.3
- 1.7
    * Presets and now supports delta boosts (thanks @msp1974)
    * BREAKING CHANGE : boost temp is now a delta and not a specific value  e.g.. now is 2C vs previously 20C
- 1.6.1

    * Fixed setting temperature bugs
- 1.6

    * Merged functionality where it now shows which rooms are being heated by an icon
- 1.5.1

    * Minor bump to fix home/away issue and bring versions inline
- 1.5

    * Now supports HACS
- 1.4
    * Major changes. Now uses pypi library
    * Uses new Climate Model (see https://developers.home-assistant.io/blog/2019/07/03/climate-cleanup.html)
    * Fix bug where updates weren't seen till new refresh cycle
    * Changes to make code HA native component compatible (more work to be done)
- 1.3.1

    * Merged djbanks Home/Away switch
- 1.3
    * Added ability to set temperature
    * Added ability to set room mode (auto,boost,manual)

repository: angrycamel/wiserHomeAssistantPlatform

gha_language: Python

repo_name: angrycamel/wiserHomeAssistantPlatform


text:
# SwiftyMarkdown 1.0

SwiftyMarkdown converts Markdown files and strings into `NSAttributedString`s using sensible defaults and a Swift-style syntax. It uses dynamic type to set the font size correctly with whatever font you'd like to use.

## Fully Rebuilt For 2020!

SwiftyMarkdown now features a more robust and reliable rules-based line processing and tokenisation engine. It has added support for images stored in the bundle (`![Image](<Name In bundle>)`), codeblocks, blockquotes, and unordered lists!

Line-level attributes can now have a paragraph alignment applied to them (e.g. `h2.aligment = .center`), and links can be underlined by setting underlineLinks to `true`.

It also uses the system color `.label` as the default font color on iOS 13 and above for Dark Mode support out of the box.

## Installation

### CocoaPods:

`pod 'SwiftyMarkdown'`

### SPM:

In Xcode, `File -> Swift Packages -> Add Package Dependency` and add the GitHub URL.

*italics* or _italics_
**bold** or __bold__
~~Linethrough~~Strikethroughs.
`code`

# Header 1

or

Header 1
====

## Header 2

or

Header 2
---

### Header 3
#### Header 4
##### Header 5 #####
###### Header 6 ######

	Indented code blocks (spaces or tabs)

[Links](http://voyagetravelapps.com/)
![Images](<Name of asset in bundle>)

> Blockquotes

- Bulleted
- Lists
	- Including indented lists
		- Up to three levels
- Neat!

1. Ordered
1. Lists
	1. Including indented lists
		- Up to three levels
1. Neat!

# SwiftyMarkdown 1.0

SwiftyMarkdown converts Markdown files and strings into `NSAttributedString`s using sensible defaults and a Swift-style syntax. It uses dynamic type to set the font size correctly with whatever font you'd like to use.

## Fully Rebuilt For 2020!

SwiftyMarkdown now features a more robust and reliable rules-based line processing and tokenisation engine. It has added support for images stored in the bundle (`![Image](<Name In bundle>)`), codeblocks, blockquotes, and unordered lists!

Line-level attributes can now have a paragraph alignment applied to them (e.g. `h2.aligment = .center`), and links can be underlined by setting underlineLinks to `true`.

It also uses the system color `.label` as the default font color on iOS 13 and above for Dark Mode support out of the box.

## Installation

### CocoaPods:

`pod 'SwiftyMarkdown'`

### SPM:

In Xcode, `File -> Swift Packages -> Add Package Dependency` and add the GitHub URL.

*italics* or _italics_
**bold** or __bold__
~~Linethrough~~Strikethroughs.
`code`

# Header 1

or

Header 1
====

## Header 2

or

Header 2
---

### Header 3
#### Header 4
##### Header 5 #####
###### Header 6 ######

	Indented code blocks (spaces or tabs)

[Links](http://voyagetravelapps.com/)
![Images](<Name of asset in bundle>)

> Blockquotes

- Bulleted
- Lists
	- Including indented lists
		- Up to three levels
- Neat!

1. Ordered
1. Lists
	1. Including indented lists
		- Up to three levels
1. Neat!

repository: SimonFairbairn/SwiftyMarkdown

gha_language: Swift

repo_name: SimonFairbairn/SwiftyMarkdown


text:
# UTD-CS-SE-Assignments

In this repository I have included all coding assignments and projects I have written in my time attending the University of Texas at Dallas, studying for my Computer Science and Software Engineering double major.

Each course directory will have its own README explaining the course and the assignments contained within.

## Hello Prospective Employers

The code in this repository is not the best representative of my capabilities, merely proof of what I have done studying at UTD.

My best projects are displayed on my personal webpage: http://rahatah.me/d

## Hello Prospective Plagarizers

You can't use my code for your class assignments. So don't.


text:
[![](https://godoc.org/github.com/jackc/pgtype?status.svg)](https://godoc.org/github.com/jackc/pgtype)
![CI](https://github.com/jackc/pgtype/workflows/CI/badge.svg)

---

This version is used with pgx `v4`. In pgx `v5` it is part of the https://github.com/jackc/pgx repository.

---

# pgtype

pgtype implements Go types for over 70 PostgreSQL types. pgtype is the type system underlying the
https://github.com/jackc/pgx PostgreSQL driver. These types support the binary format for enhanced performance with pgx.
They also support the database/sql `Scan` and `Value` interfaces and can be used with https://github.com/lib/pq.

repository: goharbor/harbor

branch_name: refs/heads/main

gha_language: Go

repo_name: goharbor/harbor


text:
*Note: this package is a work in progress and far from ready for production use*

# SQL Server extension for Yellicode
Generate SQL Server code using powerful TypeScript code generation templates! This [Yellicode](https://www.yellicode.com) extension lets you generate
SQL Server code from your Yellicode models.

License: MIT

## About Yellicode
Yellicode lets you build your own code generation templates with TypeScript. It consists of a Node.js CLI and extensible APIs, making it easy for developers to create, share and re-use code generators for their favorite programming languages and frameworks.

Check out [our website](https://www.yellicode.com) for more.

repository: yellicode/yellicode-sql-server

gha_language: TypeScript

repo_name: yellicode/yellicode-sql-server


text:
---
title: Make a POST request with fetch
description: A sample POST with fetch for those of us who can never remember how.
pubDate: 2020-08-07T12:00-0400
tags:
  - JavaScript
verse: Ruth 3:11
---

[`fetch` is utility for making HTTP requests](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) from the browser. It is [available in all modern browsers](https://caniuse.com/#feat=fetch) and has a [popular polyfill for older browsers](https://github.com/github/fetch).

To make a `GET` request, just pass the endpoint to the global `fetch` method:

```js
fetch("https://mirror-api.seanmcp.repl.co/get");
```

It returns a promise that will resolve with the server response. From there, you can convert the response to JSON and read the value in your code:

```js
(async function () {
  const response = await fetch("https://mirror-api.seanmcp.repl.co/get");
  const data = await response.json();
  console.log(data);
})();
```

But `fetch` also handles other request methods. After `GET`, the first you will reach for is `POST`. But it isn't immediately apparent how to make a request with a different method.

## How to `POST` with `fetch`

The global `fetch` function accepts a second options argument. There you can set the method, add a body, and set headers.

Here is an example POST request that sends a JSON body:

```js
fetch("https://mirror-api.seanmcp.repl.co/post", {
  method: "POST",
  body: JSON.stringify({ message: "Hello API!" }),
  headers: {
    "Content-Type": "application/json",
  },
});
```

Once you have the request in order, you can handle the promises and get the server response.

For more information on the available including examples with other methods, checkout [_Using Fetch_ on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch).

Happy fetching!

gha_language: Astro


text:
# Integrated Manager for Lustre software {{site.version}}

## **Help Docs**

## Table of Contents

### [**Online Help**](docs/IML_Help_TOC.md)

- Online Help documents for the Integrated Manager for Lustre software Graphical User Interface.

### [**Software Installation Guide**](docs/Install_Guide/ig_TOC.md)

- These documents provide detailed instructions for installing the Integrated Manager for Lustre software.

### [**Software API Documentation**](docs/api/api_TOC.md)

- An API reference for the Integrated Manager for Lustre software.

### [**Software Contributor Documentation**](docs/Contributor_Docs/cd_TOC.md)

- Documents for contributing to the Integrated Manager for Lustre software.

repository: nixuser/Online-Help

repo_name: nixuser/Online-Help


text:
esshader - offline ShaderToy viewer
===========================================
Simple offline ShaderToy-compatible GLSL shader viewer.

Requirements:
-------------
In order to build esshader you will need GLFW, OpenGL ES 2.0 development headers (libglvnd on arch) and SOIL installed on your system.
The program can also be demanding on GPU hardware, so the more powerful GPU you have, the better.

Installation:
-------------
Edit `config.mk` to match your local setup (the /usr/local prefix is used by default).

Afterwards enter the following command to build and install esshader (if necessary as root):

```
sudo make clean install
```

Running esshader
------------------
Simply invoke the 'esshader' command. To quit, press either
the Escape or Q key.

repository: cmcsun/esshader

gha_language: C

gha_license_id: NOASSERTION

repo_name: cmcsun/esshader