text:
# FundiPythonTutorial
Python hands-on session for the 2021 Fundi tutorials

In this tutorial, we will discuss some of the common and useful packages for analysis of time-domain radio data. All the required software for the tutorial is bundled up into a docker/singularity container. You are free to use either and you will find instructions on how to use it below:

## Use Docker

If you are using docker, note that you will need a docker installation on your laptop as you will likely not have permissions to run docker on the MPIfR machines. Assuming you have a working installation, which you can set up from [here](https://docs.docker.com/get-docker/), the easiest way to use it is to download the image from docker hub by doing:

```
docker pull vivekvenkris/fundi_python_tutorial:latest
```

In case you do not have a good internet connection and wish to build it from scratch, you can clone [this](https://github.com/vivekvenkris/pulsar_folder) repository, `cd` to the repository  and run

```
docker build -t fundi_python_tutorial .
```

Once this is done, you can run the container by doing:

```
docker run -it -p <your_port_number>:<your_port_number> -v <repo_location>:/<repo_location> vivekvenkris/fundi_python_tutorial
```

## Use Singularity

If you are using singularity, you can use either your personal machine or one of the MPIfR machines that has singularity installed (E.g: dogmatix0). You can install singularity on your local machine using instructions from [here](https://sylabs.io/guides/3.0/user-guide/installation.html). The singularity image can either be downloaded from google drive [here](https://drive.google.com/drive/folders/1ASX0Qhl7V39wlefxK_FGmo7luV648Chc?usp=sharing) or from the FPRA meerkat partition here: `/fpra/mkat/01/users/vivek/singularity_images/vivekvenkris_fundi_python_tutorial-2021-10-03-5dd4a33d25e1.sif`. Note that not all will have permissions to access this directory, so revert to downloading from Google Drive if you cant download from here.

Once you have downloaded or copied the singularity image, you can run it by doing
```
singularity shell -B <repo_location>:/<repo_location> /fpra/mkat/01/users/vivek/singularity_images/vivekvenkris_fundi_python_tutorial-2021-10-03-5dd4a33d25e1.sif
```
## Using Jupyter notebook

Once you are inside your docker or singularity container, you can start a jupyter notebook by doing the following

```
cd <repo_location>
jupyter lab --port <your_port_number> --no-browser
```

Your port number here and everywhere else can in principle be anything (although needs to be the same everywhere), but since there might be unconscious overlaps, please choose a random number between 10000 and 11000.

If you are running docker, you need to also add `--allow_root --ip <IP_ADDRESS>` to your jupyter lab command.
If you are running singularity, you need to forward the port you are using to your localhost. You can do that by requesting a port forward by doing:
```
ssh <your_user_name>@<your_machine> -J <gateway machine> -L <your_port_number>:localhost:<your_port_number>
```
For instance, `ssh vkrishnan@dogmatix1 -J portal.mpifr-bonn.mpg.de -L 10034:localhost:10034` forwards the port `10034` from `dogmatix1` to my localhost (my laptop) via the `portal` gateway.

repository: JacobCT/FundiPythonTutorial

repo_name: JacobCT/FundiPythonTutorial


text:
# `spellcheck` Command

Searches the specified project or solution for possible misspellings or typos.

## Synopsis

```shell
roslynator spellcheck <PROJECT|SOLUTION>
[--case-sensitive]
[--culture]
[-d|--dry-run]
[--file-log]
[--file-log-verbosity]
[--ignored-projects]
[--ignored-scope]
[--include-generated-code]
[--interactive]
[--language]
[--min-word-length]
[-m|--msbuild-path]
[--projects]
[-p|--properties]
[--scope]
[-v|--verbosity]
[--visibility]
--words
```

## Arguments

**`PROJECT|SOLUTION`**

Path to one or more project/solution files.

### Required Options

**`--words`** <PATH>

Specified path to file and/or directory that contains list of allowed words.

### Optional Options

**`--case-sensitive`**

Specifies case-sensitive matching.

**`--culture`** <CULTURE_ID>

Defines culture that should be used to display diagnostic message.

**`-d|--dry-run`**

Display misspellings and typos but do not save changes to a disk.

**`--ignored-projects`** <PROJECT_NAME>

Defines projects that should not be analyzed.

**`--ignored-scope`** <SCOPE>

Defines syntax that should not be analyzed. Allowed values are `comment`, `type`, `member`, `local`, `parameter`, `non-symbol` and `symbol`.

**`--include-generated-code`**

Indicates whether generated code should be spellchecked.

**`--interactive`**

Enable editing of a replacement.

**`--language`** `{cs[harp]|v[isual-]b[asic])}`

Defines project language.

**`--min-word-length`** <NUM>

Specifies minimal word length to be checked. Default value is 3.

**`-m|--msbuild-path`** <MSBUILD_PATH>

Defines a path to MSBuild. This option must be specified if there are multiple locations of MSBuild. This is usually required when multiple versions of Visual Studio are installed.

**`--projects`** <PROJECT_NAME>

Defines projects that should be analyzed.

**`-p|--properties`** `<NAME=VALUE>`

Defines one or more MSBuild properties.

**`--scope`** <SCOPE>

Defines syntax that should be analyzed. Allowed values are `comment`, `type`, `member`, `local`, `parameter`, `non-symbol` and `symbol`.

**`-v|--verbosity`** `{q[uiet]|m[inimal]|n[ormal]|d[etailed]|diag[nostic]}`

Defines the amount of information to display in the log.

**`--visibility`** <VISIBILITY>

Defines a  maximal visibility of a symbol to be fixable. Allowed values are `public`, `internal` or `private`. Default value is `public`.

## Redirected/Piped Input

Redirected/piped input will be used as a list of project/solution paths separated with newlines.

## How to Suppress Spellchecking

Possible misspelling or typo is reported as a diagnostic `RCS2001`.
Thus it is possible to [suppress](../HowToConfigureAnalyzers.md#how-to-suppress-a-diagnostic) it as any other diagnostic.

## List of Allowed Words

* It is required to specify one or more wordlists (parameter `--words`).
* Wordlist is defined as a text file that contains list of values separated with newlines.
* Each value is either a valid word (for example `misspell`) or a fix in a format `<ERROR>: <FIX>` (for example `mispell: misspell`).
* Word matching is case-insensitive by default (use option `--case-sensitive` to specify case-sensitive matching).
* It is recommended to use [Wordb](https://github.com/JosefPihrt/Wordb/tree/main/data) wordlists that are specifically tailored to be used for spellchecking.

## See Also

* [Roslynator Command-Line Interface](README.md)

repository: bubdm/Roslynator

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: bubdm/Roslynator


text:
# Wearable_Sensor_Long-term_sEMG_Dataset

This code is described in the paper
Are armband sEMG devices dense enough for long-term use?--Sensor placement shifts cause significant reduction in recognition accuracy
accepted by *Biomedical Signal Processing and Control*.

You can see very simple online processing for controlling 3D graphics using by this dataset from here (online_processing).

In addition, the effect of reattachment is here (indiscriminable_reattachment).

__\<Description\>__

After changing your directories in set_config.m and downloading getxxfeat.m, you can use this codes.

This project has four folders:

1. hand motions

    8 short movies for each fundamental forearm motion

2. data

   - 30-days EMG data from 5 subjects
   - csv files (each data has 1.5-s information)
   - D means day
   - M means the motion label (e.g., M1 means resting state and M2 means wrist flexion)
   - T means the number of trials

3. code

   this folder has one main m.file named main_script that uses:

   - set_config

   - preprocessing

        - extract_feature

        you can get the following m.files from here

            - getrmsfeat

            - getmavfeat

            - getzcfeat

            - getsscfeat

            - getwlfeat

            - getarfeat

    - intraday

        - plot_figure6_and_figure7

    - interday

        - labeling

        - interday_recog

        - plot_figure8

    - interday_sub

        - plot_figure9

4. resuts

   this folder will store all results (but this main script requires about 10GB for saving result data, please take care before using it)

__\<Environments\>__

MATLAB R2018b

 1. Signal Processing Toolbox
 2. Statics and Machine Learning Toolbox


text:
# react-table-plain · ![travis build](https://img.shields.io/travis/DCCS-IT-Business-Solutions/react-table-plain.svg) ![npm<EMAIL_ADDRESS>
A NPM package that helps creating HTML tables in a React-way. It was partly inspired by [react-table](https://react-table.js.org).

@dccs/react-table-plain is written in [Typescript](https://www.typescriptlang.org/) and comes with its own type definitions.

## Installation

You should install [react-table-plain with npm or yarn](https://www.npmjs.com/package/@dccs/react-table-plain):

    npm install @dccs/react-table-plain
    or
    yarn add @dccs/react-table-plain

This command will download and install react-table-plain and all required dependencies.

## Minimal version

```javascript
import React from "react";
import { TablePlain } from "@dccs/react-table-plain";

function App() {
  return (
    <TablePlain
      data={[
        { id: 1, name: "Alexa" },
        { id: 2, name: "Google Home" },
        { id: 3, name: "Cortana" }
      ]}
      colDef={[
        {
          prop: "id",
          header: "ID"
        },
        {
          prop: "name",
          header: "User name",
          sortable: true
        }
      ]}
    />
  );
}
```

[![Edit react-table-plain mini](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/1o5m67xz5j)

## Properties

| Property                  | Type                                                         | Optional | Description                                                                                |
| ------------------------- | ------------------------------------------------------------ | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| rootElement               | React.ReactNode                                              | x        | Normaly <table>                                                                                |
| rowElement                | React.ReactNode                                              | x        | Normaly <tr>                                                                                |
| cellElement               | React.ReactNode                                              | x        | Normaly <td>                                                                                |
| headerCellElement         | React.ReactNode                                              | x        | Normaly <th>                                                                                |
| headerElement             | React.ReactNode                                              | x        | Normaly <thead>                                                                                |
| bodyElement               | React.ReactNode                                              | x        | Normaly <tbody>                                                                                |
| footerElement?            | React.ReactNode                                              | x        | Normaly <tfooter>                                                                                |
| renderSortLabel?          | colDef: IColDef, desc: boolean) => React.ReactNode           | x        | Render the sort label (arrow down/up) in header                                                                                |
| data                      | any[]                                                        |          | Data array to render                                                                                |
| colDef?                   | IColDef[]                                                    | x        | Definitions for all columns                                                                                |
| orderBy?                  | string                                                       | x        |
| sort?                     | "asc" \| "desc"                                              |          |
| onChangeOrderBy?          | colDef: IColDef) => void                                     | x        | Called, when sorting changed                                                                                |
| onChangeFilter?           | ChangeFilterHandler                                          | x        | Called, when filter changed                                                                                |
| onRowClick?               | data: any) => void                                           | x        | Called, when one row has bee clicked                                                                                |
| renderRoot?               | children: React.ReactNode) => React.ReactNode                | x        | Returns root element to render                                                                                |
| renderHeaderCell?         | col: IColDef, idx: number) => React.ReactNode                | x        | Returns header element to render                                                                                |
| renderFooterCell?         | ( col: IColDef, data: any[], idx: number) => React.ReactNode | x        | Returns footer element to render                                                                                |
| renderFilter?             | (col: IColDef, idx: number) => React.ReactNode               | x        | Returns the filter for a column                                                                                |
| renderExpansionIndicator? | (expanded: boolean) => React.ReactNode                       | x        | Returns the expanstion indicator to toggle a sub-component.                                                                                |
| subComponent?             | (data: any) => React.ReactNode                               | x        | Returns the subcomponent for a row.                                                                                |
| rowProps?                 | (data: any) => object                                        | x        | Callback that returns the props for a row.                                                                                |
| cellProps?                | (data: any) => object                                        | x        | Callback that returns the props for a cell.                                                                                |
| filter?                   | object                                                       | x        | Current filter object.                                                                                |
| defaultFilter?            | object                                                       | x        | One time filter object.                                                                                |
| ellipsis?                 | boolean                                                      | x        | Use text ellipsis to shorten lengthy text content?                                                                                |
| selectedRow?              | any / any[]                                                  | x        | If any single-line-selection, if any[] multi-line-selection.                                                                                |
| onChangeSelectedRow?      | (data:any)=>void                                             | x        | Callback when selection changes.                                                                                |
| selectedRowProps?         | (data:any)=>object                                           | x        | Gets called if row is in scope of "selectedRow". The return value is set as property in the "tr" tag.                                                      |
| rowSelectionColumnName    | string                                                       | x        | The name of the property of data that should be checked if it is in "selectedRow" scope. If null/undefined it checks if the whole data object is in scope. |

## Features

### Sorting

react-table-plain supports sorting by a single column.

```javascript
class App extends React.Component {
  state = {
    orderby: "",
    sort: "asc",
    data: [
      { id: 1, name: "Alexa" },
      { id: 2, name: "Google Home" },
      { id: 3, name: "Cortana" }
    ]
  };
  render() {
    return (
      <TablePlain
        data={this.state.data}
        colDef={[
          {
            prop: "id",
            header: "ID"
          },
          {
            prop: "name",
            header: "User name",
            sortable: true
          }
        ]}
        orderBy={this.state.orderby}
        sort={this.state.sort}
        onChangeOrderBy={this.handleChangeOrderBy}
      />
    );
  }

  handleChangeOrderBy = col => {
    let sort? : SortDirection;
    if (this.state.orderby === col.prop) {
      sort = this.state.sort === "desc" ? "asc" : "desc";
    }
    this.setState(prev => ({
      orderby: col.prop,
      sort,
      data: sortData(prev.data, col.prop, sort)
    }));
  };
}

function sortData(data, prop, desc) {
  let result = data.sort((a, b) => a[prop] > b[prop]);
  return desc ? result.reverse() : result;
}
```

[![Edit react-table-plain sort](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/305v98omy5)

**IMPORTANT:** react-table-plain doesn't do the sorting. It just displays the data.
The caller is responsible for sorting the data.

### Render custom cells

TODO

### Set row props

You can set the props of each row, depending on the data for each row. For example to highlight a single row.

```javascript
import React from "react";
import { TablePlain } from "@dccs/react-table-plain";

function App() {
  return (
    <TablePlain
      data={[
        { id: 1, name: "Alexa" },
        { id: 2, name: "Google Home" },
        { id: 3, name: "Cortana" }
      ]}
      colDef={[
        {
          prop: "id",
          header: "ID"
        },
        {
          prop: "name",
          header: "User name",
          sortable: true
        }
      ]}
      rowProps={data => ({
        style: { background: data.id === 1 ? "yellow" : null }
      })}
    />
  );
}
```

[![Edit react-table-plain rowProps](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/18vv15mo84)

### Fixed Column width

Depending on the displayed data the width of the columns might vary. To prevent that (i.e. during paging) you may set the width of a column.
How does it work:

```javascript
colDef={[{
    prop: "id",
    header: "ID",
    width: 1
  },
  {
    prop: "name",
    header: "Full name",
    width: 2
  },
  {
    prop: "ocupation",
    header: "Work",
    width: 2
  }]}
```

[![Edit react-table-plain rowProps](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/l39m51vk1z)

The total of all widths is 100% of the table width and each column is sized according to the width value. Like:

- Property "id" has a width of 1 of a total of 5. So the with is 1/5 of 100% that is 20% of the table width.
- Property "name" has a width of 2. The total width is still 5. So the width is 2/5. That is 40% of the table width.

### Filter

You can add a filter for each row.

```javascript
colDef={[
  {
    prop: "name",
    header: "Full name",
    filterable: true
  }
]}
```

This renders a `<input type="text" />` below the `header`.
`onChangeFilter` reflects any changes to the filter.

#### Custom Filter inputs

To render custom filter inputs i.e. a datepicker you can provide the `renderFilter` property with a component.

```javascript
colDef={[
  {
    prop: "name",
    header: "Full name",
    filterable: true,
    renderFilter: (value, handleChange) => <Datepicker value={value} onChange={e => handleChange(e.traget.value)}
  }
]}
```

[![Edit react-table-plain rowProps](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/y0jorjqp41)

The `handleChange` callback enables the table to collect all filter values and provide them to you.

#### Handling Filter State

By default the filter state is handled by `react-table-plain`. If you like to preset filter values or have control over the filter as a whole you can provide a `filter` property of type `object`.
Now it is your responsipility to update the `filter` property according to the changes delivered by the `onChangeFilter` callback. If you don't update the `filter` no updates will be seen in the view.

```javascript
state = {
  filter: {}
}

render() {
  return <TablePlain
    colDef={[{
      prop: "name",
      header: "Full name",
      filterable: true
    }]}
    filter={this.state.filter}
    onChangeFilter={this.handleFilterChange}
    />;
}

handleFilterChange = (col, val) => {
  this.setState(p => ({
    filter: {
      {...p.filter},
      [col.prop]: val
    }
  }))
}
```

[![Edit react-table-plain external filter](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/92z0klrvmp)

### Cell properties for all cells

To set the props of all body cells you can use the `cellProps` property of the table like this:

```javascript
<TablePlain
  cellProps={data => ({
    style: {
      whiteSpace: "nowrap",
      width: "100%",
      overflow: "hidden",
      textOverflow: "ellipsis"
    }
  })}
  // ...
/>
```

### Row Selection

This table supports two types of selection. Single and Multi Selection

#### Single Row Selection

selectedRow: To use single-row-selection the selectedRow has to bee of type "any". In this case the Id of the selected row.

selectedRowProps: This function is called by every row that is in scope of selectedRow. The function returns a object which is put into "tr" tag of the row. If this function is not provided the background of the Row is set to grey by default.

onChangeSelectedRow: This function is called, when the selection changes (User clicks on row).

rowSelectionColumnName: The name of the property of the data that should be checked if it is in scope of selectedRow. If it is not provided the whole data object is checked if it is in scope.

```javascript
const data = [
  { id: 1, name: "Alexa" },
  { id: 2, name: "Google Home" },
  { id: 3, name: "Cortana" }
];

const [selectedRow, setSelectedRow] = React.useState();

function handleSelectionChange(data) {
  setSelectedRow(data.id);
}

function selectedRowProps(data) {
  return { style: { background: "yellow" } };
}

<TablePlain
  data={data}
  colDef={[
    {
      prop: "id",
      header: "ID"
    },
    {
      prop: "name",
      header: "User name",
      sortable: true
    }
  ]}
  selectedRow={selectedRow}
  selectedRowProps={selectedRowProps}
  onChangeSelectedRow={handleSelectionChange}
  rowSelectionColumnName="id"
/>;
```

[![Edit react-table-plain single-line-selection](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/0y5k9y0pjv?fontsize=14)

#### Multi-Line-Selection

selectedRow: To use multi-row-selection the selectedRow has to bee of type "any[]". In this case the Ids of the selected rows.

selectedRowProps: This function is called by every row that is in scope of selectedRow. The function returns a object which is put into "tr" tag of the row. If this function is not provided the background of the Row is set to grey by default.

onChangeSelectedRow: This function is called, when the selection changes (User clicks on row).

rowSelectionColumnName: The name of the property of the data that should be checked if it is in scope of selectedRow. If it is not provided the whole data object is checked if it is in scope.

```javascript
const data = [
  { id: 1, name: "Alexa" },
  { id: 2, name: "Google Home" },
  { id: 3, name: "Cortana" }
];

const [selectedRows, setSelectedRows] = React.useState([]);

function selectedRowProps(data) {
  return { style: { background: "yellow", cursor: "pointer" } };
}

function handleSelectionChange(data) {
  setSelectedRows([...selectedRows, data.id]);
}

<TablePlain
  data={data}
  colDef={[
    {
      prop: "id",
      header: "ID"
    },
    {
      prop: "name",
      header: "User name",
      sortable: true
    }
  ]}
  selectedRow={selectedRows}
  selectedRowProps={selectedRowProps}
  onChangeSelectedRow={handleSelectionChange}
  rowSelectionColumnName="id"
/>;
```

[![Edit react-table-plain multi-line-selection](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/oxxw81kmnz?fontsize=14)

### Content styling

#### Alignment

You can always set cell properties with `props: () => ({style: {textAlign: "right"}})` to achive alignment of the cell content.
To make things easier we introduced the `align` property, that aligns header, body and footer cell content.

[![Edit react-table-plain align](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/oxnvn95lz)

#### Ellipsis

This setting applies to all body cells.

[![Edit react-table-plain table-wide cell props](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/v32l3qo010)

### Subcomponent

TODO

### Theming

TODO

## Contributing

## Publish a new version

Create a new version: `npm version [major|minor|patch]`
then push with tags: `git push origin --follow-tags`

### License

@dccs/react-table-plain is [MIT licensed](https://github.com/facebook/react/blob/master/LICENSE)

license: MIT

gha_language: TypeScript

gha_license_id: MIT


text:
# MobX Architecture

***Hello!*** This package allows you to more easily and cleanly bind your MobX stores to your UI.
For now, it focuses  mainly on the binding of ViewModels to the UI,  and provides an instance of MediaQueryData, for sizing widgets, getting the orientation, etc. more conveniently. ( No one wants MediaQueries scattered all over the place, now do they? )

If you do like this package, please do star it over on GitHub. Any and all contributions, whether they be to the docs, or the code, in the form of bug fixes or new features or even feature requests, are all highly, highly appreciated and encouraged.

This package has a lot of potential, and I plan to actively maintain this package and add new features on as regular a basis as possible, and contributions would really help out a lot. So, any new feature you feel will benefit this package, please don't hesitate to add a feature request over on the package's repository.

## Getting Started

### First, let's get some of the introductions, assumptions, and  requirements out of the way.
This package helps implement a custom version of the [MVVM](https://en.wikipedia.org/wiki/Model–view–viewmodel) architecture pattern, smooshing together the **Widget-Store-Service** organization pattern mentioned in the [Flutter MobX docs](https://en.wikipedia.org/wiki/Model–view–viewmodel) with the traditional **Model-View-ViewModel** architecture pattern, resulting in a unified pattern where:
- The **Model** is relatively unchanged, and houses the services, API calls etc.
- The **ViewModel** is unified with the **MobX Store**, and has the dual purpose of managing state (either local, shared or any other) as well as the business logic of the corresponding **View**
- The **View** is relatively unchanged, with the one major difference being [Observer](https://pub.dev/packages/flutter_mobx) widgets sprinkled about as necessary, wrapping the parts of the UI that render based on the state of the app

---

*This package assumes the following:*
- You are using the [MVVM](https://en.wikipedia.org/wiki/Model–view–viewmodel) architecture pattern to architect your app
- You are using [Provider](https://pub.dev/packages/provider) to inject your MobX stores. ( Although not required *per se*, as the package has widgets for that scenario, it is still ***highly*** recommended ).

---

*This package depends on / must be used in conjunction with the following extra packages:*
- [MobX](https://pub.dev/packages/mobx) (Of course)
- [Flutter Mobx](https://pub.dev/packages/flutter_mobx) (For **Observer** Widgets, which you most likely are using already)
---
### Note:
- [Provider](https://pub.dev/packages/provider) is **highly** recommended to be used alongside MobX itself, as well as this package, and is internally used by parts of the package as well,to inject your MobX stores wherever they are required. Checkout the MobX [docs](https://mobx.netlify.app/guides/stores/) for more info.
- Using the parts of the package that depend on Provider ( .usesProvider constructors) without actually having Provider as a dependency may lead to unexpected behaviour
---
*Before we begin, here are some packages that I recommend using with this package, some because they play  better than others with this package, and some because I feel they promote the safest, cleanest code:*
- [Get_it](https://pub.dev/packages/get_it) for a service locator ( Even though Provider is most likely a dependency already, this package comes in handy for
injecting services and such, and also for accessing them from *ViewModels*, where the *BuildContext* isn't as readily available, if at all
- [Hive](https://pub.dev/packages/hive) for local data persistence
---

This package exposes 4 widgets, and 6 total variations in the implementation across those 4 widgets ( using constructors ), with
the widgets and their variations being split based on these 3 requirements:
- Binding a ViewModel that is ***not*** a MobX Store
- Binding a ViewModel that ***is*** a MobX Store
- Stateless and Stateful vairations of the above mentioned criteria, so as to be able to
access widget lifecycle methods, such as ***inItState( )*** and ***dispose(  )*** , when required.

The widgets are therefore as follows:
- **StatefulVMStoreBuilder\<T>( )** : This widget is used for when you need to access widget lifecycle methods,  and are binding a ViewModel that is also a MobX Store to the UI. It has two constructors:
    - **StatefulVMStoreBuilder\<T>.usesProvider( )** : This constructor is used if you are using the Provider package. It automatically reads the appropriate store from the type ***T*** , using Provider.
		``` dart
			StatefulVMStoreBuilder<Store>.usesProvider(
			  key: ///Optionally provide a key ,
			  builder: (BuildContext context, T store, SizingInfo sizingInfo) {
			  /// Provides the store, the BuildContext and an object containing
			  /// the sizing information of the screen, accessible through.
			  /// [sizingInfo.height] and [sizingInfo.width]

			  return Widget();
			  },
			  initState: (store) {
			  ///Provide a optional ininState method
			  },
			  dispose: (store) {
			  ///Provide a optional dispose method
			  },
			);
		```
    - **StatefulVMStoreBuilder\<T>.standAlone( )** : This constructor is used if you are not using the Provider package
        ```dart
    			StatefulVMStoreBuilder<Store>.standAlone(
    			  key: ///Optionally provide a key ,
    			  viewModelStoreBuilder: () => MyViewModelStore(),
    			  builder: (BuildContext context, T store, SizingInfo sizingInfo) {
    			    /// Provides the store, the BuildContext and an object containing
    			    /// the sizing information of the screen, accessible through.
    			    /// [sizingInfo.height] and [sizingInfo.width]

    			    return Widget();
    			    },
    			  initState: (store) {
    			  ///Provide a optional ininState method
    			  },
    			  dispose: (store) {
    			  ///Provide a optional dispose method
    			  },
    			);
    	```
        Note:
    	If you are using this constructor, then Observer Widgets from the [Flutter Mobx](https://pub.dev/packages/flutter_mobx) package or equivalent reactions should be used, and setState or other ways of re-triggering the build function of the widget must not be used, as the Store is instantiated inside the build method, and re-triggering it causes a new store to be created.

    	This of course does not occur with the .usesProvder variation of the widget, as then the instance of the store is gotten from Provider.

    	Furthermore, if you instantiate the store with values that are stored/kept track of elsewhere in your code, or if you are fine with the store’s instance members returning to their default values when the build function is called again, then re-triggering the build function is perfectly fine.
-  **StatelessVMStoreBuilder\<T>( )**: This widget is used for when you ***don't*** need to access widget lifecycle methods,  and are binding a ViewModel that is also a MobX Store to the UI. It has two constructors:
   - **StatelessVMStoreBuilder\<T>.usesProvider( )** : This constructor is used if you are using the Provider package. It automatically reads the appropriate store from the type ***T*** , using Provider.

		``` dart
			StatelessVMStoreBuilder<Store>.usesProvider(
			  key: ///Optionally provide a key ,
			  builder: (BuildContext context, T store, SizingInfo sizingInfo) {
			  /// Provides the store, the BuildContext and an object containing
			  /// the sizing information of the screen, accessible through
			  /// [sizingInfo.height] and [sizingInfo.width]

              return  Widget();
			  },
			);
		```
    - **StatelesslVMStoreBuilder\<T>.standAlone( )** : This constructor is used if you are not using the Provider package

		``` dart
			StatelessVMStoreBuilder<Store>.standAlone(
			  key: ///Optionally provide a key ,
			  viewModelStoreBuilder: () => MyViewModelStore(),
			  builder: (BuildContext context, T store, SizingInfo sizingInfo) {
			  /// Provides the store, the BuildContext and an object containing
			  /// the sizing information of the screen, accessible through
			  /// [sizingInfo.height] and [sizingInfo.width]

			  return  Widget();
			  },
			);
		```
        Note:
        If you are using this constructor, then Observer Widgets from the [Flutter Mobx](https://pub.dev/packages/flutter_mobx) package or equivalent reactions should be used, and setState or other ways of re-triggering the build function of the widget must not be used, as the Store is instantiated inside the build method, and re-triggering it causes a new store to be created.

        This of course does not occur with the .usesProvder variation of the widget, as then the instance of the store is gotten from Provider.

        Furthermore, if you instantiate the store with values that are stored/kept track of elsewhere in your code, or if you are fine with the store’s instance members returning to their default values when the build function is called again, then re-triggering the build function is perfectly fine.

  - **StatefulVMBuilder\<T>( )** : This widget is used for when you need to access widget lifecycle methods, and are binding a ViewModel that is ***not***  a MobX Store to the UI.
	``` dart
		StatefulVMBuilder<Object>(
		  key: ///Optionally provide a key ,
		  viewModelStoreBuilder: () => MyViewModel(),
		  builder: (BuildContext context, T viewModel, SizingInfo sizingInfo) {
		  /// Provides the ViewModel, the BuildContext and an object containing
		  /// the sizing information of the screen, accessible through
		  /// [sizingInfo.height] and [sizingInfo.width]

		  return  Widget();
		  },
		  initState: (store) {
	      ///Provide a optional ininState method
		  },
		  dispose: (store) {
		  ///Provide a optional dispose method
		  },
		);
	```
- **StatelessVMBuilder\<T>( )** : This widget is used for when you ***don't*** need to access widget lifecycle methods, and are binding a ViewModel that is ***not***  a MobX Store to the UI.

	``` dart
		StatelessVMBuilder<Object>(
		  key: ///Optionally provide a key ,
		  viewModelStoreBuilder: () => MyViewModel(),
		  builder: (BuildContext context, T viewModel, SizingInfo sizingInfo) {
		  /// Provides the ViewModel, the BuildContext and an object containing
		  /// the sizing information of the screen, accessible through
		  /// [sizingInfo.height] and [sizingInfo.width]

		  return  Widget();
		  },
		);
	```
	---
The package has been designed with ***modularity*** as one of its core principles. Except for MVVM, MobX itself, and Provider, which nearly 100% of people use alongside MobX, the package enforces ***no*** additional packages or principles, from Dialog services to data persistence, all the way to how you should structure your app, it's all left to the developer to implement in any way they please.

This stems from a core belief that every project is different, and has a different set of requirements and a rigorous structure and certain way to do things may only ever result in benefiting a small percentage of those projects, if that, and will likely result in many scenarios where people might have to "fight the framework", so to speak.
As such, going forward, this is probably the only thing about this framework that will be set in stone.

The framework will always therefore be **lightweight**, **unobstructive**, **unobtrusive**, and, most importantly, **modular**,  and will prioritize the above criteria above all else, allowing developers to switch out (or add on top off) functionality provided by the framework (or add new functionality all together) in the form of either separate, purpose-built packages or custom solutions, as easily as is possible.

---
## License
This package is licensed under the Apache License, Version 2.0
```
Copyright 2021 Tanzil Zubair Bin Zaman

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
````


text:
# Media Server using Docker, NGINX and Let's Encrypt

With this repo you will be able to set up your media server using a single NGINX proxy to manage your connections, automating your apps container (port 80 and 443) to auto renew your ssl certificates with Let´s Encrypt.

Something like:

![Web Proxy environment](https://github.com/evertramos/images/raw/master/webproxy.jpg)

## Why use it?

Using this set up you will be able start a new media server environment in a few seconds.

Easy and trustworthy!

## Prerequisites

In order to use this compose file (docker-compose.yml) you must have:

1. docker (https://docs.docker.com/engine/installation/)
2. docker-compose (https://docs.docker.com/compose/install/)

## What's included

- Portainer: a lightweight management UI which allows you to easily manage your different Docker environments.

- Transmission: a bittorrent client.

- Sonarr: a PVR for usenet and bittorrent users. It can monitor multiple RSS feeds for new episodes of your favorite shows and will grab, sort and rename them.

- Couchpotato: an automatic NZB and torrent downloader. You can keep a "movies I want" list and it will search for NZBs/torrents of these movies every X hours.

- Htpc-manager: a front end for many htpc related applications.

## How to use it

1. Clone this repository:

```bash
git clone https://github.com/nakioman/docker-media-server.git
```

2. Make a copy of our `.env.sample` and rename it to `.env`:

Update this file with your preferences.

3. Run our start script

```bash
# ./run.sh
```

Your media server is ready to go!

## Credits

Without the repositories below this webproxy wouldn´t be possible.

Credits goes to:
- nginx-proxy [@jwilder](https://github.com/jwilder/nginx-proxy)
- docker-gen [@jwilder](https://github.com/jwilder/docker-gen)
- docker-letsencrypt-nginx-proxy-companion [@JrCs](https://github.com/JrCs/docker-letsencrypt-nginx-proxy-companion)
- linuxserver/couchpotato [@linuxserver](https://github.com/linuxserver/docker-couchpotato)
- linuxserver/sonarr [@linuxserver](https://github.com/linuxserver/docker-sonarr)
- linuxserver/transmission [@linuxserver](https://github.com/linuxserver/docker-transmission)
- linuxserver/htpcmanager [@linuxserver](https://github.com/linuxserver/docker-htpcmanager)
- portainer [@portainer](https://github.com/portainer/portainer)
- docker-compose-letsencrypt-nginx-proxy-companion [@evertramos](https://github.com/evertramos/docker-compose-letsencrypt-nginx-proxy-companion)

repository: nakioman/docker-media-server

repo_name: nakioman/docker-media-server


text:
# TI-JS Sample - node-ts

## Table of contents

- [Introduction](#introduction)
- [Setup](#setup)
- [Usage](#usage)
- [License](#license)

## Introduction

This project demonstrates how to use the `ti-js` library in a node server, in typescript.

## Setup

Run:
```sh
npm install
```

## Usage

To start the server, run:
```sh
npm start
```

Then navigate to `http://<IP_ADDRESS>:3000/` in your favorite web browser.

You can also just build with:
```sh
npm run build
```

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: davidtorosyan/ti-js

gha_language: JavaScript

repo_name: davidtorosyan/ti-js


text:
# Supply Chain Fabric

This project contains the hyperledger fabric-network files and smart contracts (chaincodes) for the Supply Chain application. This also includes the Kubernetes and Jenkins details/files which are use for the deployment of the fabric.

## But first, what is the Supply Chain Application?

Here is a high-level description of the Supply Chain application:

*This application applies to any business area in which participants are going to move products amongst each other. It allows for the packaging of several products into one trackable object and then the transferring of ownership/custodianship of said goods.*

*There are currently 5 Roles/Participants expected by the application, however it can be quickly customized for any supply chain:*
```
(1) Manufacturer: can create products and issue recall notices on products and package products in containers.
(2) Carrier: accepts ownership of goods upon receiving the physical item as well as package products in containers.
(3) Warehouse: accepts ownership of goods upon receiving the physical item as well as package products in containers.
(4) Store: accepts ownership of goods upon receiving the physical item as well as package products in containers.
(5) Consumer: have a visual on a product once they receive it at the end of the supply chain.
```

### High-Level details regarding the folders this project contains

```
(1) /chaincode - this folder contains all files related to the application's smart contracts. See below "Current Chaincodes this project contains" for further high-level details regarding each of the files inside this folder.
(2) /rest-server - This holds the Rest Server for Fabric Supply Chain App.
```

## Installing the development environment
### Requirements

- Go 1.11.x
- [Dep](https://golang.github.io/dep/docs/installation.html)

### Setup GOPATH

Go requries your sourcecode be within the \$GOPATH environment variable. This causes issues when you try to have your chaincode also with a shared repository. The following commands will symlink your chaincode directory into the GOPATH satifying both requirements.

```
export GOPATH=/opt/gopath
mkdir -p $GOPATH/src/github.com
ln -s $(pwd)/chaincode $GOPATH/src/github.com
```

## Developing Chaincode

### Installing dependencies

Run `dep ensure` to install from within \$GOPATH/src/github.com/chaincode to install the required dependencies.

### Current Chaincodes this project contains

On /chaincode folder you can see the list of files used by this application

#### /chaincode/common
This holds the structure/models used by the application, as well as some functions each uses.

```
(1) Container.go - models a container in a supply chain. This holds AccessibleBy, UnmarshalJSON and Remove functions.
(2) ContainerRequest.go - models a request body for container creation in a supply chain.
(3) History.go - models a historical custodian change in the supply chain.
(4) Identity.go - encapsulates a chaincode invokers identity. This holds GetInvokerIdentity, CanInvoke and isManufacturer functions.
(5) Product.go - models a product in a supply chain. This holds AccessibleBy and UnmarshalJSON functions.
(6) ProductRequest.go - models request body for new product in a supply chain.
(7) UpdateRequest.go - models a product update in a supply chain.
```

#### /chaincode/supplychain/cmd

This holds the "main.go" file. This starts up the chaincode in the container during instantiate.

#### /chaincode/supplychain

This holds all the chaincodes (smart contracts) used by the application including the *_test.go files that can be use for testing purposes.

```
(1) Common.go - contains common functionalities of the application such as:
1.1 updateState - takes health and misc data and allows a user to update the trackingID
1.2 scan - checks to see if state exists and whether it is owned by the current identity
1.3 getIdentity - obtains users current identity
1.4 getHistory - retrieves single items hsitory on the ledger
1.5 isInHistory - helper to check if in history

(2) Container.go - contains functionalities related to the container asset used by the application.
2.1 createContainer - creates a new Container on the blockchain using the request body with the supplied ID
2.2 getAllContainer - retrieves all Container on the ledger
2.3 getSingleContainer - retrieves single Container on the ledger by trackingID
2.4 updateCustodian - claims current user as the custodian
2.5 packageItem - takes product/container and updates its containerID and takes a container and adds to its contents list

(3) Product.go - contains functionalites related to the product asset used by the application.
3.1 createProduct - creates a new Product on the blockchain using the  with the supplied ID
3.2 getAllProducts - retrieves all products on the ledger
3.3 getSingleProducts - retrieves all products on the ledger
3.4 getContainerlessProducts - retrieves all products on the ledger where containerID is empty
3.5 updateCustodian - claims current user as the custodian

(4) supplychain.go - this is holds the Supply Chain Smart Contract's init and invoke functionalities.
4.1 SmartContract - structure of the Smart Contract; this will hold the Smart Contract containing this chaincode
4.2 Init - called during chaincode instantiation to initialize any data
4.3 Invoke - called per transaction on the chaincode.
```

Below are the existing *_test.go files for the above chaincodes.
```
(1) Common_test.go
(2) Container_test.go
(3) Product_test.go
```

#### /chaincode/testdata

This holds data used by /chaincode/supplychain/*_test.go chaincodes. This includes:

```
(1) carrier.pem - test certificate for the role/participant carrier. Used by Product_test.go chaincode.
(2) manufacturer.pem - test certificate for the role/participant manufacturer. Used by Common_test.go,  Container_test.go and Product_test.go chaincodes.
(3) container-input-valid.json - used by Container_test.go chaincode.
(4) container-output.json - used by Container_test.go chaincode.
(5) product-input-valid.json - used by Product_test.go chaincode.
(6) product-output.json - used by Product_test.go chaincode.
(7) update-product-input.json - used by Product_test.go chaincode.
```

### Testing
#### Test using symlink

Run `go test` or `go test -v` from within \$GOPATH/src/github.com/chaincode to run the chaincode unit tests.

#### Test not using symlink

If you ONLY need to test your golang chaincodes (.go) using your golang test chaincodes (*_test.go), you don't need to run the fabric network locally for testing purposes, you can just do the following instead. (This is normally use for quick tests on bug fixes.)

```
(1) copy over to your $GOPATH/src/ the whole supplychain project's chaincode folder
NOTE: $GOPATH is normally $HOME/go

(2) in the $GOPATH/src/<project's chaincode folder> you can use `go get` to get dependencies then `go test -v` to test your chaincode.
NOTE: the test details will be cached so you could use `go clean` if you will be doing another round of test or another test with other chaincodes. This is to ensure that your are reading the correct test details when using `go test`.
```

### Update Chaincode deployed

To update chaincode running on a clusters, use the `platforms/hyperledger-fabric/configuration/chaincode-upgrade.yaml` playbook.
The input network.yaml should be updated with a new version of chaincode. Please do not use dot(.) in chaincode versions.

## Deploying REST-Server and API-Server

The Supplychain Restserver and ExpressAPI server is deployed using the `examples/supplychain-app/configuration/deploy-supplychain-app.yaml` playbook.
The input network.yaml should be updated correctly with the Chart path `examples/supplychain-app/charts`. Also, please do not use dot(.) in chaincode versions.

### Updating the Fabric REST-Server deployed

To update running Fabric rest-servers, ensure you are logged in to the Azure Docker Registry. Then:

```bash
docker build -t hyperledgerlabs/supplychain_fabric:rest_server_latest rest-server
docker push hyperledgerlabs/supplychain_fabric:rest_server_latest
```

Once the push is complete, Flux-helmoperator should redeploy the restserver pods

## Installing supplychain chaincode over BYFN

[BYFN](https://github.com/hyperledger/fabric-samples.git) (build your first network) is a sample network mentioned by Hyperledger Fabric.
You can deploy the supplychain chaincode over BYFN.
Here's the steps:
1. Clone the repository and install the binaries required

```
git clone https://github.com/hyperledger/fabric-samples.git
cd fabric-samples/
git checkout release-1.4
curl -sSL http://bit.ly/2ysbOFE | bash -s -- 1.4.4 1.4.4 0.4.18
```

2. Setup the byfn network with raft consensus and fabric version 1.4.4
```
cd first-network/
printf '%s\n' y | ./byfn.sh generate -o etcdraft -s couchdb
printf '%s\n' y | ./byfn.sh up -s couchdb -o etcdraft
```

3. Copy the chaincode from BAF repository and put it in the CLI container
```
export CLI_CONTAINER_ID="$(docker ps -a | grep cli | awk '{print $1}')"
git clone https://github.com/hyperledger-labs/blockchain-automation-framework.git
cd blockchain-automation-framework
git checkout develop
docker cp $PWD/examples/supplychain-app/fabric/chaincode_rest_server/chaincode/ $CLI_CONTAINER_ID:/opt/gopath/src/github.com/chaincode/
```

4. Move chaincode to correct path and install dependencies
```
docker exec -it $CLI_CONTAINER_ID bash
apt-get update
printf '%s\n' y | apt-get install vim
cd /opt/gopath/src/github.com/chaincode
mv chaincode/* .
mkdir -p $GOPATH/bin && curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
cd /opt/gopath/src/github.com/chaincode && dep ensure
```

5.  Instantiate chaincode
```
peer chaincode instantiate -o orderer.example.com:7050 -C mychannel  --tls true --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -n supplychain -v 1.0 -c '{"Args":['\"init\",\"\"']}' -P 'AND ('\''Org1MSP.peer'\'','\''Org2MSP.peer'\'')'
```

branch_name: refs/heads/main


text:
## PROJECT NAME Here

The description of your project should be here. It should give a brief overview of your project to a user or another developer. What is it, how did you make it (what languages), and any other details you would like to provide.

## Motivation
What Made you create this project. Where the idea came from or if it was part of a course, assignment, or general learning.

## Screenshot

Add any screenshots here

<!-- ## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

```bash
pip install foobar
```

## Usage

```python
import foobar

foobar.pluralize('word') # returns 'words'
foobar.pluralize('goose') # returns 'geese'
foobar.singularize('phenomena') # returns 'phenomenon'
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)

-->

repository: sydgarcia/Portfolio

repo_name: sydgarcia/Portfolio


text:
Markdown Collaboration Tool
===

![](http://i.imgur.com/4YiDb56.gif)

### About

I'd like this to be community build collaboration tool. Something like Google Docs but for markdown.

### Get started

1. `npm install && npm start`
2. Navigate to http://<IP_ADDRESS>:3000 in your browser.

### Ideas

- [ ] Sharable (publicly or privately)
- [ ] Post to Medium, etc.
- [x] Word count, read time
- [ ] Comments
- [ ] Suggested changes (similar to Google Docs)
- [ ] Non-distruction mode

Feel free to contribute!

repository: knowbody/markdown-collaboration

repo_name: knowbody/markdown-collaboration


text:
# go-logger Golang Logger
Logger on steroids.

## Get it
```bash
go get github.com/bestmethod/go-logger
```

## What's new
#### Async option
There is now support for async logging. To avoid slowdown of main code when logging to stdout, one can run the logger in Async mode - which in turn uses goroutines. This allows for the main code execution without delay. To use, set logger.Async to true AFTER running the logger.Init().
###### Warning: Use Async at your own peril. If your logging falls behind the main code, you risk exhausting handles, memory or goroutine space and crashing. This is no designed as a queuing mechanism for logging, but marely to allow for more real-time of main code execution.
```go
logger := new(Logger.Logger)
logger.Init(header, serviceName, stdoutLevels, stderrLevels, devlogLevels)
logger.Async = true
```

## Usage
#### Create object and Init
```go
logger := new(Logger.Logger)
err := logger.Init(header, serviceName, stdoutLevels, stderrLevels, devlogLevels)
```
#### Functions
```go
func (l *Logger) Init(header string,serviceName string,stdoutLevel int,stderrLevel int,devlogLevel int) error {}
func (l *Logger) Debug(format string, args ...interface{}) {}
func (l *Logger) Info(format string, args ...interface{}) {}
func (l *Logger) Warn(format string, args ...interface{}) {}
func (l *Logger) Error(format string, args ...interface{}) {}
func (l *Logger) Critical(format string, args ...interface{}) {}
func (l *Logger) Fatal(format string, args ...interface{}) {}
func (l *Logger) Fatalf(exitCode int,format string, args ...interface{}) {}
func (l *Logger) Destroy() error {}
func (l *Logger) TimeFormat(newFormat string) {}
```

#### Destroy objects before forgetting them
This will destroy the devlog handler and the connection to devlog that it holds in the background (open handle).

Note that this will not stop the logger from working if you use it afterwards. This just disables and closes the devlog type logger as a cleanup procedure. If you do not use devlog logger, don't worry about this at all.
```
err := logger.Destroy()
```

## Example
```go
import "github.com/bestmethod/logger"
import "fmt"
import "os"

logger := new(Logger.Logger)
err := logger.Init("SUBNAME", "SERVICENAME", Logger.LEVEL_DEBUG | Logger.LEVEL_INFO | Logger.LEVEL_WARN, Logger.LEVEL_ERROR | Logger.LEVEL_CRITICAL, Logger.LEVEL_NONE)
if err != nil {
  fmt.Fprintf(os.Stderr, "CRITICAL Could not initialize logger. Quitting. Details: %s\n", err)
  os.Exit(1)
}

// standard logger messages
logger.Info("This is info message")
logger.Debug("This is debug message")
logger.Error("This is error message")
logger.Warn("This is warning message")
logger.Critical("This is critical message")

// logger messages, like Printf (auto-discovery of printf happens, so same functions are used)
logger.Info("%s %v","This is info message",10)
logger.Debug("%s %v","This is debug message",10)
logger.Error("%s %v","This is error message",10)
logger.Warn("%s %v","This is warning message",10)
logger.Critical("%s %v","This is critical message",10)

// standard fatal exit with custom exit code
code := 1
logger.Fatal("This is a critical message that terminates the program with os.exit(code)", code)

// fatal with printf has a separate fatalf
code = 1
logger.Fatalf(code,"%s","This is a critical message that terminates the program with os.exit(code)")

```

repository: bestmethod/go-logger

repo_name: bestmethod/go-logger


text:
---
type: "finalist"
title: CodingDiva
name: "CodingDiva"
description: "Another ambitious individual here to perform as a team"
Team-Quote: "Fight till the end"
Application_Type: "Website"
---

I am Harshita Kanal, I have built this productivity application as my contribution in this hackathon, I am an enthusiastic developer.

---

# Smart Note Taker

_**Theme-Name**_ : Education

_**Application-Type**_ :  Website

---

# Description

>  Smart note taker: Online learning has posed a great challenge to students, they usually find themselves cluttered with gathering resources from various sources but find it difficult to organise themselves, the approach would be in this direction, to create a web application to assign each user a special profile where he can maintain all his notes, The notes could be appropriately tagged according to custom categories, he would also be provided access to a discussion forum where he can connect with peers and exchange academic projects.

---

_**Tech-Stack**_  :   React, Firebase

_**GitHub-Link**_ :   https://github.com/Harshita-Kanal/Smart-Note-Taker

_**DemoVideo-Link**_ :   https://drive.google.com/file/d/1SUFM_Fbo6a7kZjnu1x3Sh9A9_OSfexUD/view?usp=sharing

---

# Harshita Kanal

_**Role-In-Team**_  : Full Stack Developer

_**Working-Stack**_ : React, Firebase

_**University/School**_ : University of Mumbai


text:
# Building Office Addins using Angular2, TypeScript and Express

See [my blog](https://peteskelly.com) for a series fo posts regarding this code.

** Warning: **
This sample may be in a state that does not build or may have errors as I update.

See [PitchMe](https://gitpitch.com/pkskelly/OutlookCandidateMgr/master) for more details.  See [GitPitch](https://github.com/gitpitch/gitpitch/wiki/) for a great way to show off your ideas.

[![GitPitch](https://gitpitch.com/assets/badge.svg)](https://gitpitch.com/pkskelly/OutlookCandidateMgr/master?grs=github&t=white)

repository: pkskelly/OutlookCandidateMgr

repo_name: pkskelly/OutlookCandidateMgr


text:
---
title: Read More / Read Less
description: Read More / Read Less
extends: _layouts.documentation
section: content
---

# Read More / Read Less {#read-more}

Simple read more/read less component powered by Blade Components.

Here is an example:

![Read-more-read-less](/assets/img/components/readmore.png)

### Usage

```php
// in blade view

<x-readmore :content="$post->body" limit="200" />
```

### Component

```php
<div x-data="{ open: false }" x-ref="demo" x-cloak>
	<span x-show="!open">
		{!!
			\Illuminate\Support\Str::limit(
				strip_tags(trim($content ?? '')),
				(int) $limit ?? 100
			)
		!!}
	</span>

	<a href="#0" @click.prevent="open = true" x-show="! open">Show more</a>

	<div x-show="open">
		{!! $content ?? '' !!}
		<a
			href="#0"
			@click.prevent="
				open = false;
				$refs.demo.scrollIntoView({behaviour: 'smooth'})
			"
			x-show="open"
		>Show less</a>
	</div>
</div>
```

repository: mithicher/blade-components

repo_name: mithicher/blade-components


text:
# DROP Sample Multi-Curve Package

DROP Sample Multi-Curve illustrates the Multi-Curve Construction and Valuation.

## Class Components

 * [***CustomBasisCurveBuilder***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/multicurve/CustomBasisCurveBuilder.java)
 CustomBasisCurveBuilder contains the sample demonstrating the full functionality behind creating highly customized spline based Basis curves.

 * [***FixFloatForwardCurve***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/multicurve/FixFloatForwardCurve.java)
 FixFloatForwardCurve contains the sample demonstrating the full functionality behind creating highly customized spline based forward curves from fix-float swaps and the discount curves.

 * [***FixFloatSwap***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/multicurve/FixFloatSwap.java)
 FixFloatSwap contains a full valuation run on the Multi-Curve Fix-Float IRS Product.

 * [***FixFloatSwapAnalysis***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/multicurve/FixFloatSwapAnalysis.java)
 FixFloatSwapAnalysis contains an analysis if the correlation and volatility impact on the fix-float Swap.

 * [***FixFloatSwapIMM***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/multicurve/FixFloatSwapIMM.java)
 FixFloatSwapIMM contains a full valuation run on the IMM Fix-Float Swap Product.

 * [***FloatFloatForwardCurve***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/multicurve/FloatFloatForwardCurve.java)
 FloatFloatForwardCurve contains the sample demonstrating the full functionality behind creating highly customized spline based forward curves.
 	* The first sample illustrates the creation and usage of the xM-6M Tenor Basis Swap:
 		* Construct the 6M-xM float-float basis swap.
  		* Calculate the corresponding starting forward rate off of the discount curve.
  		* Construct the shape preserving forward curve off of Cubic Polynomial Basis Spline.
  		* Construct the shape preserving forward curve off of Quartic Polynomial Basis Spline.
  		* Construct the shape preserving forward curve off of Hyperbolic Tension Based Basis Spline.
  		* Set the discount curve based component market parameters.
  		* Set the discount curve + cubic polynomial forward curve based component market parameters.
  		* Set the discount curve + quartic polynomial forward curve based component market parameters.
  		* Set the discount curve + hyperbolic tension forward curve based component market parameters.
  		* Compute the following forward curve metrics for each of cubic polynomial forward, quartic polynomial forward, and KLK Hyperbolic tension forward curves:
  			* Reference Basis Par Spread
  			* Derived Basis Par Spread
 		* Compare these with a) the forward rate off of the discount curve, b) The LIBOR rate, and c) The Input Basis Swap Quote.
 	* The second sample illustrates how to build and test the forward curves across various tenor basis. It shows the following steps:
 		* Construct the Discount Curve using its instruments and quotes.
 		* Build and run the sampling for the 1M-6M Tenor Basis Swap from its instruments and quotes.
 		* Build and run the sampling for the 3M-6M Tenor Basis Swap from its instruments and quotes.
 		* Build and run the sampling for the 6M-6M Tenor Basis Swap from its instruments and quotes.
 		* Build and run the sampling for the 12M-6M Tenor Basis Swap from its instruments and quotes.

 * [***FundingNativeForwardReconciler***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/multicurve/FundingNativeForwardReconciler.java)
 FundingNativeForwardReconciler demonstrates the Construction of the Forward Curve Native to the Discount Curve across different Tenors, and display their Reconciliation.

 * [***OTCSwapOptionSettlements***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/multicurve/OTCSwapOptionSettlements.java)
 OTCSwapOptionSettlements contains all the pre-fixed Definitions of the OTC Swap Option Settlements.

## DROP Specifications

 * Main                     => https://lakshmidrip.github.io/DROP/
 * Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
 * GitHub                   => https://github.com/lakshmiDRIP/DROP
 * Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
 * Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
 * Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
 * Release Versions         => https://lakshmidrip.github.io/DROP/version.html
 * Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
 * Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
 * JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
 * Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html

repository: fairhopeweb/DROP

repo_name: fairhopeweb/DROP


text:
---
layout: default
---

# 1993-07-16 - No Subject

## Header Data

From: Thomas Grant Edwards<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: ff79db145a1ac0b5e58eaefe208957ff2d68fe312e20ab5f0935f277b2be7877

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-07-16 19:44:02 UTC

Raw Date: Fri, 16 Jul 93 12:44:02 PDT

## Raw message

```
{% raw  %}From: Thomas Grant Edwards<EMAIL_ADDRESS>Date: Fri, 16 Jul 93 12:44:02 PDT
To<EMAIL_ADDRESS>Subject: No Subject
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

-----BEGIN PGP SIGNED MESSAGE-----

Does anyone know of C source code for low speed CELP or vocoder
software available on the net?

I feel if we can develop even a low-speed software based answer to
the secure-phone, it will probably be used and distributed to many
people.  I think it would have to be based around the soundblaster
card though.

Perhaps we can also devise an internet secure-phone standard, and
clients can be written for NeXTs, Suns, PCs, and etc.

I've had no luck getting our SparcStations to decompress ADPCM encoded
Internet Talk Radio in real time...either the software I have is truly
sad (could be), or we need to look at other compression methods
such as CELP, or at worst, vocoder.

- -Thomas

-----BEGIN PGP SIGNATURE-----
Version: 2.2

iQBVAgUBLEcE4DAI9D7h8UTJAQHGSgIAgleqJLQnpwQck4b8FQi79uL6RPGv1j01
LlLX+ICFA/yFfVheh43tWt9vsHrG0d+Vgbo3SX4FHUniDBlqAHYnfw==
=QYED
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Ed Carp)](/authors/khijolerc_at_apple_com_ed_carp_)"
+ Return to "[Thomas Grant Edwards <tedwards@src.umd.edu>](/authors/thomas_grant_edwards_tedwards_at_src_umd_edu_)"

+ 1993-07-16 (Fri, 16 Jul 93 12:44:02 PDT) - No Subject - _Thomas Grant Edwards<EMAIL_ADDRESS>  + 1993-07-16 (Fri, 16 Jul 93 14:53:58 PDT) - [Re: your mail](/archive/1993/07/ac9143f3205e947b88b051daf7d6dd823535304f4d6d1121b8959b31f68cdcc2) -<EMAIL_ADDRESS>(Ed Carp)_


text:
---
name: 'Bug report'
about: 'Oops, all berries? Let us know.'
title: ''
labels: 'bug'
assignees: ''
---

<!-- Please title this ticket with a brief summary of the issue, then answer the questions below. -->

## Detailed description

> Is this issue related to a specific component?

> What did you expect to happen? What happened instead?

> What browser & version are you experiencing this in?

## Steps to reproduce the issue

1. Step one.
2. Step two.
3. Step three.
4. Bug!

## Screenshots

Please include screenshots to help illuminate the issue.

## Additional information

repository: arnoldsandoval-okta/odyssey

gha_license_id: NOASSERTION

repo_name: arnoldsandoval-okta/odyssey


text:
# Audience Profile

## Name
Organization: _Polk County Parks_

Individuals: _Ms. Candice Knothe, Mr. Britt Sutherland_

Candice Knothe
* Currently works for the Environmental Lands Program for Polk County, FL.
* Previously worked as a biologist with the Florida Forest Service at Lake Wales Ridge State Forest where she monitored and managed the threatened and endangered plant species in the forest. She also worked in the plant ecology lab at the Robert W. Jones Research Center at Ichauway and at the ecology lab at Rice University.
* She is working on a M.S. in Biology at Georgia Southern University and graduated from the University of Central Florida in 2008.
* Candice is a member of the Heartland CISMA, a network of land managers in central Florida, and serves as an organizer for a number of their events.

## Organizational
Sector: _Government Organization | Park_

Mission:
  The Polk County Parks department's mission is to acquire, preserve, protect, manage, and restore endangered and environmentally sensitive lands, water resources and important wildlife habitat. Acquired properties may be used for passive outdoor recreational purposes provided that such uses will not disturb or degrade the environmental quality for which the site was acquired.

Stakeholders:
  The Polk County Parks and Recreation department is a government organization of the Polk County Board of County Commissioners that serves the citizens of Polk County with nearly 40 park sites and 11 mini-parks that include athletic facilities, picnic areas, a historical-oriented park, and five campgrounds. Polk County Parks works closely with non-profits, local, state and federal level agencies.

The Citizens of Polk County: The community of Polk County is very concerned about the loss of native habitat in the area including the water, wildlife, and wilderness resources. In 1990, they kickstarted a grassroots effort to promote the funding of environmental lands acquisition and management program for their protection. The sense of responsibility toward their environment in their community is evident in that they elected to levy a tax on themselves to fund a local environmental lands program.

Polk County Board of County Commissioners (BoCC): In response to the citizen's initiative to raise funds for the conservation of natural habitat in the area, the Polk County BoCC has a funded environmental land acquisition and management program.

Culture: The Polk County Parks department has an active organizational culture despite being a governmental organization. The community is very invested in the parks' programs and the County organizes community outreach events through the year to engage its citizens and to raise funds. The citizens actively participate in the County programs to come together and recently collaborated to weed out invasive species from areas that needed such atttention.

## Both individual & organizational
* Data capabilities

  Water quality data is available from November 2017 to April 2018. It provides data on various parameters such as temperature(deg C), conductivity(umhos/cm), dissolved oxygen(%), pH(Std Unit), chlorophyll(ug/l), sulfate(mg/l), total dissoloved and suspended solids(mg/l), iron(ug/l), nitrogen ammonia(mg/l), Kjeldahl nitrogen(mg/l), nitrogen nitrate + nitrite(mg/l), total nitrogen, Ortho phosphorus(mg/l), and total phosphorus(mg/l) which are useful in analyzing the water quality. Data is available from November 2017 to April 2018 which helps in detecting the increase or decrease in water quality over the period.

  The data provided on Sand Skinks uses codes to represent the tracks of Sand Skinks and can be used to analyze the presence of Sand Skinks over Crooked Lake West-Stuart, Crooked Lake West-Lewis, Crooked Lake Sandhill, Hickory Lake Scrub, and Crooked Lake Prairie regions.

* Requirements/needs

  * Quantify the benefits of the wet land found in the Banana Creek and Hancock water bodies.
  * Analyze the increase or decrease in water quality as it moves through the wet land system.
  * Analyze the long term Sand Skink data.

* Priorities

  The following questions are most important to be answered before providing any additional analysis:
  * Analysis on water quality over the specified period
  * Sand Skink presence or absence for each year
  * Is there a decline in number of Sand Skinks
  * Difference of Sand Skink presence between the sites
  * Relationship between Sand Skink presence/absence and prescribed fire

_**Contributorship Statement**: Aysha Ruhi Damda, Hemachandra Ghanta, and Jeremy Reep contributed to this Audience Profile review and writing of this document. We reached out to our contacts Ms. Candice Knothe and Mr. Britt Sutherland via email with some prelimnary questions regarding the organization and their data._

_**Proofreader Statement**: Proofread 10.10.2018 by Jeremy Reep._

repository: hcghanta/apple-mango-banana

gha_language: HTML

repo_name: hcghanta/apple-mango-banana


text:
# InheritableAccessors [![Build Status](https://travis-ci.org/blakechambers/inheritable-accessors.svg)](https://travis-ci.org/blakechambers/inheritable-accessors)

Easily and consistently inherit attributes and configurations.  This is particularly designed to work well with Rspec, which creates new inherited classes during each context.

## Usage

Inheritable accessors comes with 3 inheritable components that can be used:
an iheritable hash, set, and option accessor.

### InheritableHashAccessor

```ruby
class Parent
  include InheritableAccessors::InheritableHashAccessor

  inheritable_hash_accessor :options

  options[:a] = 1
end

class Child < Parent
  options[:b] = 2
end

item = Child.new

# deleted items do not affect parent items
item.delete(:a)
item.options[:c] = 3

Parent.options.to_hash
#=> {a: 1})
Child.options.to_hash
#=> {a: 1, b: 1})
item.options.to_hash
#=> {b: 2, c: 3})
```

### InheritableOptionAccessor

```ruby
class MyRequest
  include InheritableAccessors::InheritableHashAccessor
  include InheritableAccessors::InheritableOptionAccessor

  inheritable_hash_accessor   :request_opts
  inheritable_option_accessor :path, :action, :params, for: :request_opts

  # passing an argument to the accessor will "set" that value.
  action "GET"

  action # => "GET"

  # passing a block will use the value of the block, but *only* when it is
  # called.  Block values will be memoized after the first run.
  path { secret_path }

  protected

  def secret_path
    "/secret_path"
  end

end

request = MyRequest.new
request.path # => "/secret_path"
request.path "/other_path"
request.path # => "/other_path"

```

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'inheritable_accessors'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install inheritable_accessors

## Usage

see [specs](https://github.com/blakechambers/inheritable-accessors/blob/master/spec/inheritable_accessors_spec.rb).

## Contributing

1. Fork it ( https://github.com/blakechambers/inheritable-accessors/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request

repository: blakechambers/inheritable-accessors

repo_name: blakechambers/inheritable-accessors


text:
Title: Using Microsoft Build Central Package Versions for Xamarin
Drafted: 12/18/2019
Published: 01/09/2020
Tags:
    - MSBuild
    - Xamarin
---

## NuGet Version Shenanigans
Have you ever worked on a project where any given developer adds nuget packages references.  Have you ever audited package versions across a solution only to find your issue is version mismatches?  Have you ever had two different projects depend on two different versions of the same dependency?!  Have you sourced a package only to receive an error because another package relies on a different version of the same dependency?  If you answered yes to any of the questions, you're in luck!  Today we are going to see how [Central Package Versions](https://github.com/microsoft/MSBuildSdks/tree/master/src/CentralPackageVersions) can help alleviate the issues of package dependency purgatory.  This concept isn't new, there is now an MSBuild Sdk that provides a central way to manage the concern.

## Build props and targets
Recently I started using `directory.build.props` and `directory.build.targets` to provide global functionality to projects of similar types in a folder.  This is something like adding roslyn analyzers to a projects in a code base, but explicitly not using it for unit test projects.  It can also be a way to provide simliar package metadata to a mutli-project, multi-package solution.  Instead of duplicating the metadata in each .csproj in the solution, you can provide the package details like `RepositoryUrl` or `License` to all .csproj files in the solution.

For a while this worked fine, but there was still no standard way to handle things like package version overrides, or enforcement of package versioning.  It didn't matter, it was better than how things were.  MSBuild Sdks provides an explicit Sdk for Centralizing Package Versions, and enforcing consistent package consumption for a repository.  When I first heard about it, I was excited!  As with most things, I become less excited when I find out that it doesn't work, or isn't supported for Xamarin.  This was no exception.  I perused the docs (scanned quickly) and was convinced it didn't work for Xamarin solutions.  I was wrong.

## Central Package Version
If you use git, then drop a `packages.props` file in the root directory of your repository.  This `packages.props` file is going to be the single source of truth.  That means you can no longer right click and add a nuget package to a single project, it has to be added here.  The packages props will maintain a global version reference.

I prefer to put a common props and target file at the root of the repository.  You don't have to, you can add the following to a directory target, or on each individual .csproj file.  Regardless of where you place it, the following xml will tell the MSBuild engine to use the Central Package Version Sdk.

```xml
<Project>
    <Sdk Name="Microsoft.Build.CentralPackageVersions" Version="2.0.52" />
</Project>
```

### Package References Types

In your `packages.props` you can now define a few specific reference types.

```xml
<GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" />
```

- [Global Package References](https://github.com/microsoft/MSBuildSdks/tree/master/src/CentralPackageVersions#global-package-references) - This reference type should be used on any dependency that is used repository wide.  It is as the name suggests a global inclusion for all projects.

```xml
<PackageReference Include="System.Reactive" Version="4.*" />
```
- Include Package References - This reference type includes the package reference in all projects.

```xml
<PackageReference Update="ReactiveUI" Version="11.*" />
```
- Update Package References - This reference type updates the package reference from the metadata.

## But Why?

At this point, it would have registered that I said, no right click and adding nugets.  Yes, I know some readers will find this too complicated.  The tedious nature of having to update XML is just too much for some to bother with.  Remember one of the benefits of this Sdk is to make maintaining a **solution** easier.  So there is a trade off.  You trade a simple GUI user experience, for not having to dig through every single project just to find a single project has the wrong dependency version.

### Benefits

- Forcing a consistent dependency version
- Providing an easier way to source packages used by multiple projects
- Less package version audits
- Fewer problems updating package references
- Global package avilability

### Drawbacks

- Developers on a team can no longer source individual files using the nuget explorer
    - That's right, you have to add XML directly to the packages.props and know what version you want!
- More confusing to someone where package dependency versions are kept
- You have to explicitly request and override of a version

I won't bore you with showing you how to setup the `packages.props` instead here is a link to a Xamarin.Forms project using it, Happy Package Management!

https://github.com/RLittlesII/demo/tree/master/msbuild/CentralPackageVersion

repository: RLittlesII/rodneylittlesii

gha_language: C#

repo_name: RLittlesII/rodneylittlesii


text:
# TODO

## 0.2.0 - Tasks
* [x] Add go module
* [x] Use GitHub Actions CI
* [ ] Submit to Awesome-Go
* [x] Add CI/CD badges
  * [ ] Build passing, Go Reference, Go Report
  * [ ] Awesome-Go
* [ ] Add copyright to source files
* [ ] Remove dead code
* [ ] Signal stream cancellation from error handler ErrorFunc
* [ ] Add Stream.OnOpen(func(ctx)) hook to trigger before stream starts
* [ ] Add Stream.Notify() to catch os/signal notif

## 0.2.5
* [ ] Automatically turn on batch when batch operators are invoked
* [ ] Add support for stream.Into(func(item <type>){}) which is equivalent to stream.Into(collectors.Func(func))
* [ ] Change collectors signature to return StreamError instead of error

## 0.3 - Tasks
* [ ] Stream emitter - source from another stream
* [ ] Stream collector - sink into another stream
* [ ] New stream operators (join, split, broadcast, etc)
* [ ] Parallelization operator
* [ ] Add type-specific operators to streams (i.e. `SortInt()`)

## 0.1 Alpha - Tasks
* [x] Refactor log - implement logging with handler func
* [x] Error propagation and handling strategies
* [x] Support ability to pass context to user-defined operation functions
* [x] Dependency mgmt
* [x] Fix tests with `-race` failure
* [x] net/htt examples
* [x] Examples with error handling
* [x] Examples with logging
* [x] Context cancellation check for all operators
* [x] Examples with gRPC streaming
* [x] Add logo to README.md
* [x] Rebase commit history

repository: Jae-KimSeo/automi

repo_name: Jae-KimSeo/automi


text:
---
title: Healthy Cheese Scalloped Potatoes
categories: [sides]
servings: 14
prep_time: 15
cook_time: 45
reference: https://www.joyfulhealthyeats.com/healthy-cheesy-scalloped-potatoes-recipe/
ingredients:
- slug: yukon gold potatoes
  amount: 3 lbs
  notes: peeled and thinly sliced to 1/8" pieces
- slug: milk
  amount: 1 C
  notes:
- slug: butter
  amount: 1 tbsp
  notes:
- slug: garlic
  amount: 1 clove
  notes: minced
- slug: fresh thyme
  amount: 1 tbsp
  notes:
- slug: white cheddar cheese
  amount: 1 C
  notes: shredded
- slug: parmesan cheese
  amount: 1/2 C
  notes: grated
- slug: nutmeg
  amount: pinch of
  notes:
- slug: salt and pepper
  amount:
  notes: to taste

---

1. Preheat oven to 400 degrees F. Spray a 13×9″ baking dish with cooking spray. (I used the butter PAM). Add thinly sliced potatoes to a large bowl with water. This will keep the potatoes from browning.
2. To a small sauce pan add milk, garlic cloves, nutmeg and fresh thyme. Bring to a boil then add butter.  Set aside.
3. Arrange half of the potatoes to the prepared baking dish. Season with salt and pepper. Cover with half the shredded white cheddar cheese and half the parmesan cheese. Arrange the remaining potatoes. Season with salt and pepper. Pour the milk mixture of the potatoes, making sure to evenly coat. Finish with remaining white cheddar cheese and parmesan cheese.
4. Bake, uncovered, for 40 minutes or until potatoes are tender the top is slightly browned. Serve!

repository: yelper/alpertopia

gha_language: SCSS

repo_name: yelper/alpertopia


text:
Fix #
Toward #

## Change List
 -

## Checklist
 - [ ] Ensure the PR works with all demos on the online editor
 - [ ] Unit tests added or updated
 - [ ] Examples added or updated
 - [ ] [Documentation](https://github.com/gosling-lang/gosling-website) updated (e.g., added API functions)
 - [ ] Screenshots for visual changes (e.g., new encoding support or UI change on Editor)


text:
# KSP Craft Stats

KSP Craft Stats displays useful statistics and data about your vehicles, and allows basic ascent simulations, so you can get a rough idea of how your rocket
will perform in seconds, rather than minutes.

KSP Craft Stats is a collection of command-line tools. There is currently no GUI, though anyone is welcome to write one.  KSP Craft Stats also endeavours to be
a library jar that can be used by other tools to abstract away the complexities of loading KSP data files, calculating statistics, and merging crafts.

Many thanks go to these other projects, for paving the way in figuring out the internals of KSP:

* [Payloader](http://forum.kerbalspaceprogram.com/showthread.php/29950-0-18-Payloader-1-2-A-quick-easy-payload-launcher-utility!-WIN-LIN-MAC)
* [KSP scripts](https://github.com/numerobis/KSP-scripts)

Thanks also to @ojacobson/derspiny for his invaluable help with all the math and equations.

## Tools

There are a number of different command-line tools included in Craft Stats.

* PartHierarchy - Shows the part tree so you can see how things are connected
* StageParts - Shows what parts will still be on the ship in each stage, as well as what parts get dropped.
* VehicleStats - Shows mass, thrust, acceleration, and much more for the ship, as well as each stage.
* AscentSim - INCOMPLETE: Attempts to simulate an ascent from the surface of any body in KSP.
* MergeCraft - Merges any number of vehicles together to easily build multi-stage rockets.
* ChangeCommandPod - Changes which pod in a vehicle is the primary command pod.

All tools need to be told where to find the KSP data files.  This can be done in one of two ways:
* Set a KSP_HOME environment variable that points to your KSP directory.
* Pass the -k parameter to the tools.  eg. -k c:\KSP_win

### PartHierarchy

Shows the part tree so you can see how things are connected.

Required params:
-c or --craft  The path to the .craft file to load.

Optional params:
-v or --verbose More verbose output.

Example:
parthierarchy -c testrocket.craft -v

### StageParts

Shows what parts will still be on the ship in each stage, as well as what parts get dropped.

Required params:
-c or --craft  The path to the .craft file to load.

Optional params:
-a or --all     List all parts, not just major ones.
-v or --verbose More verbose output.

Example:
stageparts -c testrocket.craft -v -a

### VehicleStats

Shows mass, thrust, acceleration, and much more for the ship, as well as each stage.

Required params:
-c or --craft  The path to the .craft file to load.

Optional params:
-s or --stages  Show information about individual stages.
-v or --verbose More verbose output.

Example:
vehiclestats -c testrocket.craft -v -s

### AscentSim

INCOMPLETE: Attempts to simulate an ascent from the surface of any body in KSP.

### MergeCraft

Merges any number of vehicles together to easily build multi-stage rockets.

Required params:
-c or --craft       Path to a vehicle .craft file to merge. Must be specified multiple times. First craft will be on top of the resulting rocket.
-d or --destination Path to the write the merged vehicle .craft to. Required.

Optional params:
-v or --verbose More verbose output.

Example:
mergecraft -c bottomstage.craft -c middlestage.craft -c topstage.craft -c payload.craft -d merged.craft

### ChangeCommandPod

Changes which pod in a vehicle is the primary command pod.

Required params:
-c or --craft  The path to the .craft file to load.
-i or --id     ID of command pod to set as primary. Required.

Optional params:
-v or --verbose More verbose output.

Example:
changecommandpod -c testrocket.craft -i Mark1-2Pod_4292406272


text:
This was (manually) forked from
[puppeteer-heroku-buildpack](https://github.com/jontewks/puppeteer-heroku-buildpack).
This fork adds support for more fonts.

Note that [this other fork](https://github.com/CoffeeAndCode/puppeteer-heroku-buildpack)
only adds support for a few fonts, and we need more.

# heroku-buildpack-puppeteer

Installs dependencies needed in order to run puppeteer on heroku. Be sure to include `{ args:
['--no-sandbox', '--disable-setuid-sandbox'] }` in your call to `puppeteer.launch`