text:
# NavExplorer Node Indexer

This is a go application that watches for changes from the dnsseed.dump output of the [NavCoin Seeder](https://github.com/NAVCoin/navcoin-seeder) and indexes the results into an ElasticSearch index.

repository: NavExplorer/node-indexer

repo_name: NavExplorer/node-indexer


text:
# bee_data_cleaning
BeeDataCleaning is a outlayer detection library for energy and temperature timeseries.

it is organized in two modules:

1. data_cleaning
2. visualization

## data_cleaning

This module contains the data cleaning functions to detect the outliers and clean their data.

### functions:

##### detect_min_threshold_outliers(series, threshold)
Detects the values that are lower than the threshold passed

    series : series, mandator

        The series where to detect the outliers

    threshold : integer, float, mandatory

        The threshold of the minimum value that will be considered outliers.

##### detect_znorm_outliers(series, threshold, mode="global", **kwargs)
Detects the outliers usin the znorm technique.

    series : series, mandatory
        The series where to detect the outliers

    threshold : integer, float, mandatory
        The threshold of the maximum znorm value to considere as outliers.

    mode: string, mandatory
        Indicate the mode to perform the znorm outlier detection; possible values are:
        'global': considere all the series at once
        'rolling': use a window and slide it through the time series

    window: integer, only when 'rolling'
        The size of the window used when rolling

    lowq: float, default=2.5
        The lower percentile to not considere when performing the mean and std for the znorm

    highq float, default=97.5
        The higher percentile to not considere when performing the mean and std for the znorm

##### detect_max_threshold_outliers(series, threshold)
Detects the values that are higer than the threshold passed

    series : series, mandatory
        The series where to detect the outliers

    threshold : integer, float, mandatory
        The threshold of the maximum value that will be considered outliers.

##### detect_outliers(series, threshold, method, **kwargs)
Deprecated due to its complexity

Detects all outliers with the different methods by order on the lists

    series : series, mandatory
        The series where to detect the outliers

    threshold : list of integer, float, mandatory
        The threshold of the maximum value that will be considered outliers for each method.

    threshold : list of strings, mandatory
        The threshold of the maximum value that will be considered outliers for each method.

##### clean_series(series, bool_outliers)
Cleans the series by setting its outliers to 'NaN'

This function should be used with the results of the the "detect_x" functions, to clean the outliers from the timeseries

    series : series, mandatory
        The series to clean
    bool_outlier : array or series, mandatory

##### percentage_of_gaps(series)
Returns the percentage of nans found in the series'

    series : series, mandatory
        The series to calculate the percentage of NaN

##### summary(series, **kwargs)
Returns information about the timeseries passed
"dateStart", "dateEnd", "frequency", "mean", "sd", "min", "max", "p1",
"p5", "p25", "p50", "p75", "p95", "p99"

    series : series, mandatory
        The series to get the information

## Visualization

This module contains the visualization functions to analyze the dataframe.

### functions:

##### plot_dataframe(df_to_plot, pdf, height=None, width=None, title="Dataset")
Plots the dataframes

    df_to_plot: pandas.DataFrame, mandatory
        dataframe to plot
    pdf: PDFobject or string, mandatory
        file where the plot will be stored
    height: int, optional
        height of the plot
    width: int, optional
        width of the plot
    title: string, default="Dataset"
        title of the plot

##### plot_timeseries(series, names_series, pdf, series_labels=None, series_outliers=None, series_negatives=None, ylabel="Value", title="Time series plot")

Plot high frequency time series of data.

    :param series: pandas.Series of List of pandas.Series with DateTime index.
        the time series which will be drawn in the plot.
    :param names_series: list of strings
        the names of the series. In the same order to the series list.
    :param pdf: PDFobject or string
        file where the plot will be stored
    :param series_labels: pandas.Series with datetime index
        This series will be represented by labels painted on the main series, so is recommended to contain very few items.
    :param series_outliers: pd.Series with datetime index and Boolean values
         If true, that element is an outlier
    :param series_negatives:
        Boolean Pandas series with datetime index
        If true, that element is negative.
    :param ylabel: str
        The Y axis label name
    :param title: str
        Title of the plot
    :return:

##### plot_histogram(series, pdf, title="Histogram"):
Plot histogram of a series.

    :param series: Pandas series object
    :param pdf: PDF object or PDF filename where the plot will be stored
    :param title: Title of the plot
    :return:

##### initialize_plotly_by_rows(nrows, titles):
Initiates a plotly to plot the timeseries.

    nrows: integer, mandatory
        the number of rows to add in the plot
    titles: list of strings,mandatory
        the titles to add to each row

##### add_plotly_timeseries(fig, series, label, unit):
Adds a new timeseries to the plotly objecs

    fig: plotly figure, mandatory
        the plotly figure to add the timeseries
    series:  a series
        The series to add to the data.
    label: string,
        A label indicating information about the data
    unit: string,
        The unit of the data

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
title: 'How to call a function on URL change in javascript'
date: "2020-07-03"
tags:
  - javascript
  - react
show: true
author: trishul
---

Modern JS frameworks tend not to reload the page but manipulate DOM and change URL path for internal navigation, for performance and smooth UX. But since there is no page reload, `window.onload` event does not get triggered for subsequent navigation. We run into a situation where we need to call a function whenever URL path changes (not the hash).

### Problem
The [`itsopensource.com`](https://itsopensource.com/) blog is built using [gatsby](https://www.gatsbyjs.org/), we wanted to add google analytics to this, but instead of using google tag manager, we tried to restrict what [data](https://github.com/tsl143/itsopensource/blob/master/src/html.js#L32) is sent to google and in this process, we need to send XHR request on every page load. We created a function `sendTelemetry` and called it on `window.onload`. This works as expected (partially), whenever the page is loaded the XHR is sent, but gatsby do not reload the page while changing the URL when any blog link is clicked, so XHR is sent only once per session and not on subsequent page loads.
Javascript does not provide any native listener to path change (not hashchange).

### Solution
The `history` API maintains complete the navigation state. Whenever a new page is navigated `history.pushState` is called and page is added to the state. That means this event is called whenever the URL changes. We hooked our function on this, and done :)

```Javascript
(function(history){
    var pushState = history.pushState;
    history.pushState = function(state) {
      // YOUR CUSTOM HOOK / FUNCTION
      console.log('I am called from pushStateHook');
      return pushState.apply(history, arguments);
    };
})(window.history);
```

### Demo
A quick demo can be the following:
1. Open the browser console on this very page.
2. Paste the above-written code snippet.
3. Keep console open and navigate various pages on this blog
4. You should see a message in console on every navigation.

<br>

*The first choice for the title was `how to hook a function on history.pushState`.*

Reference: [stackoverflow](https://stackoverflow.com/questions/4570093/how-to-get-notified-about-changes-of-the-history-via-history-pushstate)  😉

gha_language: JavaScript

gha_license_id: MIT


text:
---
permalink: "blog/not-lot/"
tags: posts
title: Not a lot
date: 2001-05-02
layout: layouts/post.njk
---

Not a lot to report on now. I drew a naked girl last night. It was Melissa again, who I drew a lot during my last class. I was doing pretty well, but I REALLY hate my teacher.
"Um, I just drew a circle there. I haven't gotten there yet."
"Right, but don't you think you should fix it?"
"Yeah, I'll fix it, but I haven't gotten there yet."
"Why not?"
"Because I haven't. I've been working on other parts."
"But shouldn't the head be the right size?"
"Yes. And it will be, when I get to it."

I've taken 2 years of figure drawing classes in art school, where I had 4 or 5 different teachers trying to tell me how to draw and conform to their style for a semester at a time. After I graduated, I thought I was done with that and I could do my own style, in my own way.  In Chicago they had these places where you could go, pay $15, and sit in a room with 2 nude models, no teacher, and just draw. Peoria should have one of those. The closest thing we have is a strip club.

But other than my annoying teacher, it seems like everything is well and good in the world. Everyone is happy and well, and I feel better and better every day, which I didn't think was possible. And what great weather to feel as good as I feel... bright, sunny, and warm. I wore shorts for the first time today. They're kind of weird though... the front pockets velcro shut. But now I'm rambling.

Now here's a story to end my incredibly boring entry. I was getting ready this morning and shoving everything from the pants I wore yesterday into the shorts I'm wearing today. I had everything transferred except for my wallet, which weren't in the pants I wore yesterday.  Sometimes when I watch TV I take out my wallet since it's kind of uncomfortable. Anyway, I couldn't find it and was just going to go the day without it, but as I was locking Abby in her kennel, I had a brilliant idea. I checked the pants I wore on Monday, and there they were. So, I unknowingly went all day yesterday without a wallet. How did I ever manage?

repository: timwasson/timwasson

gha_language: HTML

repo_name: timwasson/timwasson


text:
---
code: true
type: page
title: updateSelf | API | Core
---

# updateSelf

Updates the currently logged in user information.

This route cannot update the list of associated security profiles. To change a user's security profiles, the route [security:updateUser](/core/2/api/controllers/security/update-user) must be used instead.

---

## Query Syntax

### HTTP

<SinceBadge version="2.4.0"/>
```http
URL: http://kuzzle:7512/_me[?refresh=wait_for][?retryOnConflict=10]
Method: PUT
Headers: Authorization: "Bearer <authentication token>"
Body:
```

<DeprecatedBadge version="2.4.0">
```http
URL: http://kuzzle:7512/_updateSelf[?refresh=wait_for][?retryOnConflict=10]
Method: PUT
Headers: Authorization: "Bearer <authentication token>"
Body:
```
</DeprecatedBadge>

```js
{
    "foo": "bar",
    "fullname": "Walter Smith"
}
```

### Other protocols

```js
{
  "controller": "auth",
  "action": "updateSelf",
  "jwt": "<authentication token>",
  "body": {
    "foo": "bar",
    "name": "Walter Smith"
  },
  // Optional
  "refresh": "wait_for",
  "retryOnConflict": 10
}
```

---

## Arguments

- `jwt`: valid authentication token (for the HTTP protocol, the token is to be passed to the `Authorization` header instead)

### Optional arguments

- `refresh`: if set to `wait_for`, Kuzzle will not respond until the user changes are indexed (default: `"wait_for"`)
- `retryOnConflict`: in case of an update conflict in Elasticsearch, the number of retries before aborting the operation (default: `10`)

---

## Body properties

User properties that can be set or updated depend on the application hosted by Kuzzle. This document is free of limitations.

---

## Response

Returns the following properties:

- `_id`: current user's [kuid](/core/2/guides/main-concepts/authentication#kuzzle-user-identifier-kuid)
- `_source`: additional (and optional) user properties

```js
{
  "status": 200,
  "error": null,
  "action": "updateSelf",
  "controller": "auth",
  "requestId": "<unique request identifier>",
  "result": {
    "_id": "<kuid>",
    "_source": {
      "fullname": "Walter Smith"
    }
  }
}
```

repository: kuzzleio/kuzzle

repo_name: kuzzleio/kuzzle


text:
# Monopoly-Game
My first CPP project.
It is user friendly, user interactice monopoly game.
You just need two dice(don't worry if you don' have them. I have a code for that too. Just compile it :p) and this application/code to play one of the interesting multiplayer games.
It's a pure terminal application(using CLI). So, don't expect any graphics please. :)
Please let me know if there are any bugs in the application.

(For windows, use 'Monopoly.exe')

(For linux open a terminal and change to the directory where the 'Monopoly_linux_executable' is present and execute it using terminal with command : ./Monoploy_linux_executable after changing the permissions to execute.)

NOTE : If You are working on windows, You may need libstdc++-6.dll and libgcc_s_dw2-1.dll for that application to run. So, I uploaded those files also in the repo.

(Since it is a CLI only, suggested layout for best vision of terminal in ubuntu is: enter fullscreen mode and zoom out once and for windows cmd is keep the font size 12 in properties and enter fullscreen)

repository: sushanttimmapur/BUSINESS-GAME

repo_name: sushanttimmapur/BUSINESS-GAME


text:
# Install efs-provisioner

To install efs-provisioner, create/update the efs security group with following inbound rule.

```text
Type       : NFS
Protocol   : TCP
Port Range : 2049
Source     : <IP_ADDRESS>/16 (private ip range of your nodes)
```

Then change these values in efs-provisioner public chart according to your efs configurations and apply the chart

```text
efsFileSystemId: fs-1234567
awsRegion: eu-west-1
path: /
```

## Mount EFS to node

```bash
sudo mkdir -p /mnt/efs;
sudo mount -t nfs4 -o nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2 fs-blahblah.efs.us-west-2.amazonaws.com:/ /mnt/efs;
```

repository: stakater/til

repo_name: stakater/til


text:
# Instructions for installing pytorch and pytorch lightening.

There are few issue with newer version of pytorch and pytorch lightening because of missing modules and API changes.
For reproducing and running the models in repo use following versions of these libraries.
# with CUDA
```pytorch-lightning==1.0.8
pytorch-lightning-bolts==0.2.2
torch==1.7.0+cu110
torchaudio==0.7.0
torchvision==0.8.1+cu110
```
If you don't have GPU and want to proceed with cpu version than use the cpu counterpart. Here is the pip command.
Find more info on officail [pytorch page](https://pytorch.org/get-started/previous-versions/)
```
pip install torch==1.7.0+cpu \
                    torchvision==0.8.1+cpu  \
                    torchaudio==0.7.0 \
                    -f https://download.pytorch.org/whl/torch_stable.html```

repository: dahiyaaneesh/Handposeestimation

repo_name: dahiyaaneesh/Handposeestimation


text:
# DCPPC-DRAFT
## Proposed DCPPC RFC Implementation Process
-----------

The comments and suggestions in this document are being used to stage an RFC for the DCPPC RFC process itself.

### Preamble
The (proposed) DCPPC RFC Process is modeled after industry RFC processes and includes two basic steps: a DCPPC-DRAFT and the actual DCPPC-RFC.  We briefly describe when to use each and refer the proposer(s) to the Sources section   for elaboration, additional background, or context.

### DCPPC-DRAFT
The DCPPC-DRAFT is a document containing preliminary technical specifications, results of related work, or other technical information.  Drafts are intended to be work-in-progress documents for work that may eventually be published as a Request for Comments (RFC).  Use a DCPPC-DRAFT to iterate on a design principle, process, guideline, or informational topic before it is polished and before it may be ready to be proposed to the broader DCPPC community for adoption or dissemination.  Not all DCPPC-DRAFTs need to become a DCPPC-RFC, nor is it appropriate to refer to an effort as a “Draft RFC” according to industry RFC convention. Rather, iterate and refine a DCPPC-DRAFT, and if desired, submit it as a DCPPC-RFC when ready.

### DCPPC-RFC
The DCPPC-RFC is a publication from the DCPPC community describing a design principle, process, guideline, or information applicable to the working of the NIH Data Commons. It is submitted either for peer review for adherence or adoption by the community, or to convey new concepts or information to the community.  It is expected that the DCPPC-DRAFT is used as a precursor by an individual or group to refine and polish a design principle, process, guideline, or informational topic prior to publishing as a DCPPC-RFC.  As a publication, the text in a published DCPPC-RFC will not change once published according to accepted RFC convention.

|               |Refined, polished?|Content modifiable?|Community-wide?|Require DCPPC RFC Governance to post?|
|---------------|------------------|-------------------|---------------|-------------------------------------|
|**DCPPC-DRAFT**|No                |Yes                |Not necessarily|No                                   |
|**DCPPC-RFC**  |Yes               |No                 |Yes            |Yes                                  |

Below are the DCPPC-RFC instructions and guidelines.  Steps 1 and 2 are for the DCPPC-DRAFT preceding the DCPPC-RFC, and steps 3-8 are for the DCPPC-RFC.

-----------

### DCPPC Request for Comments (RFC) Instructions and Guidelines

===
### DCPPC-DRAFT
1. Read the [background document to the DCPPC-RFC process](#background).  Your individual or group’s DCPPC-DRAFT and eventual DCPPC-RFC should align with the principles and roles therein.
2. Create, iterate, and refine your DCPPC-DRAFT as a work-in-progress document for work you or your group may be positioning to be published as a DCPPC-RFC, when ready, as a Request for Comments (RFC).  Use your DCPPC-DRAFT to iterate on a design principle, process, guideline, or informational topic until it is polished and ready to be proposed to the broader DCPPC community for adoption or dissemination.  The format of the DCPPC-DRAFT text or determining when it is ready to be put forward as a DCPPC-RFC is not prescriptive - you or your group determine that. The proposing individual or group coordinates the DCPPC-DRAFT content, chooses the scope and audience to iterate it with, chooses when to call it finished, and chooses if/when to submit it as a DCPPC-RFC.  The DCPPC-RFC-Governance - described in Step 4 below - is not involved in a DCPPC-DRAFT until or unless it is submitted as a DCPPC-RFC.

===
### DCPPC-RFC
3. Except for the header, the format of the DCPPC-RFC is not prescriptive and should contain content sufficient for the DCPPC-RFC-Type (defined next) and any supporting information or other documents.   The DCPPC-RFC header placed at the beginning of the DCPPC-RFC should contain this information:
  * DCPPC-RFC-# : (NOTE: Leave blank as this will be assigned by DCPPC-RFC-Governance in Step 4 upon initial submission)
  * DCPPC-RFC-Title :
  * DCPPC-RFC-Type : (click the type for definition):
    * [Design Principle](#design-principle)
    * [Process](#process)
    * [Consensus Building](#consensus-building)
    * [Informational](#informational)
  * Name of the person who is to be Point of Contact for the RFC :
  * Email of the person who is to be Point of Contact for the RFC :
  * Submitting Individual or Group :
  * Requested RFC posting start date :
  * Requested RFC posting end date :
  * Date Emailed for consideration :
  * DCPPC-RFC-Status : (DCPPC-RFC-Governance will assign)
    * Pending
    * Active and open for comment
  * URL Link to GitHub : (DCPPC-RFC-Governance will assign a link of where RFC documents are stored per Step 8)
  * URL Link to RFC Text (URL of DCPPC-RFC text for a given RFC)

4. Email the DCPPC-RFC text to DCPPC-RFC-Governance at<EMAIL_ADDRESS>{Owen, Titus, Stan}.
   a. Within 2 business days, they will either approve and post to<EMAIL_ADDRESS>nih-dcppc general slack channel} or email back Point of Contact requesting refinement or clarification.
   b. If posted to<EMAIL_ADDRESS>nih-dcppc general slack channel}, a unique DCPPC-RFC tag will be assigned based on the pattern: DCPPC-RFC-#  where # is an assigned sequential number

5. Once an approved DCPPC-RFC-# is posted to<EMAIL_ADDRESS>nih-dcppc general slack channel}, the NIH Data Commons community will be proactively encouraged to comment on it during the requested posting period.
   a. DCPPC project management staff will broadly announce the DCPPC RFC on the start date, halfway through the suggested duration, the day prior, and on the RFC end date.
   b. Cross-posting by any NIH DCPPC community members is encouraged.

6. Upon conclusion of the DCPPC-RFC-# posting period, the Submitting Individual or Group will have ten business days to prepare a summary to address comments provided in the DCPPC-RFC-#. In the summary, agreement and disagreement should be clearly articulated, and proposed decisions to be made, or not made, are clearly articulated. If there are disagreements with the RFC, those disagreements should be clearly articulated in the summary by the authors of the RFC, to the satisfaction of the disagreeing parties (that is, in the summary the articulation of the disagreement is to be to the satisfaction of the disagreeing party, not that the RFC itself is proposed to the satisfaction of all parties).

7. Upon conclusion of the DCPPC-RFC-# posting period or at their discretion, the DCPPC-RFC-Governance will assign one of the following DCPPC-RFC-Status values concluding the DCPPC-RFC process without further iteration:
   a. Resolved
   b. Merged (i.e. with another DCPPC-RFC)
   c. Postponed
   d. Unsuccessful
   e. Withdrawn

8. All documents from a concluded DCPPC-RFC with all contributor comments will be placed in https://github.com/dcppc/internal/rfcs.

-----------

## DCPPC-RFC-Types
#### Design Principle
A  **Design Principle** DCPPC-RFC describes a new feature or implementation for the NIH Data Commons. It may also describe an interoperability design principle that will be supported across the full stacks. Candidate specification must be implemented and tested for correct operation and interoperability by multiple independent parties and utilized in increasingly demanding environments, before it can be adopted as an DCPPC Design Principle. Candidate specifications should include a description of any external design principles and/or standards that were considered, used, adapted, or rejected.

#### Process
A **Process** DCPPC-RFC describes a process surrounding the NIH Data Commons, or proposes a change to (or an event in) a process. Process DCPPC-RFCs are like Design Principle DCPPC-RFCs but apply to areas other than the NIH Data Commons code itself. They may propose an implementation, but not to NIH Data Commons codebase.  Unlike Informational DCPPC-RFCs, they are more than recommendations, and users are typically not free to ignore them. Examples include procedures, guidelines, and changes to the decision-making process.

#### Consensus Building
A **Consensus Building** DCPPC-RFC describes a NIH Data Commons design issue, or provides general guidelines or information to the NIH Data Commons development community, and may propose a new feature. This type of RFC type includes use cases or demonstration of how the design, guideline, or information meets a specific need, and/or which stakeholders' needs have been met. Unlike Informational DCPPC-RFCs, Consensus Building DCPPC-RFC represent a NIH Data Commons community consensus or recommendation, so users and implementers are expected to make a best effort to follow their advice.

#### Informational
An Informational DCPPC-RFC describes a NIH Data Commons design issue, or provides general guidelines or information to the NIH Data Commons development community, but does not propose a new feature. Informational DCPPC-RFCs do not necessarily represent a NIH Data Commons community consensus or recommendation, so users and implementers are free to ignore Informational DCPPC-RFCs or follow their advice.

## Foundation of the DCPPC-RFC Process
#### Background
The activities of both the Full Stacks (FSs) and the Key Capabilities (KCs) play a vital role in the Data Commons (DC), and are also critical to the NHLBI Data STAGE. In the process of building the Data Commons we must make decisions, but we need to make decisions based on feedback from individual contributors, the FSs, the KCs, and the many NIH stakeholders, including Data STAGE.  Further, there is considerable overlap and interaction between the KCs and the FSs, but they have somewhat different responsibilities and timelines.  As a result, we need to establish a process that enables effective interactions between the KCs and the FSs, and also supports shared decision making.  To accomplish this, we propose the use of Requests for Comments (RFCs).

Principles that support the need for RFCs:
1. Where possible, we enable individual contributors and teams to independently make the decisions necessary to build components, to build the FSs, and to subsequently build the DC.
2. We actively seek feedback from a broad community of domain experts, and not all of those experts are part of the teams building the KCs, the FSs, the DC, or STAGE.
3. The KCs provide domain expertise and also build communities-of-practice.
4. The KCs help the DC to manage the risk in building the DC.
5. The KCs are responsible for not only providing feedback on the current technology, but also provide context and feedback on future technologies.
The KCs operate asynchronously from the FSs.
6. The FSs will seek input from a broad community of stakeholders outside the DCPPC.
7. By using RFCs the work of building the DC can proceed as multiple, interoperable and  parallel projects, thus permitting exploration and resiliency.

The KCs’ roles are:
1. Each KC focuses on challenges that fall within an area of competence that must be addressed for the DC, and as such they act as community conveners to encourage exploration and innovation.
2. In cases when challenges and solutions overlap or have dependencies with other KCs, the KC will involve other KCs and divide the discussions and responsibilities appropriately.
3. They act as working groups that evaluate key areas of technology necessary for the Data Commons (DC).
4. The KCs may implement products that are  intended to be used by the FSs on an ongoing basis.
5. The KCs put forward Requests for RFCs to solicit feedback on key areas in which standards may need to emerge.

The FSs’ roles are:
1. Each FS focuses on a set of challenges that must be addressed for a particular implementation of the DC, as well as the interoperability of the components they build across other stacks.
2. The FSs act as development teams that implement and evaluate key areas of technology necessary for the Data Commons.
3. The FSs put forward RFCs to solicit feedback on key areas in which standards may need to emerge.

An RFC should include participation from all the FS teams. Interaction between KCs and FSs
1. The KCs serve as the group that provides in-depth technical analysis of possible choices for a given DC challenge and will implement resources to be used by the FS where necessary.
2. The FSs serve as the primary implementers of capabilities that are eventually deployed. As such the FSs depend on and are informed by the technical analysis done the KCs.
3. Sharing of KC analyses across the multiple teams allows cross-fertilization of options and approaches across the FSs.

Using the RFC process, through consultation with the broader community, allows the KCs and the FSs to:
1. Initiate or refine potential community standards as design principles, or
2. Establish or improve a DCPPC process, or
3. Build consensus among competing technologies, or
4. Provide broadly useful information.

Generally, an RFC should be created when:
1. We seek to reach agreement.
2. We seek to establish a contract between actors.
3. We are defining conventions, e.g.,  interfaces, APIs, data models, etc.
4. There is a need for transparency and inclusion on a necessary decision.
5. A decision could impact more than one system component or team or stakeholders.
6. We are adding dependencies that can affect more than one team.

Sources:
https://opensource.com/article/17/9/6-lessons-rfcs
https://en.wikipedia.org/wiki/Internet_Draft
https://en.wikipedia.org/wiki/Request_for_Comments
https://www.python.org/dev/peps/pep-0001/
https://opensource.com/business/12/6/architecture-participation
http://aturon.github.io/2018/05/25/listening-part-1/


text:
# umlang

Symbolic/Numeric CAS (Computer Algebra System) with UML-like Syntax

## Compilation

```Shell
$ waf distclean  # Removes old build files
$ waf configure  # Configures build environment
$ waf generate   # Generates lexer and parser from ANTLR4 grammar file
$ waf deploy     # Deploys the generated lexer and parser to the Java source dir
$ waf build      # Compiles the source files
```

## Usage

## License

Copyright © 2013 Dylon Edwards

Distributed under the [MIT License](http://www.opensource.org/licenses/mit-license.php).

repository: dylon/umlang

repo_name: dylon/umlang


text:
---
title: "Troubleshooting"
linkTitle: "Troubleshooting"
weight: 4
Description: >
  Troubleshooting guide
---

- [Running `karavictl inject` leaves the vxflexos-controller in a `Pending` state](#running-karavictl-inject-leaves-the-vxflexos-controller-in-a-pending-state)
- [Running `karavictl inject` leaves the powermax-controller in a `Pending` state](#running-karavictl-inject-leaves-the-powermax-controller-in-a-pending-state)
- [Running `karavictl inject` leaves the isilon-controller in a `Pending` state](#running-karavictl-inject-leaves-the-isilon-controller-in-a-pending-state)

---

### Retrieve CSM Authorization Server Logs

To retrieve logs from services on the CSM Authorization Server, run the following command (e.g proxy-server logs):

```
$ k3s kubectl logs deploy/proxy-server -n karavi -c proxy-server
```

For OPA related logs, run:

```
$ k3s kubectl logs deploy/proxy-server -n karavi -c opa
```

### Running "karavictl inject" leaves the vxflexos-controller in a "Pending" state
This situation may occur when the number of vxflexos-controller pods that are deployed is equal to the number of schedulable nodes.
```
$ kubectl get pods -n vxflexos

NAME                                   READY   STATUS    RESTARTS   AGE
vxflexos-controller-696cc5945f-4t94d   0/6     Pending   0          3m2s
vxflexos-controller-75cdcbc5db-k25zx   5/5     Running   0          3m41s
vxflexos-controller-75cdcbc5db-nkxqh   5/5     Running   0          3m42s
vxflexos-node-mjc74                    3/3     Running   0          2m44s
vxflexos-node-zgswp                    3/3     Running   0          2m44s
```

__Resolution__

To resolve this issue, we need to temporarily reduce the number of replicas that the driver deployment is using.

1. Edit the deployment
    ```
    $ kubectl edit -n vxflexos deploy/vxflexos-controller
    ```

2. Find `replicas` under the `spec` section of the deployment manifest.
3. Reduce the number of `replicas` by 1
4. Save the file
5. Confirm that the updated controller pods have been deployed
    ```
    $ kubectl get pods -n vxflexos

    NAME                                   READY   STATUS    RESTARTS   AGE
    vxflexos-controller-696cc5945f-4t94d   6/6     Running   0          4m41s
    vxflexos-node-mjc74                    3/3     Running   0          3m44s
    vxflexos-node-zgswp                    3/3     Running   0          3m44s
    ```

6. Edit the deployment again
7. Find `replicas` under the `spec` section of the deployment manifest.
8. Increase the number of `replicas` by 1
9. Save the file
10. Confirm that the updated controller pods have been deployed
    ```
    $ kubectl get pods -n vxflexos

    NAME                                   READY   STATUS    RESTARTS   AGE
    vxflexos-controller-696cc5945f-4t94d   6/6     Running   0          5m41s
    vxflexos-controller-696cc5945f-6xxhb   6/6     Running   0          5m41s
    vxflexos-node-mjc74                    3/3     Running   0          4m44s
    vxflexos-node-zgswp                    3/3     Running   0          4m44s
    ```

### Running "karavictl inject" leaves the powermax-controller in a "Pending" state
This situation may occur when the number of powermax-controller pods that are deployed is equal to the number of schedulable nodes.
```
$ kubectl get pods -n powermax

NAME                                   READY   STATUS    RESTARTS   AGE
powermax-controller-58d8779f5d-v7t56   0/6     Pending   0          25s
powermax-controller-78f749847-jqphx    5/5     Running   0          10m
powermax-controller-78f749847-w6vp5    5/5     Running   0          10m
powermax-node-gx5pk                    3/3     Running   0          21s
powermax-node-k5gwc                    3/3     Running   0          17s
```

__Resolution__

To resolve this issue, we need to temporarily reduce the number of replicas that the driver deployment is using.

1. Edit the deployment
    ```
    $ kubectl edit -n powermax deploy/powermax-controller
    ```

2. Find `replicas` under the `spec` section of the deployment manifest.
3. Reduce the number of `replicas` by 1
4. Save the file
5. Confirm that the updated controller pods have been deployed
    ```
    $ kubectl get pods -n powermax
    NAME                                   READY   STATUS    RESTARTS   AGE
    powermax-controller-58d8779f5d-cqx8d   6/6     Running   0          22s
    powermax-node-gx5pk                    3/3     Running   3          8m3s
    powermax-node-k5gwc                    3/3     Running   3          7m59s
    ```

6. Edit the deployment again
7. Find `replicas` under the `spec` section of the deployment manifest.
8. Increase the number of `replicas` by 1
9. Save the file
10. Confirm that the updated controller pods have been deployed
    ```
    $ kubectl get pods -n powermax
    NAME                                   READY   STATUS    RESTARTS   AGE
    powermax-controller-58d8779f5d-cqx8d   6/6     Running   0          22s
    powermax-controller-58d8779f5d-v7t56   6/6     Running   22         8m7s
    powermax-node-gx5pk                    3/3     Running   3          8m3s
    powermax-node-k5gwc                    3/3     Running   3          7m59s
    ```

### Running "karavictl inject" leaves the isilon-controller in a "Pending" state
This situation may occur when the number of Isilon controller pods that are deployed is equal to the number of schedulable nodes.
```
$ kubectl get pods -n isilon

NAME                                 READY   STATUS    RESTARTS   AGE
isilon-controller-58d8779f5d-v7t56   0/6     Pending   0          25s
isilon-controller-78f749847-jqphx    5/5     Running   0          10m
isilon-controller-78f749847-w6vp5    5/5     Running   0          10m
isilon-node-gx5pk                    3/3     Running   0          21s
isilon-node-k5gwc                    3/3     Running   0          17s
```

__Resolution__

To resolve this issue, we need to temporarily reduce the number of replicas that the driver deployment is using.

1. Edit the deployment
    ```
    $ kubectl edit -n <namespace> deploy/isilon-controller
    ```

2. Find `replicas` under the `spec` section of the deployment manifest.
3. Reduce the number of `replicas` by 1
4. Save the file
5. Confirm that the updated controller pods have been deployed
    ```
    $ kubectl get pods -n isilon

    NAME                                   READY   STATUS    RESTARTS   AGE
    isilon-controller-696cc5945f-4t94d   6/6     Running   0          4m41s
    isilon-node-mjc74                    3/3     Running   0          3m44s
    isilon-node-zgswp                    3/3     Running   0          3m44s
    ```

6. Edit the deployment again
7. Find `replicas` under the `spec` section of the deployment manifest.
8. Increase the number of `replicas` by 1
9. Save the file
10. Confirm that the updated controller pods have been deployed
    ```
    $ kubectl get pods -n isilon
    NAME                                   READY   STATUS    RESTARTS   AGE
    isilon-controller-58d8779f5d-cqx8d   6/6     Running   0          22s
    isilon-controller-58d8779f5d-v7t56   6/6     Running   22         8m7s
    isilon-node-gx5pk                    3/3     Running   3          8m3s
    isilon-node-k5gwc                    3/3     Running   3          7m59s
    ```

repository: JacobGros/csm-docs

branch_name: refs/heads/main

repo_name: JacobGros/csm-docs


text:
I/O Benchmarks
------------

This module contains microbenchmarks that can be used to measure various aspects of performance for Okio and other buffers. Benchmarks are written using JMH (version 1.11.+ at this time) and require Java 7.

Running Locally
-------------

To run benchmarks locally, first build and package the project modules:

```
$ gradle clean shadowJar
```

This should create a `perf-test-all.jar` file in the `perf-test/build/libs` directory, which is a typical JMH benchmark JAR:

```
$ java -jar perf-test/build/libs/perf-test-all.jar -l
Benchmarks:
io.apptik.joio.perf.BufferPerfBench.cold
io.apptik.joio.perf.BufferPerfBench.threads16hot
io.apptik.joio.perf.BufferPerfBench.threads1hot
io.apptik.joio.perf.BufferPerfBench.threads2hot
io.apptik.joio.perf.BufferPerfBench.threads32hot
io.apptik.joio.perf.BufferPerfBench.threads4hot
io.apptik.joio.perf.BufferPerfBench.threads8hot
```

More help is available using the `-h` option. A typical run on Mac OS X looks like:

```
$ /usr/libexec/java_home -v 1.7 --exec java -jar perf-test/build/libs/perf-test-all.jar \
"cold" -prof gc,hs_rt,stack -r 60 -t 4 \
-jvmArgsPrepend "-Xms1G -Xmx1G -XX:+HeapDumpOnOutOfMemoryError"
```

This executes the "cold" buffer usage benchmark, using the default number of measurement and warm-up iterations, forks, and threads; it adjusts the thread count to 4, iteration time to 60 seconds, fixes the heap size at 1GB and profiles the benchmark using JMH's GC, Hotspot runtime and stack sampling profilers.

repository: apptik/joio

repo_name: apptik/joio


text:
---
title: SICSS Festival 2020
subtitle: "June 22 - June 26, 2020"
layout: page
---

The SICSS Festival 2020 will take place Monday, June 22 - Friday, June 26, 2020. During the festival, alumni from all SICSS locations would host events such as tutorials, panel discussions, or debates.  These events will all be online.  SICSS Festival events will be open to either current SICSS participants (at any location) or anyone that is interested; the choice of audience will be driven by the topic, learning objectives, and preferences of presenters.  If you are a SICSS alumni and would like to host an event in the festival, please send us an email with a rough sketch of your idea.  We will be adding events to this website as they are finalized.

## Panel discussion on teaching computational social science

__Speaker:__ [Matti Nelimarkka](https://matti.mante.li/) (SICSS-Princeton 17) and [Rochelle Terman](http://rochelleterman.com/) (SICSS-Princeton 17)

__Moderator:__ Matthew Salganik

__Description:__ Teaching computational social science at both the undergraduate and graduate level presents a number of challenging pedagogical questions. How should we teach a class with students from different disciplinary backgrounds?  What is the role of programming in computational social science education? How should computational social science courses fit into a larger curriculum?  The panelists will address these questions---and others---first in a moderated conversation and then will take questions from the audience.

__Open to:__ Unlimited registered participants: Link to registration form coming soon

__Time:__ Monday, June 22. 10-11am EDT

__Archiving:__ This talk will be recorded and archived.

## Using Empirica for high-throughput virtual lab experiments

__Speaker:__ [Abdullah Almaatouq](http://www.amaatouq.com/) (SICSS-Princeton 17), [James Houghton](http://www.jamesphoughton.com/) (SICSS-Duke 20), and Nicolas Paton.

__Description:__ [Empirica](https://empirica.ly/) is a new open source software platform for developing and conducting synchronous and interactive human-subject experiments.  It has already been used by researchers around the world. This session will start with a live demonstration where participants will take part in a real-time experiment involving dozens of people.  Next, the data from that experiment will be downloaded and analyzed.  Thus, participants will have a behind-the-scenes, end-to-end experience with an experiment run with Emprica. Finally, there will be time for questions and discussion about Empirica and the future of experiments in the social sciences.

__Open to:__ Up to 30 registered participants: Registration form coming soon

__Time:__ Wednesday, June 24, 2020. 1-2:30pm EDT

__Preparatory materials:__ All registered participants are strongly encouraged to work through and watch Empirica videos A - E (link coming soon), which will require them to [install software](https://empirica.ly/docs/quick-start.html) on their computers.

__Archiving:__ This talk will be recorded and archived.

repository: JoseZhangSH/summer-institute

repo_name: JoseZhangSH/summer-institute


text:
# Linux App Service
Linux App Service is a progression of the Microsoft Platform as a Service (PaaS) supporting the underlying OS as being Linux.  This has the added benefit of allow Docker images bourne from Linux as the base, and the Open Source Community.

In this workshop we will explore the use of App Service for Linux, as well as Continuous Deployment options utilising GitHub.

## Create the App Service for Linux instance
Login the Azure Portal, and search for "App Linux" in the New Resource pane.

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/choose_app_service.PNG?raw=true "Search for App Linux")

Select Web App on Linux and setup your new service.  I'd recommend you create a new Resource Group so you can tear it down easily later.

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/add_svc_settings.PNG?raw=true "Enter your Settings")

## Check your Application is running
Once the instance has been created, you will be able to see the the DNS entry hase been created and listed.

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/check_running.PNG?raw=true "Get the App URL")

Either click on the URL listed (in this case, http://appsrvlinux.azurewebsites.com), or click the "Browse" button at the top left of the screen., and you will see your application instance is running and available.

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/app_running.PNG?raw=true "Your app is up!")

## Deploying to your Application Continuously (The **CD** of CI/CD)
In this example, we are going to link to a GitHub repository, which Azure will check at regular intervals and will pull down and restart your instance automatically.

### Create your GitHub repository
Goto GitHub and create a new repository.  It can be public, or private.

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/create_github_repo.PNG?raw=true "Create GitHub repo")

### Link to your GitHub organisation
From the portal, goto your application and select "Deployment Options".  In this case we will  choose "GitHub" as the source, and will link the App Service for Linux instance to the account, organisation, repository and branch we want to monitor for changes.

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/setup_deployment.PNG?raw=true "Link GitHub source to AZ App instance")

### Commit a new file to your repository
You can choose whatever way you want to commit a change to the repository, we'll use the GitHub web UI to edit and commit directly into the repository.

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/create_index_php.PNG?raw=true "Create index.php")

If you flick back to the portal, you should see that a deployment has been triggered

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/update_from_repo.PNG?raw=true "Update from repository")

A few moments later, take a look back at your Application URL...

![alt text](https://github.com/justindavies/OSS-Partner-Day/blob/master/AppServiceLinux/website_published.PNG?raw=true "Your App is live")

## Some other things to try
How about some other things to try:

- Push load onto the published application and see how the resource utilisation holds up
- Scale the number of instances up or down to see performance increase/decrease


text:
# useStyleLink

[![NPM](https://nodei.co/npm/use-style-link.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/use-style-link/)

![publish workflow](https://github.com/zheeeng/use-style-link/actions/workflows/publish.yml/badge.svg)
[![npm version](https://img.shields.io/npm/v/use-style-link.svg)](https://www.npmjs.com/package/use-style-link)

A React hook for inserting the identical style link.

Support SSR scene.

## Install

```bash
yarn add use-style-link (or by npm)
```

## Usage

```ts
import { useStyleLink } from 'use-style-link'

const App = () => {
<EMAIL_ADDRESS>
    return (
        <div>Hello world</div>
    )
}
```

## Signature

```ts
const useStyleLink: (url: string, autoClear?: boolean, isSameLink?: (link1: string, link2: string) => boolean) => void
```

by default, it won't clear the inserted style link automatically for performance consideration.

repository: zheeeng/use-style-link

repo_name: zheeeng/use-style-link


text:
---
sidebar_label: QPixmap
title: QPixmap
---

> The QPixmap class helps hold an image in the form of off-screen image representation.

**This class is a JS wrapper around Qt's [QPixmap class](https://doc.qt.io/qt-5/qpixmap.html)**

A `QPixmap` provides ability to store an image in the memory.

**QPixmap inherits from [Component](api/Component.md)**

### Example

```javascript
const { QPixmap } = require("@nodegui/nodegui");

const imageUrl = "path/to/png";
const pixMap = new QPixmap(imageUrl);
```

### `new QPixmap(imageUrl?)`

- `imageUrl` string (_optional_). Absolute path of the image that needs to be loaded in the memory.

## Static Methods

QPixmap can access all the static methods defined in [Component](api/Component.md)

## Instance Properties

QPixmap can access all the instance properties defined in [Component](api/Component.md)

## Instance Methods

QPixmap can access all the instance methods defined in [Component](api/Component.md)

Additionally it also has the following instance methods:

### `pixMap.load(imageUrl)`

loads an image from the url into memory as a Pixmap.
returns true if load was successful otherwise returns false.

- `imageUrl` string (_optional_). Absolute path of the image that needs to be loaded in the memory.

#### `pixMap.save(fileName, format)`

Saves the pixmap to the file with the given fileName using the specified image file format and quality factor. Returns `true` if successful; otherwise returns false.

If format is 0, an image format will be chosen from fileName's suffix.

See also [Reading and Writing Image Files.](https://doc.qt.io/qt-5/qpixmap.html#reading-and-writing-image-files).

- `fileName` string.
- `format` string. (_optional_).

#### `pixMap.scaled(width, height, aspectRatioMode?)`

Scales the pixmap to provided height and width with respect to aspectRatioMode.
This method doesnt mutate this pixmap and rather returns a new pixmap with new height and width.

- `width` number. Width in pixels for new pixmap.
- `height` number. Height in pixels for new pixmap.
- `aspectRatioMode` AspectRatioMode (_optional_). Specifies how scaling should happen. [AspectRatio is an enum from Qt](api/QtEnums.md)

repository: bundyo/nodegui

repo_name: bundyo/nodegui


text:
<img<EMAIL_ADDRESS>align="left" width="70">

#Search with Bookmarks [![License](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)
This is a simple FireFox add-on which allows you to search any text selected on a website using your context-menu.

https://addons.mozilla.org/en-GB/firefox/addon/search-with-bookmarks/

repository: alayliercan/SearchwithBookmarks

repo_name: alayliercan/SearchwithBookmarks


text:
---
layout: page-breadcrumbs.html
title: Ways to File a Claim
template: 1-topic-landing
relatedlinks:
  - url: /disability-benefits/claims-process/claim-types/fully-developed-claim/
    title: What is the fastest way to file a claim?
    description: ""
  - url: /disability-benefits/apply-for-benefits/help/
    title: How do I get help filing a claim?
    description: ""
  - url: /disability-benefits/claims-process/claim-types/predischarge-claim/
    title: How do I file while on active duty?
    description: ""
  - url: /disability-benefits/apply-for-benefits/one-year/
    title: How do I file for disabilities that appear within one year after discharge?
    description: ""
  - url: /disability-benefits/claims-process/date/
    title: Effective date of disability
    description: ""
---

Choose one of three ways:

1.	Apply online, using [eBenefits]( https://www.ebenefits.va.gov/ebenefits/about/feature?feature=disability-compensation), or

2.	Get help from an [accredited representative](/disability-benefits/apply-for-benefits/help/index.html), or

3.	Go to a [VA regional office](http://www.benefits.va.gov/benefits/offices.asp) and have a VA employee assist you.

**Note:** Active-duty Servicemembers should learn about [predischarge claims](/disability-benefits/claims-process/claim-types/predischarge-claim/index.html).

repository: crwallace/vets-website

repo_name: crwallace/vets-website


text:
# MERN_BookSearch_Engine

## Description

For this assignment we were tasked with reworking existing code to work with GraphQl API and Apollo Server.

The application allows a user to search for books and return recommendations for similar books that they can then save to an account that they have created.

## Installation

There is nothing to install to use this application.

There are the following packages required to run the application.

    *GraphQl
    *Mongoose
    *Node
    *Apollo-Server-Express
    *Bcrypt
    *Express
    *Jsonwebtoken

## License

[![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)

## Contributors

Zachary Gibbs

## Contact

* Github Profile
* <a<EMAIL_ADDRESS>href="_blank">E-Mail

license: Unlicense


text:
# Computer Vision

Many applications in the area of computer vision are closely related to our daily lives, now and in the future, whether medical diagnostics, driverless vehicles, camera monitoring, or smart filters. In recent years, deep learning technology has greatly enhanced computer vision systems' performance. It can be said that the most advanced computer vision applications are nearly inseparable from deep learning.

We have introduced deep learning models commonly used in the area of computer vision in the chapter "Convolutional Neural Networks" and have practiced simple image classification tasks. In this chapter, we will introduce image augmentation and fine tuning methods and apply them to image classification. Then, we will explore various methods of object detection. After that, we will learn how to use fully convolutional networks to perform semantic segmentation on images. Then, we explain how to use style transfer technology to generate images that look like the cover of this book. Finally, we will perform practice exercises on two important computer vision data sets to review the content of this chapter and the previous chapters.

### INDEX

- Image Augmentation
- Fine Tuning
- Object Detection and Bounding Boxes
- Anchor Boxes
- Multiscale Object Detection
- Object Detection Data Set (Pikachu)
- Single Shot Multibox Detection (SSD)
- Region-based CNNs (R-CNNs)
- Semantic Segmentation and Data Sets
- Transposed Convolution
- Fully Convolutional Networks (FCN)
- Neural Style Transfer
- Image Classification (CIFAR-10) on Kaggle
- Dog Breed Identification (ImageNet Dogs) on Kaggle


text:
# GitSearch

>This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 7.3.9.

---

## Development server

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

---

## Code scaffolding

>Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

---
## Build

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

---

## Running unit tests

>Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).

---

## Running end-to-end tests

>Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).

---

## Further help

>To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI README](https://github.com/angular/angular-cli/blob/master/README.md).

---

## Setup/Installation Requirements
>* Clone the application using git clone(this copies the app onto your device):
>* `git-clone`
>* Install required node packages:
>* `npm install`
>* Serve the application:
>* `ng serve`
>* open localhost on your browser to use application

---

## Future Improvemnts
>Improve validation on info typed. Add repo search

---

## Technologies Used
>* HTML
>* CSS(Bootstrap)
>* JavaScript
>* Angular 7

---

## Behaviour driven development/ input and output checking
>* The user will load the page and search for users github profiles.

---

| Behaviour                     | Sample input             | Expected output                                         |
|-------------------------------|--------------------------|-------------------------------------------|
| Submit search form            | Click submit button      | Returns search result            |
|                | |                     |

## Support and contact details
>For any questions, troubleshooting or contributions,  find me on:
>* Mobile: +254724443879
>* Email<EMAIL_ADDRESS>
---

### License
>MIT License
Copyright (c) {2019} **K-Wayne**

---
---

repository: k-wayne/GithubSearch

gha_language: TypeScript

repo_name: k-wayne/GithubSearch


text:
### Soil Body
The following table defines attributes of the soil zone for the farm. For entering the name, coordinates, and shape of the soil body, use the spatial attributes defined in [Spatial Attributes](FMDS_Identification-of-Locations-and-Herds.md#Spatial-Attributes). See the [Farm Features and Attributes Data Standard](https://github.com/Datalinker-Org/Farm-Data-Standards/blob/master/Farm%20Features%20and%20Attributes/FFADS_Feature-Catalogue.md) for a definition of soil body and references to the [INSPIRE](http://inspire.ec.europa.eu/documents/Data_Specifications/INSPIRE_DataSpecification_SO_v3.0.pdf) and [ANZSoilML](http://anzsoil.org/doc/anzsoilml/html/2.0.0/) standards.

#### Soil description and profile

Attributes | Data Types | Notes
:--------- | :--------- | :----
Soil group | Enumeration | Sedimentary, Volcanic, Pumice, Podzol, Sand, Peat, Recent/YGE/BGE
Soil order | Enumeration | Allophanic, Brown, Gley, Granular, Melanic, Organic, Oxidic, Pallic, Podzol, Pumice, Recent, Semiarid, Ultic
Top soil texture | Enumeration | See [Soil Texture](https://github.com/Datalinker-Org/Farm-Data-Standards/blob/master/Irrigation%20and%20Effluent/IEDS_Lists-of-Enumerated-Values.md#Soil-Texture) in the Irrigation & Effluent Data Standard.
Top soil stony | Boolean
Top soil compacted | Boolean
Maximum rooting depth | Integer | cm
Depth to impeded drainage layer | Integer | cm
Non-standard layer | Enumeration | Sandy, Stony, Stony matrix
Drainage class | Enumeration | Well, Moderately well, Imperfect, Poor, Very poor
Hydrophobic condition | Enumeration | Rain always soaks in, Generally soaks in, Mostly runs off
Susceptibility to pugging | Enumeration | Rare, Occasional, Winter, Winter or rain
Drainage method | Enumeration | None, Mole/tile system, Other

#### Representative Soil Test Results for effective area

Attributes | Data Types
:--------- | :---------
pH | Float
Olsen P | Integer
Quick Test Mg | Integer
Quick Test Potassium | Integer
Soil test sulphate | Integer

repository: Datalinker-Org/Farm-Data-Standards

repo_name: Datalinker-Org/Farm-Data-Standards


text:
Secret sharing pads are a simple, computer-free way to securely share passwords
with trusted friends and family for use in emergencies.

When you encrypt your passwords using secret sharing pads, the encrypted
password is split amongst several printed pads using a technique called [secret
sharing](https://en.wikipedia.org/wiki/Secret_sharing). On their own the pads
cannot be decrypted but, when any two pads are used together, the secret
information can be decrypted using just a pen and paper.

This repository contains a simple browser-based tool for creating sets of
secret sharing pads to print out.

* [Try the secret sharing pad crator
  online](http://jhnet.co.uk/projects/secret_sharing_pads/app/index.html)

* [Sample Secret Sharing Pad](screenshots/sample_pad.pdf).

* [Screenshot of Secret Sharing Pad Creator](screenshots/creator.png).

* [Visit the Secret Sharing Pads website](http://jhnet.co.uk/projects/secret_sharing_pads)

Build
-----

This software (and its dependencies) can be built using NPM as follows:

    $ npm install
    $ npm run test
    $ npm run build

The resulting assets will be written to the `dist/` directory and may be used
directly from your file system (ensuring it cannot exfiltrate your secrets) or
hosted on the web.

Disclaimer & License
--------------------

This software was not built or devised by a person with specialist experience.
It is also a bit scruffy internally. Use it at your own risk!

The software is provided under the [MIT license](LICENSE.txt).


text:
# pyCHNOSZ

Author: Dr. Grayson Boyer, GEOPIG Lab, Arizona State University

[CHNOSZ](https://www.chnosz.net/) is a package written by [Dr. Jeff Dick](https://chnosz.net/jeff/) for performing thermodynamic calculations in aqueous geochemistry and biogeochemistry. pyCHNOSZ is a wrapper for CHNOSZ that allows these calculations to be carried out in Python 3 Jupyter notebooks.

## Features

The following CHNOSZ functions are supported in pyCHNOSZ:

- [info](https://chnosz.net/manual/info.html) - Search for chemical species by name or formula and retrieve their thermodynamic parameters.
- [add_OBIGT](https://chnosz.net/manual/add.OBIGT.html) - Add or overwrite species in the OBIGT thermodynamic database by supplying a comma separated value (csv) file with custom data.
- [mod_OBIGT](https://chnosz.net/manual/add.OBIGT.html) - Modify species in the OBIGT thermodynamic database. Optionally, supply a Pandas dataframe containing custom data.
- [reset](https://chnosz.net/manual/thermo.html) - reset data to default values.
- [subcrt](https://chnosz.net/manual/subcrt.html) - Calculate standard state partial molal thermodynamic properties of reactions at elevated temperatures and pressures.
- [basis](https://chnosz.net/manual/basis.html) - Define basis species of a chemical system.
- [species](https://chnosz.net/manual/species.html) - Define the species of interest in a system.
- [equilibrate](https://chnosz.net/manual/equilibrate.html) - Calculate equilibrium chemical activities of species from the affinities of formation of the species at unit activity.
- [affinity](https://chnosz.net/manual/affinity.html) - Calculate the chemical affinities of formation reactions of species.
- [diagram](https://chnosz.net/manual/diagram.html) - Plot equilibrium chemical activity (1-D speciation) or equal-activity (2-D predominance) diagrams as a function of chemical activities of basis species, temperature and/or pressure.

## Requirements

This package must be installed into an environment with an [R](https://www.r-project.org/) installation. See [these instructions](https://docs.anaconda.com/anaconda/user-guide/tasks/using-r-language/) for installing R with Anaconda. Additionally, the CHNOSZ package for R must be installed (see instructions below).

## Installation

### Installing CHNOSZ

Open an R session. Install the CHNOSZ package with:

```r
install.packages("CHNOSZ")
```

Once CHNOSZ is installed you may quit the R session.

### Installing pyCHNOSZ

Install pyCHNOSZ using pip:

```
$ pip install pyCHNOSZ
```

## Usage

Import pyCHNOSZ in your python code with:
```python
import pyCHNOSZ
```

In the following examples, pyCHNOSZ functions are imported with:
```python
from pyCHNOSZ import info, add_OBIGT, mod_OBIGT, reset, subcrt
```

### Search for chemical species

The `info()` function can be used to look up chemical species by name or formula. If names or formulas are provided, database index integers are returned. A list of integers will look up chemical species by index and return a table of thermodynamic properties. See the `info()` function's [original documentation](https://chnosz.net/manual/info.html) to learn more about what this function can do. A few examples are shown below.

Look up the database index value of Fe+2:

```python
info("Fe+2")
```

Look up multiple chemical species:

```python
info(["HCO3-", "CH4"])
```

Define chemical states:

```python
info(["HCO3-", "CH4"], state=["aq", "gas"])
```

Search species by index values to look up their thermodynamic parameters.

```python
info([13, 872])
```

Nest `info` functions to look up thermodynamic properties directly from names or formulas:

```python
info(info("Fe+2"))
```

Look up and add a protein to the database:

```python
info("LYSC_CHICK")
```

### Add or replace thermodynamic data in the database

See the original R documentation for `add_OBIGT()` and `reset()` for basic useage. A few examples are given below.

Load the SUPCRT92 database.

```python
a = add_OBIGT("SUPCRT92")
```

The variable `a` is assigned a list of integers corresponding to the indices of chemical species that are added or replaced in the OBIGT thermodynamic database used by pyCHNOSZ.

It is possible to add a custom table of thermodynamic parameters.

```python
a = add_OBIGT("my_custom_entries.csv")
info(a) # confirm new entries have been added
```

The entries of `my_custom_entries.csv` would then be available for thermodynamic calculations with `subcrt()`, for example.

Reset thermodynamic database to its original configuration.

```python
reset()
```

Modify values in the thermodynamic database with `mod_OBIGT()`:

```python
mod_OBIGT("HCO3-", G = -140283.7, Cp = -9)
info(info("HCO3-"))
```

### Calculate thermodynamic properties of reactions

See the [original documentation](https://chnosz.net/manual/subcrt.html) for `subcrt()`. Useage in pyCHNOSZ is the same, except python lists are used in place of R's vectors. The function produces a dictionary of results stored in pandas dataframes. An example is shown below for the reaction H2 (aq) + 0.5 O2 (gas) = H2O(liq) at 30 and 50 degrees C and 100 bars pressure:

```python
subcrt(species=["H2", "O2", "H2O"], coeff=[-1.0, -0.5, 1.0],
       state=["aq", "gas", "liq"], T=[30, 50], P=100)
```

Output is a python dictionary of dataframes:
```
subcrt: 3 species at 2 values of T (ºC) and P (bar) (wet) [energy units: cal]

{'reaction':       coeff    name formula state  ispecies
 62     -1.0      H2      H2    aq      62.0
 2612   -0.5  oxygen      O2   gas    2612.0
 1       1.0   water     H2O   liq       1.0,
 'out':       T    P       rho       logK             G             H         S  \
 1  30.0  100  1.000017  43.855086 -60832.380282 -67420.887872 -21.89070
 2  50.0  100  0.992305  40.834419 -60379.262657 -67882.530994 -23.36663

           V         Cp
 1 -7.494052 -24.126268
 2 -8.259704 -20.941879  }
```

### More examples:

For more examples, like plotting activity and predominance diagrams, check out the [pyCHNOSZ demo notebook](https://nbviewer.org/github/worm-portal/pyCHNOSZ/blob/master/test/pyCHNOSZ-demo.ipynb).

repository: worm-portal/pyCHNOSZ

repo_name: worm-portal/pyCHNOSZ


text:
---
weight: 0
---
# What is a debugger?

In this section, you will get a brief overview of what a debugger is and the
features that it typically offers. You will also learn how the Scala debugger
API is related to the Eclipse debugger (described below).

---

## Overview

In a nutshell, a debugger is a program written to aid in testing and debugging
another computer program. For those unfamiliar, debugging is the process of
finding and removing defects (bugs) in a computer program and can be
accomplished in a variety of ways including examining log files for oddities,
monitoring the memory of an application or system, profiling for performance
bottlenecks, utilizing test code to discover inconsistencies, and using
interactive debugging to examine the running state of your program.

Debuggers come in quite a few different packages and, most likely, you have
encountered at least one. Several more well-known debuggers include [GDB][gdb],
commonly used to interactively debug C and C++ programs from the command line,
and the [Eclipse Debug Project][eclipse], which is part of the Eclipse IDE and
available for a variety of languages although most-specifically targeted
towards Java. If you have done any web-based frontend development, you have
probably used your browser's debugger such as
[Google Chrome's DevTools][chrome] or [Mozilla Firefox's Debugger][firefox].

While debuggers themselves are an old concept, the latest debuggers are
continuing to demonstrate new, clever ideas to make the everyday programmer's
life a little easier. If interested in modern developments in the debugger
space, check out Elm's [time traveling debugger][elm] or Scala IDE's new
[async debugger][scala-ide].

## Features

A debugger can offer a wide range of features to aid the programmer in
discovering and fixing defects. The most common features found in modern
debuggers are the ability to step through a program, stop (break) a program to
examine its state, and track the values of variables in a program.

### Running a program step-by-step

This involves running a target program one "line" at a time, breaking at each
next "line" to observe the state of the program such as the values of variables
in the stack frame. While line-by-line stepping is one of the most common and
useful forms of stepping through your program, some debuggers offer other step
increments such as frame-by-frame.

Newer debuggers like Scala IDE's [async debugger][scala-ide] offer the ability
to step through your program even when the code execution path is not
straightforward (in this case when running distributed, message-driven programs
using the [Akka toolkit and runtime][akka]).

### Breaking a program to examine its state

This involves setting what is known as a breakpoint, a marker in a program
indicating that you want to stop execution temporarily, to be able to examine
the running state of a program. Often, breakpoints are placed on specific
source lines of a program indicating that the developer wishes to stop the
program when executing a specific line to examine the current state. Earlier
breakpoints would be placed on specific instructions (assembly).

Other forms of breakpoints can also exist including setting a conditional
breakpoint that triggers when reading/writing memory (watchpoints) or the
evaluation of an expression yields true.

### Watching variables in a program

When debugging a program, a common scenario is that a developer wants to
know when a variable's value is accessed or changed. This typically involves
the temporary suspension of the program allowing the developer to inspect the
current stack frame to understand what led to the access/modification of the
variable. Furthermore, more restrictions might be placed on the modification
of a variable such that a developer is only notified when a variable is changed
to a certain value, allowing more accurate understanding of specific problems
such as when a variable unexpectedly becomes _null_.

### Evaluating expressions

A useful feature in many debuggers is the ability to evaluate an expression
(snippet of code) in the target program while it is suspended due to a
breakpoint. This allows developers to quickly test functions and perform
modifications to the state of the program using the same language as the
program itself.

## More about Eclipse and how it relates to this project

The [Eclipse Debug Project][eclipse] offers two subprojects for debugging with
the Eclipse tooling: platform debug and JDT debug. Platform debug focuses on
defining language-independent debugging capabilities including defining
breakpoints (see features for more info), launching programs, and
notification of events from target programs. JDT debug is more specific as it
implements the Java debugging support to launch or attach to a JVM, evaluate
expressions in the context of a stack frame, and dynamically reload classes
into the target JVM.

The underlying API driving Eclipse's debugging framework for Java (and other
JVM-based languages) is the [Java Platform Debugger Architecture][jpda] (JPDA).
The JDPA is a collection of APIs to debug Java code and includes the Java Debug
Wire Protocol (JDWP) defining communication between the debugger and target
JVMs, the Java Virtual Machine Tools Interface (JVMTI) providing a native
interface (C++) to inspect state and control execution of programs running in
a JVM, and the [Java Debugger Interface][jdi] (JDI) that defines a high-level
API in Java to debug remote JVMs.

The Scala debugger API is built on top of the JDI, wrapping existing JDI
functionality in Scala-friendly wrappers and providing higher-level
abstractions to aid Scala developers in writing debugger tooling and utilize
debugger functionality in their own applications.

[gdb]: https://www.gnu.org/software/gdb/
[eclipse]: http://www.eclipse.org/eclipse/debug/
[chrome]: https://developers.google.com/web/tools/chrome-devtools/debug/?hl=en
[firefox]: https://developer.mozilla.org/en-US/docs/Tools/Debugger
[elm]: http://elm-lang.org/blog/time-travel-made-easy
[scala-ide]: http://scala-ide.org/docs/current-user-doc/features/async-debugger/index.html
[akka]: http://akka.io/
[jpda]: http://docs.oracle.com/javase/7/docs/technotes/guides/jpda/index.html
[jdi]: http://docs.oracle.com/javase/7/docs/jdk/api/jpda/jdi/index.html

*[JDI]: Java Debugger Interface

repository: chipsenkbeil/scala-debugger

repo_name: chipsenkbeil/scala-debugger


text:
# Before and After Hooks
_Since_: Concordion 2.0.0

Concordion provides hooks to invoke fixture methods before or after an __example__, __specification__ or __suite__.

## Example hooks

Annotate a fixture method with `@BeforeExample` to invoke it before each example, or `@AfterExample` to invoke it after each example.

Optionally, the method can have a String parameter annotated with `@ExampleName`, which will be supplied with the name of the example. For example:

    @BeforeExample
    public void setupExample(@ExampleName exampleName) {
    }

We have two examples below. Each example increments an AtomicInteger that is [scoped](ConcordionScoped.md "c:run") differently and echoes the value.

### [Test that increments counters](- "firstTest")

* Example name is [firstTest](- "?=getExampleName()")
* Unannotated field value is [1](- "?=getFieldCounter()")
* Example scope value is [1](- "?=getExampleScopedCounter()")

### [The same test again](- "secondTest")

* Example name is [secondTest](- "?=getExampleName()")
* Unannotated field value is [1](- "?=getFieldCounter()")
* Example scope value is [1](- "?=getExampleScopedCounter()")

## Specification hooks

Annotate a fixture method with `@BeforeSpecification` to invoke it before any of the examples are executed, or `@AfterSpecification` to invoke it after all the examples are executed.

## Suite hooks

Annotate a fixture method with `@BeforeSuite` to invoke it before any of the specifications run, or `@AfterSuite` to invoke it after all the specifications run.

Note that for the suite hooks to be run, they must exist on the fixture that is being executed directly by the test runner (eg. by JUnit).

## [Example] (- "example-hooks")

Running the specification [BeforeAndAfterLogging](BeforeAndAfterLogging.md "c:run") which logs messages in its `@BeforeSpecification`, `@BeforeExample`, `@AfterExample` and `@AfterSpecification` methods, as well as in the specification and examples, results in the following :

|[checkRows][] [text][]|
|----------------------|
|Before specification  |
|In before example     |
|Before [Outer]        |
|In specification      |
|After [Outer]         |
|In before example     |
|Before example1       |
|In example 1          |
|After example1        |
|In before example     |
|Before example2       |
|In example 2          |
|After example2        |
|After specification   |

[checkRows]: - "c:verifyRows=#line : getLog()"
[text]:      - "?=#line"

## [Example With Listener] (- "example-listener-hooks")

Running the specification [BeforeAndAfterLoggingWithListener](BeforeAndAfterLoggingWithListener.md "c:run") which in addition logging the before and after methods, also has two extensions which listen out for the same events and logs those, results in the following :

|[checkRows2][] [text][]|
|----------------------|
|Extension 1: beforeProcessingSpecification |
|Extension 2: beforeProcessingSpecification |
|Before specification  |
|Extension 1: Before outer example [Outer]  |
|Extension 2: Before outer example [Outer]  |
|Before [Outer]        |
|In specification      |
|After [Outer]         |
|Extension 2: After outer example [Outer]  |
|Extension 1: After outer example [Outer]  |
|Extension 1: Before example example1 |
|Extension 2: Before example example1 |
|Before example1       |
|In example 1          |
|After example1        |
|Extension 2: After example example1 |
|Extension 1: After example example1 |
|Extension 1: Before example example2 |
|Extension 2: Before example example2 |
|Before example2       |
|In example 2          |
|After example2        |
|Extension 2: After example example2 |
|Extension 1: After example example2 |
|After specification   |
|Extension 1: afterProcessingSpecification |
|Extension 2: afterProcessingSpecification |

[checkRows2]: - "c:verifyRows=#line : getListenerLog()"
[text]:      - "?=#line"

repository: concordion/concordion

gha_language: Java

gha_license_id: NOASSERTION

repo_name: concordion/concordion


text:
# Sequelized Burger Manager

## Purpose:
Eat-Da-Burger - Sequelized! is a restaurant app utilizing Sequelize that lets users input the names of burgers they'd like to eat.

## Description:
In this project you are presented with two tables and an input area which allow you to manage burgers.  That means you can add new burgers and update a burger once it has been eaten.

## Tech Used:
To accomplish this, the app utilizes NodeJS, SequelizeJS, Express, Express Handlebars and MySQL.  Additionally, for the live version Heroku and JAWSDB.

## Live Version:
The live version is located at: https://eat-da-burger-sqlize-lawrence.herokuapp.com/

repository: lsplaver/sequelizedBurger

repo_name: lsplaver/sequelizedBurger


text:
---
layout: information
title: terms of service
description: Things you should know about using linksOML!
---
## 1. Terms
By accessing the website at http://linkso.ml/, you are agreeing to be bound by
these terms of service, all applicable laws and regulations, and agree that you
are responsible for compliance with any applicable local laws. If you do not
agree with any of these terms, you are prohibited from using or accessing this site.
The materials contained in this website are protected by applicable copyright and
trademark law.

## 2. Use License
Permission is granted to temporarily download one copy of the materials (information
or software) on linksOML's website for personal, non-commercial transitory viewing only.
This is the grant of a license, not a transfer of title, and under this license you may not:

- modify or copy the materials;
- use the materials for any commercial purpose, or for any public display (commercial or non-commercial);
- attempt to decompile or reverse engineer any software contained on linksOML's website;
- remove any copyright or other proprietary notations from the materials; or
- transfer the materials to another person or "mirror" the materials on any other server.

This license shall automatically terminate if you violate any of these restrictions and may be
terminated by linksOML at any time. Upon terminating your viewing of these materials or upon the
termination of this license, you must destroy any downloaded materials in your possession whether
in electronic or printed format.

## 3. Disclaimer
- The materials on linksOML's website are provided on an 'as is' basis. linksOML
makes no warranties, expressed or implied, and hereby disclaims and negates all
other warranties including, without limitation, implied warranties or conditions of
merchantability, fitness for a particular purpose, or non-infringement of intellectual
property or other violation of rights.
- Further, linksOML does not warrant or make any representations concerning the accuracy,
likely results, or reliability of the use of the materials on its website or otherwise
relating to such materials or on any sites linked to this site.

## 4. Limitations
In no event shall linksOML or its suppliers be liable for any damages (including,
without limitation, damages for loss of data or profit, or due to business interruption)
arising out of the use or inability to use the materials on linksOML's website, even
if linksOML or a linksOML authorized representative has been notified orally or in
writing of the possibility of such damage. Because some jurisdictions do not allow
limitations on implied warranties, or limitations of liability for consequential or
incidental damages, these limitations may not apply to you.

## 5. Accuracy of Materials
The materials appearing on linksOML's website could include technical, typographical,
or photographic errors. linksOML does not warrant that any of the materials on its
website are accurate, complete or current. linksOML may make changes to the materials
contained on its website at any time without notice. However linksOML does not make any
commitment to update the materials.

## 6. Links
linksOML has not reviewed all of the sites linked to its website and is not responsible
for the contents of any such linked site. The inclusion of any link does not imply endorsement
by linksOML of the site. Use of any such linked website is at the user's own risk.

## 7. Modifications
linksOML may revise these terms of service for its website at any time without notice.
By using this website you are agreeing to be bound by the then current version of these
terms of service.

## 8. Governing Law
These terms and conditions are governed by and construed in accordance with the laws of Ontario
and you irrevocably submit to the exclusive jurisdiction of the courts in that State or location.


text:
# comichron-data/urls

Url builder for accessing https://github.com/comichron-data/api

This is a helper module for implementing your own client. See [comichron-data/browser-client](https://github.com/comichron-data/browser-client) for an existing client module.

## Install

`npm install comichron-data-urls --save`

## API

```js
var urls = require('comichron-data-urls');
```

### urls.titles()

Makes url for getting titles.

### urls.byMonth(id)

Makes url for getting by-month data.

- id - Comic id from titles response

### urls.byIssue(id)

Makes url for getting by-issue data.

- id - Comic id from titles response

### urls.sourceData(year, month)

Makes url for getting source data.

- year - 4 digit year. String or Number.
- month - 1 or 2 digit month. January is 1. String or Number.

## License

MIT

repository: comichron-data/urls

repo_name: comichron-data/urls


text:
# Configuration Modification

## Overview

Learn how to use various configuration options available in `ConfigInterface`.

## Definition

See the definition of the object that you must pass to props to modify the component configuration:

```ts
interface ConfigInterface {
  schemaID?: string;
  show?: {
    info?: boolean;
    channels?: boolean;
    servers?: boolean;
    messages?: boolean;
    schemas?: boolean;
  };
  expand?: {
    channels?: {
      root?: boolean;
      elements?: boolean;
    };
    servers?: {
      root?: boolean;
      elements?: boolean;
    };
    messages?: {
      root?: boolean;
      elements?: boolean;
    };
    schemas?: {
      root?: boolean;
      elements?: boolean;
    };
  },
  showErrors?: boolean;
  parserOptions?: ParserOptions;
  pushStateBehavior?: (hash: string) => void;
}
```

- **schemaID?: string**

  This field contains a schema name.
  This field is set to `asyncapi` by default.

- **show?: Partial<ShowConfig>**

  This field contains configuration responsible for rendering specific parts of the AsyncAPI component.
  All fields are set to `true` by default.

- **expand?: Partial<ExpandConfig>**

  This field contains configuration responsible for expanding specific parts of the AsyncAPI component automatically.
  `root` refers to a root component for specific parts of the AsyncAPI component, and `elements` refers to elements inside the `root` component.
  By default, `expand.channels.root` is set to `true`.

- **showErrors?: boolean**

  This field turns on or off the option displaying validation or parsing errors that show at the top of the component.
  This field is set to `true` by default.

- **parserOptions?: ParserOptions**

  This field contains configuration for [`asyncapi-parser`](https://github.com/asyncapi/parser). See available options [here](https://github.com/asyncapi/parser-js/blob/master/API.md#parser).
  This field is set to `null` by default.

- **pushStateBehavior?: (hash: string) => void**

  This field contains custom logic for changing the `hash` parameter in the URL of a page.
  See the default logic [here](../../library/src/store/useChangeHash.ts#L11).

## Examples

See exemplary component configuration in TypeScript and JavaScript.

### TypeScript

```tsx
import * as React from "react";
import { render } from "react-dom";
import AsyncApiComponent, { ConfigInterface } from "asyncapi-react";

import { schema } from "./mock";

const config: Partial<ConfigInterface> = {
  schemaID: 'custom-name',
  show: {
    schemas: false
  },
  showErrors: false
};

const App = () => <AsyncApiComponent schema={schema} config={config} />;

render(<App />, document.getElementById("root"));
```

### JavaScript

```jsx
import * as React from "react";
import { render } from "react-dom";
import AsyncApiComponent from "asyncapi-react";

import { schema } from "./mock";

const config = {
  schemaID: 'custom-name',
  show: {
    schemas: false
  },
  showErrors: false
};

const App = () => <AsyncApiComponent schema={schema} config={config} />;

render(<App />, document.getElementById("root"));
```

In the above examples, after concatenation with the default configuration, the resulting configuration looks as follows:

```js
{
  schemaID: 'custom-name',
  show: {
    info: true,
    servers: true,
    channels: true,
    messages: true,
    schemas: false
  },
  showErrors: false
}
```

repository: asyncapi/asyncapi-react

repo_name: asyncapi/asyncapi-react


text:
# qewl-mock

Mocking middleware for [Qewl](https://github.com/kbrandwijk/qewl) GraphQL Application Framework.

## Installation

```
$ yarn add qewl-mock
```

## Usage

```ts
route.use(
  mock({ schema: 'schemaName', mocks?: {...}, preserveResolvers?: true | false })
)
```

Adds mocking to a GraphQL schema. Uses [`addMockFunctionsToSchema`](https://www.apollographql.com/docs/graphql-tools/mocking.html) from `graphql-tools`.

> **Note**: The `preserveResolvers` setting only applies to the resolvers in your original schema. Any resolvers you add using the Qewl `resolve` function will override the mock functions. This allows for optimal control over your resolvers.

Uses [Faker.js](https://github.com/marak/Faker.js/) for default mock values for `Number`, `Float` and `String`.
Uses `cuid` for mock values for `ID`.

You can use `qewl-mock` together with Qewl GraphQL middleware functions to add additional processing to the mocked results, just like normal queries.

## Example

```ts
import * as express from 'express'
import { expressPlayground } from 'graphql-playground-middleware'
import { schema, remoteSchema, use, resolve } from 'qewl'
import { mock } from 'qewl-mock'

import { helloSchema } from './helloSchema'
import { helloResolver } from './helloResolver'

async function run() {

  const app = express()
  const graphql = express.Router()

  // Schema
  graphql.use(
    schema({ name: 'mySchema', schema: `
      type Query {
        hello: String
      }`
    })
  )

  // Mocking
  graphql.use(
    mock({schema: 'mySchema'})
  )

  // Endpoint
  graphql.use(
    serve()
  )

  app.use('/graphql', express.json(), graphql)
  app.use('/playground', expressPlayground({ endpoint: '/graphql' }))

  app.listen(3000, () => console.log('Server running. Open http://localhost:3000/playground to run queries.'))
}

run().catch(console.error.bind(console))
```

repository: qewl/qewl-mock

repo_name: qewl/qewl-mock


text:
# TStack Change Log

## 0.0.0 Inital Commit

## 0.0.1 JSDoc Comments

Add JSDoc comments to most (hopefully all) code and added changelog

## 0.0.2 - Rename 'dme-modules' to 'tstack'

## 0.0.3 - NG-Packagr

### Features
* Move src into src/modules to allow for a demo app
* Use ng-packagr to help with following best practices
* Change license from Apache 2.0 to MIT

### BREAKING CHANGES
* Rename 'getNestedValue' to 'getValue' in 'core/functions/object'
* Rename 'setNestedValue' to 'setValue' in 'core/functions/object'

repository: DustinMEastway/tstack

repo_name: DustinMEastway/tstack


text:
# Rhodotorula bogoriensis (Deinema) Arx & Weijman, 1980 SPECIES

#### Status
ACCEPTED

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

#### Published in
Antonie van Leeuwenhoek 45(4): 554 (1980)

#### Original name
Candida bogoriensis Deinema, 1961

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
The transpose of  `conv2d` .

```
 tf.nn.conv2d_transpose(
    input,
    filters,
    output_shape,
    strides,
    padding='SAME',
    data_format='NHWC',
    dilations=None,
    name=None
)

```

This operation is sometimes called "deconvolution" after [DeconvolutionalNetworks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf), but isactually the transpose (gradient) of  `conv2d`  rather than an actualdeconvolution.

#### 参数：
- **`input`** : A 4-D  `Tensor`  of type  `float`  and shape  `[batch, height, width,in_channels]`  for  `NHWC`  data format or  `[batch, in_channels, height,width]`  for  `NCHW`  data format.
- **`filters`** : A 4-D  `Tensor`  with the same type as  `input`  and shape  `[height,width, output_channels, in_channels]` .   `filter` 's  `in_channels`  dimensionmust match that of  `input` .
- **`output_shape`** : A 1-D  `Tensor`  representing the output shape of thedeconvolution op.
- **`strides`** : An int or list of  `ints`  that has length  `1` ,  `2`  or  `4` .  Thestride of the sliding window for each dimension of  `input` . If a singlevalue is given it is replicated in the  `H`  and  `W`  dimension. By defaultthe  `N`  and  `C`  dimensions are set to 0. The dimension order is determinedby the value of  `data_format` , see below for details.
- **`padding`** : A string, either  `'VALID'`  or  `'SAME'` . The padding algorithm. Seethe "returns" section of [ `tf.nn.convolution` ](https://tensorflow.google.cn/api_docs/python/tf/nn/convolution) for details.
- **`data_format`** : A string. 'NHWC' and 'NCHW' are supported.
- **`dilations`** : An int or list of  `ints`  that has length  `1` ,  `2`  or  `4` ,defaults to 1. The dilation factor for each dimension of `input` . If asingle value is given it is replicated in the  `H`  and  `W`  dimension. Bydefault the  `N`  and  `C`  dimensions are set to 1. If set to k > 1, therewill be k-1 skipped cells between each filter element on that dimension.The dimension order is determined by the value of  `data_format` , see abovefor details. Dilations in the batch and depth dimensions if a 4-d tensormust be 1.
- **`name`** : Optional name for the returned tensor.

#### 返回：
A  `Tensor`  with the same type as  `input` .

#### 加薪：
- **`ValueError`** : If input/output depth does not match  `filter` 's shape, or ifpadding is other than  `'VALID'`  or  `'SAME'` .

repository: veaba/tensorflow-docs

repo_name: veaba/tensorflow-docs


text:
---
title: Starter kit equivalent
desc: Tips and tricks on how to use a Quasar App Extension to create the equivalent of a starter kit.
scope:
  tree:
    l: "."
    c:
    - l: README.md
    - l: package.json
    - l: src
      c:
      - l: boot
        c:
        - l: my-starter-kit-boot.js
      - l: templates
        c:
        - l: common-files
          c:
          - l: README.md
          - l: some-folder
            c:
            - l: tasks.md
        - l: serviceA
          c:
          - l: src
            c:
            - l: services
              c:
              - l: serviceA.js
        - l: serviceB
          c:
          - l: src
            c:
            - l: services
              c:
              - l: serviceB.js
      - l: index.js
        e: Described in Index API
      - l: install.js
        e: Described in Install API
      - l: prompts.js
        e: Described in Prompts API
      - l: uninstall.js
        e: Described in Uninstall API
---

This guide is for when you want to create what essentially is a "starter kit" that adds stuff (/quasar.config file configuration, folders, files, CLI hooks) on top of the official starter kit. This allows you to have multiple projects sharing a common structure/logic (and only one package to manage them rather than having to change all projects individually to match your common pattern), and also allows you to share all this with the community.

::: tip
In order for creating an App Extension project folder, please first read the [Development Guide > Introduction](/app-extensions/development-guide/introduction).
:::

::: tip Full Example
To see an example of what we will build, head over to [MyStarterKit full example](https://github.com/quasarframework/app-extension-examples/tree/v2/my-starter-kit), which is a github repo with this App Extension.
:::

We'll be creating an example App Extension which does the following:

* it prompts the user what features it wants this App Extension to install
* renders (copies) files into the hosting folder, according to the answers he gave
* it extends the /quasar.config file
* it extends the Webpack configuration
* it uses an App Extension hook (onPublish)
* it removes the added files when the App Extension gets uninstalled
* it uses the prompts to define what the App Extension does

## The structure

For the intents of this example, we'll be creating the following folder structure:

<doc-tree :def="scope.tree" />

## The install script

The install script below is only rendering files into the hosted app. Notice the `src/templates` folder above, where we decided to keep these templates.

```js
// src/install.js

module.exports = function (api) {
  // (Optional!)
  // Quasar compatibility check; you may need
  // hard dependencies, as in a minimum version of the "quasar"
  // package or a minimum version of Quasar App CLI
  api.compatibleWith('quasar', '^2.0.0')

  if (api.hasVite === true) {
    api.compatibleWith('@quasar/app-vite', '^1.0.0-beta.0')
  }
  else { // api.hasWebpack === true
    api.compatibleWith('@quasar/app-webpack', '^3.0.0')
  }

  // We render some files into the hosting project

  if (api.prompts.serviceA) {
    api.render('./templates/serviceA')
  }

  if (api.prompts.serviceB) {
    // we supply interpolation variables
    // to the template
    api.render('./templates/serviceB', {
      productName: api.prompts.productName
    })
  }

  // we always render the following template:
  api.render('./templates/common-files')
}
```

Notice that we use the prompts to decide what to render into the hosting project. Furthermore, if the user has selected "service B", then we'll also have a "productName" that we can use when we render the service B's file.

## The index script

We do a few things in the index script, like extending the /quasar.config file, hooking into one of the many Index API hooks (onPublish in this case), and chaining the Webpack configuration:

```js
// src/index.js

module.exports = function (api) {
  // (Optional!)
  // Quasar compatibility check; you may need
  // hard dependencies, as in a minimum version of the "quasar"
  // package or a minimum version of Quasar App CLI
  api.compatibleWith('quasar', '^2.0.0')

  if (api.hasVite === true) {
    api.compatibleWith('@quasar/app-vite', '^1.0.0-beta.0')
  }
  else { // api.hasWebpack === true
    api.compatibleWith('@quasar/app-webpack', '^3.0.0')
  }

  // Here we extend the /quasar.config file;
  // (extendQuasarConf() will be defined later in this tutorial, continue reading)
  api.extendQuasarConf(extendQuasarConf)

  // Here we register the onPublish hook,
  // only if user answered that he wants the publishing service
  if (api.prompts.publishService) {
    // onPublish() will be defined later in this tutorial, continue reading
    api.onPublish(onPublish)
  }

  if (api.hasVite === true) {
    api.extendViteConf(extendVite)
  }
  else { // api.hasWebpack === true
    // we add/change/remove something in the Webpack configuration
    // (chainWebpack() will be defined later in this tutorial, continue reading)
    api.chainWebpack(chainWebpack)
  }

  // there's lots more hooks that you can use...
}
```

Here's an example of `extendQuasarConf` definition:

```js
function extendQuasarConf (conf, api) {
  conf.extras.push('ionicons-v4')
  conf.framework.iconSet = 'ionicons-v4'

  //
  // We register a boot file. User does not need to tamper with it,
  // so we keep it into the App Extension code:
  //

  // make sure my-ext boot file is registered
  conf.boot.push('~quasar-app-extension-my-starter-kit/src/boot/my-starter-kit-boot.js')

  // @quasar/app-vite does not need this
  if (api.hasVite !== true) {
    // make sure boot file get transpiled
    conf.build.transpileDependencies.push(/quasar-app-extension-my-starter-kit[\\/]src/)
  }
}
```

The `onPublish` function:

```js
function onPublish (api, { arg, distDir }) {
  // this hook is called when "quasar build --publish" is called

  // your publish logic here...
  console.log('We should publish now. But maybe later? :)')

  // are we trying to publish a Cordova app?
  if (api.ctx.modeName === 'cordova') {
    // do something
  }
}
```

The `extendVite` function:

```js
function extendVite (viteConf, { isClient, isServer }, api) {
  // viteConf is a Vite config object generated by Quasar CLI
}
```

The `chainWebpack` function:

```js
function chainWebpack (cfg, { isClient, isServer }, api) {
  // cfg is a Webpack chain Object;
  // docs on how to use it: webpack-chain docs (https://github.com/neutrinojs/webpack-chain)
}
```

## The uninstall script

When the App Extension gets uninstall, we need to do some cleanup. But beware what you delete from the app-space! Some files might still be needed. Proceed with extreme care, if you decide to have an uninstall script.

```js
// we yarn added it to our App Extension,
// so we can import the following:
const rimraf = require('rimraf')

module.exports = function (api) {
  // Careful when you remove folders!
  // You don't want to delete files that are still needed by the Project,
  // or files that are not owned by this app extension.

  // Here, we could also remove the /src/services folder altogether,
  // but what if the user has added other files into this folder?

  if (api.prompts.serviceA) {
    // we added it on install, so we remove it
    rimraf.sync(api.resolve.src('services/serviceA.js'))
  }

  if (api.prompts.serviceB) {
    // we added it on install, so we remove it
    rimraf.sync(api.resolve.src('services/serviceB.js'))
  }

  // we added it on install, so we remove it
  rimraf.sync(api.resolve.app('some-folder'))
  // warning... we've added this folder, but what if the
  // developer added more files into this folder???
}
```

Notice that we are requesting `rimraf` npm package. This means that we yarn/npm added it into our App Extension project.

repository: quasarframework/quasar

branch_name: refs/heads/dev

repo_name: quasarframework/quasar


text:
# tracing

## Download

https://www.jaegertracing.io/download/

## Getting Started

https://www.jaegertracing.io/docs/1.22/getting-started/

## Script

```
./run.sh
```

## References

https://github.com/openzipkin/b3-propagation

repository: udhos/tracing

repo_name: udhos/tracing


text:
# Making Contributions

Contributions are absolutely welcome!

So far, I've included most (all?) of the federal holidays in the United States, as well as a few others. There are tests for each holiday, in an attempt to make sure my calculations are correct. This is especially important around complex calculations like the one for Easter.

## Corrections

If you notice anything incorrect, please open a PR if you're able to fix it, or [open a new issue](https://github.com/grantwinney/erl-holidays/issues/new) with as many details as possible, including:

* the function you called,
* the values you passed to it,
* the incorrect result you got,
* the answer you _expected_

## Additions

If you have new holidays to add, you can open a PR (don't forget to add tests for it!), or you can open a [open a new issue](https://github.com/grantwinney/erl-holidays/issues/new) with as many details as possible, and I'll try to add it as time permits:

* the country code for the holiday,
* the calculation to figure out when it falls in a given year (if you know it),
* a few examples of valid dates when the holiday occurs

repository: grantwinney/erl-holidays

gha_language: Erlang

repo_name: grantwinney/erl-holidays