text:
# Installation
react-md is available as an [npm package](https://www.npmjs.com/package/react-md).

You can install with:

```bash
$ npm install -S react react-dom react-md
```

Once installed, the components can be accessed by `react-md` or `react-md/lib` and the styles from `react-md/src/scss/_react-md.scss`.

### Fonts
The [Roboto font](https://www.google.com/fonts/specimen/Roboto) and
[material-icons](https://design.google.com/icons/) should be included as well
(or some equivalent). These fonts can be included via [WebFontLoader](https://github.com/typekit/webfontloader)
or by locally hosting and using the provided Sass mixins to include them. See [host-material-icons](/customization/typography?tab=1#mixin-host-material-icons)
and [host-google-font](/customization/typography?tab=1#mixin-host-google-font) for more details.

### Examples
Please see the [examples folder](https://github.com/mlaursen/react-md/tree/master/examples) for example project setups using
[create-react-app](https://github.com/facebook/create-react-app), [next.js](https://github.com/zeit/next.js/), webpack,
and others.

### UMD
react-md is also available as a UMD bundle. This can either be found in the `dist` folder or from [unpkg](https://unpkg.com).

```js
/* index.js */
const { Card, CardTitle, CardText, CardActions, Button } = window.ReactMD;

class App extends React.Component {
  render() {
    return (
      <div className="md-grid">
        <Card className="md-cell">
          <CardTitle title="Hello, World!" />
          <CardText>
            Lorem ipsum... pretend more ...
          </CardText>
          <CardActions>
            <Button flat label="Action 1" />
            <Button flat label="Action 2" />
          </CardActions>
        </Card>
      </div>
    );
  }
}

ReactDOM.render(document.getElementById('app'), <App />);
```

```html
<!-- index.html -->
<!DOCTYPE html>
<html>
  <head><link rel="stylesheet" href="https://unpkg.com/react-md/dist/react-md.indigo-pink.min.css"></head>
  <body>
    <script src="https://unpkg.com/react/dist/react.min.js"></script>
    <script src="https://unpkg.com/react-dom/dist/react-dom.min.js"></script>
    <script src="https://unpkg.com/react-addons-css-transition-group/dist/react-addons-css-transition-group.min.js"></script>
    <script src="https://unpkg.com/react-addons-transition-group/dist/react-addons-transition-group.min.js"></script>
    <script src="https://unpkg.com/react-md/dist/react-md.min.js"></script>
    <script src="/bundle.js"></script>
  </body>
</html>
```

repository: PrasannaMalitha/react-md

repo_name: PrasannaMalitha/react-md


text:
---
title: NodeJS
weight: 7
---

You can send information from NodeJS code (JavaScript or TypeScript) to Ray via this third party package:

[permafrost-dev/node-ray](https://github.com/permafrost-dev/node-ray)

license: MIT

repository: electricpulp/ray

branch_name: refs/heads/master

extension: md

gha_language: PHP

gha_license_id: MIT

license_type: permissive

repo_name: electricpulp/ray


text:
# Reaction Bot

Facebook Messenger and iMessage have features that allow you to react to
messages with emojis - it's an inline, low-key way to acknowledge a message when
you don't have anything else to say. However, this feature is still missing from
Telegram, so this bot serves as a sort of polyfill.

## How to use it (for Telegram users)

- Add [@reaxnbot](https://t.me/reaxnbot) to a group chat
- Reply to any message with the `/r` command directed at `@reaxnbot` (you can
  just type `/r` and it should just work)
- `@reaxnbot` responds with an empty message with emoji buttons, and anyone can
  tap them to react

![example showing reaxnbot in action](doc/example-1.png)

- If you don't want your chat littered with `/r`s, then give the bot permissions
  to delete messages and it will automatically delete the `/r` messages.
- If you want to see who did which reaction, reply to a reaction message with
  the `/s` command.

## How to use it (for developers)

- Obtain a bot token from the [BotFather](https://t.me/botfather)
- `TELOXIDE_TOKEN=<your token here> cargo run`

## EAQ (Easily anticipated questions)

> Why are you storing the reactions using that weird Markdown hack instead of
> just using a database like a normal person?

I do not want to maintain a database. This bot needs to be something that will
cost me nothing to operate, whether that's time or money, and databases always
cost money eventually.

Also, this puts the reaction data in the hands of Telegram, whom you probably
already trust, instead of the hands of me.

> Why does this bot have the ability to read all messages in my group chat?

Due to the [way the Telegram Bot API works](https://core.telegram.org/bots/faq#what-messages-will-my-bot-get),
replying to a message with a bot command doesn't let the bot see which message
you're replying to. This bot would be a lot less useful if it wasn't clear which
message the reaction was for, so this is a no-go.

The bot completely ignores messages that are not commands directed at it, and
does not read the contents of the messages you use it to react to.

> I don't want this bot to delete my `/r` messages. / I don't trust this bot not
> to delete anything else.

Then don't give the bot deletion permissions.

> Didn't this project used to be written in TypeScript?

Yes, but I found that frustrating because essentially any operation that one can
do with the Telegram Bot API can fail, and with so many potential places for
errors to creep up, I preferred Rust's error handling strategy to TypeScript's.

Additionally, the objects that the Telegram API returns are highly polymorphic,
and dealing with them in TypeScript did not feel explicit enough for my tastes.

Moreover, the program will (probably) use fewer resources as written in Rust,
which is a win for me if it suddenly finds a large audience.

And finally, I just wanted some more practice writing programs in Rust.

## License

This code is MIT licensed. Copyright © 2020 Ibiyemi Abiodun.

repository: laptou/reactions-telegram-bot

branch_name: refs/heads/rust

gha_language: Rust

repo_name: laptou/reactions-telegram-bot


text:
# Memote

[![Build Status](https://travis-ci.org/DD-DeCaF/memote-service-frontend.svg?branch=master)](https://travis-ci.org/DD-DeCaF/memote-service-frontend)

This is the frontend client for the memote.io web site, a free online service providing access to memote, the metabolic model test suite. See also the [backend service implementation](https://github.com/dd-decaf/memote-webservice).

For more information about memote, see [opencobra/memote](https://github.com/opencobra/memote).

## Technology stack

* Frontend framework: [Vue](https://vuejs.org/)
* State management: [Vuex](https://vuex.vuejs.org/)
* Linting provided by: [eslint-plugin-vue](https://github.com/vuejs/eslint-plugin-vue/)
  * Linter: [eslint](https://eslint.org/), see `package.json` for configuration
* Testing provided by: [@vue/cli-plugin-unit-mocha](https://github.com/vuejs/vue-cli/tree/dev/packages/%40vue/cli-plugin-unit-mocha)
  * Tests are run with [mocha](https://mochajs.org/) and [jsdom](https://github.com/jsdom/jsdom)
  * The assertion library is [chai](https://www.chaijs.com/), see also the [assertion style docs](https://www.chaijs.com/guide/styles/)
  * [vue-test-utils](https://vue-test-utils.vuejs.org/) provides useful utilities

## Development

### Install dependencies
```
npm install
```

### Run local development webserver with hot-reloading
```
npm run serve
```

### Run linter, fix errors
```
npm run lint
```

### Run linter, only report errors
```
npx vue-cli-service lint --no-fix
```

### Run unit tests once
```
npm run test:unit
```

### Run unit tests in watch mode
```
npx vue-cli-service test:unit -w
```

### Compile and minify for deployment
```
npm run build
```

repository: DD-DeCaF/memote-service-frontend

gha_language: Vue

repo_name: DD-DeCaF/memote-service-frontend


text:
---
published: true
layout: post
title: Bus ride to Riga
tags:
 - transport
date: '2016-07-24 15:00:00 +0300'
---
On the walk to the Tallinn Bus Station from my [Airbnb](https://www.airbnb.com/c/tting1?s=8&user_id=276940&ref_device_id=0d023e62f7dc763cd184a94c9ef809b981c0624b), I saw a sign that had a double meaning in Japanese. I wonder if the proprietors know about it. I also passed through Keskturg (Tallinn's Central Market) and admired their fresh fruits and chanterelles.

<!--more-->

![Moe moe]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/moe.jpeg)
![I'm not sure why these watermelons surprised me.]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/keskturg-watermelon.jpeg)
![Chanterelles, €6/kg]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/keskturg-chanterelles.jpeg)

The bus station itself looked nice and had an old Soviet era bus parked outside.

![You've arrived!]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/busstation-front.jpeg)
![Timeless bus]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/busstation-sovietbus.jpeg)

When you walk in and pass the stairs going down to your left, you see a self-service ticket-printing area with four kiosks. As long as you have your ticket number from when you purchased your ticket ahead of time, you can look it up that way and print it out for the bus driver.

!["Pilet" sounds close to "billete" in Spanish.]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/busstation-tickets.jpeg)
![Success!]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/busstation-printedticket.jpeg)

If you go down the steps that you initially passed to get to the ticket kiosks, you'll see that the WCs cost €0.30 to use, and the lockers are available for €1, €2, or €6 depending on size.

![Pay the machine]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/busstation-wcs.jpeg)
![Varying sizes]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/busstation-lockers.jpeg)

The bus driver didn't actually scan the QR code on my ticket: he just checked my passport and the key information printed on the ticket and found my name on a list, which also shows how much you paid for the ticket. I looked over his shoulder and saw that while I paid €3 for my ticket, people who waited till later paid up to €14!

On the bus, you had access to free wifi, an in-seat entertainment system that ran on Android OS, and a power socket per pair of seats. I didn't question the validity of the licensing of the films since they looked like they might not be originals.

![Android-based entertainment system]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/bus-entertainment.jpeg)

I didn't spend much time admiring the view outside the window, which seems like a bit of a shame, but I did catch this field of yellow flowers below a cloudy sky.

![Picturesque]({{site.baseurl}}/images/2016/07/24/bus-ride-to-riga/bus-view.jpeg)

I'm glad I took the 4.5-hour bus ride from Tallinn to Riga: what a smooth and pleasant experience for hardly any euros!

gha_language: CSS


text:
# Zoom Training Notes

## Zoom Webinar Training

[Training site link](https://livetraining.zoom.us/rec/play/7JJ4dbqvqDI3TtbH4gSDBvMrW9W8Jq6s1Cge_KUPyB3mU3QLO1WhbrATYOG_LKTZbc8ZgO3idNkmFR0y?continueMode=true)

- **>>setup profile photo<<**, this is shown when the video is off so it's important

### Zoom Webinar Schedule Page

<https://zoom.us/webinar/schedule>

- **description** will show up on the registration page
- **duration** is used for scheduling in calendars, it has no effect on the timing in the actual event
- **registration** does not have to be required. If required there is a seperate page that has details about registration page.
- **password** is case sensative and the link is built into the weblink
- **video** options are initial settings, will the camera be on when host or panelist arrive?
- **audio** should be left to both, just in case their audio on their computer doesn't work
- **webinar options** options only available prior to starting the webinar

  - Q&A
  - Practice Session (allows host to join early to test audio/video)
  - Authenticated users only (authenticates that email address is real)

### [Zoom Webinar Information Page](https://zoom.us/webinar)

<https://zoom.us/webinar/webinarid>

- **>>Only use invitation links at the bottom of the page to share event<<** The "Add to" button links at the top of the page are for the organizer and include a "/s/" to start the webinar
- **Customize Webinar Section**

  - **Invitationss**
  - **Email Settings**
  - **Branding**

    - setup graphics in advance

  - **Polls**

    - setup questions in advance

  - **Q&A**

    - anonymous (no)
    - upvote (yes)
    - comment (yes)

## Intro to Zoom

### start a meeting

- host a meeting

  - with video off
  - with video on
  - screenshare only

- new meeting

  - options control audio/video on when starting

- invite information shows up at the bottom of the screen when in meeting

branch_name: refs/heads/main


text:
# Motion Planning Networks
Implementation of [MPNet: Motion Planning Networks](https://sites.google.com/view/mpnet). [[arXiv]](https://arxiv.org/abs/1806.05767)

The code can easily be adapted for [Informed Neural Sampling](https://arxiv.org/abs/1809.10252).

## Contains
* Data Generation
	* Any existing classical motion planner can be used to generate datasets. However, we provide following implementations in C++:
		* [P-RRT*](https://link.springer.com/article/10.1007/s10514-015-9518-0)
		* [RRT*](https://arxiv.org/abs/1105.1186)
		* Example dataset: [simple2D](https://drive.google.com/open?id=1oADJ85qxb3WKHXE4Bj6lwio-soGOktRa)
* MPNet algorithm

## Requirements
* Data Generation

	1. Install [libbot2]( https://github.com/libbot2/libbot2)
		* Make sure all dependencies of libbot2 (e.g., lcm) are installed.
		* Install libbot2 with the local installation procedure.
		* Run "make" in the data_generation folder where the README file is located.

	2. Use any compiler such as Netbeans to load the precomplie code.
		* data_generation/src/rrts_main.cpp contains the main rrt/prrt code.
		* data_generation/viewer/src/viewer_main.cpp contains the visualization code.
			* Also checkout comments in data_generation/viewer/src/renderers/graph_renderer.cpp

		* Note: main_viewer and rrts_main should run in parallel as:
			* rrts_main sends the path solution as well as the tree to the main_viewer to publish through local network.
			* data is transmitted through LCM network protocol.

* MPNet
	* [PyTorch](http://pytorch.org/)

## Examples

1. Assuming paths to obstacles point-cloud are declared, train obstacle-encoder:
```python MPNET/AE/CAE.py```

2. Assuming paths to demonstration dataset and obstacle-encoder are declared, run mpnet_trainer:

    ```python MPNET/train.py```

3. Run tests by first loading the trained models:

    ```python MPNET/neuralplanner.py```

## References

```
@inproceedings{qureshi2019motion,
  title={Motion planning networks},
  author={Qureshi, Ahmed H and Simeonov, Anthony and Bency, Mayur J and Yip, Michael C},
  booktitle={2019 International Conference on Robotics and Automation (ICRA)},
  pages={2118--2124},
  year={2019},
  organization={IEEE}
}
@inproceedings{qureshi2018deeply,
  title={Deeply Informed Neural Sampling for Robot Motion Planning},
  author={Qureshi, Ahmed H and Yip, Michael C},
  booktitle={2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)},
  pages={6582--6588},
  year={2018},
  organization={IEEE}
}
@article{qureshi2019motion,
  title={Motion Planning Networks: Bridging the Gap Between Learning-based and Classical Motion Planners},
  author={Qureshi, Ahmed H and Miao, Yinglong and Simeonov, Anthony and Yip, Michael C},
  journal={arXiv preprint arXiv:1907.06013},
  year={2019}
}
```

repository: MariosVasileiou/MPNet

repo_name: MariosVasileiou/MPNet


text:
# Serialization

RestSharp has JSON and XML serializers built in without any additional packages
or configuration. There are also a few JSON serializers provided as additional packages.

:::tip
The default behavior of RestSharp is to swallow deserialization errors and return `null` in the `Data`
property of the response. Read more about it in the [Error Handling](exceptions.md).
:::

## Default Serializers

RestSharp core package includes a few default serializers for both JSON and XML formats.

### JSON

The default JSON serializer uses the forked version of `SimpleJson`. It is very simplistic and
doesn't handle advanced scenarios in many cases. We do not plan to fix or add new features
to the default JSON serializer, since it handles a lot of cases already and when you need
to handle more complex objects, please consider using alternative JSON serializers mentioned below.

There's a [known issue](https://github.com/restsharp/RestSharp/issues/1433) that SimpleJson doesn't use the UTC time zone when the regular .NET date format
is used (`yyyy-MM-ddTHH:mm:ssZ`). As suggested in the issue, it can be solved by setting the
date format explicitly for SimpleJson:

```csharp
client.UseSerializer(
    () => new JsonSerializer { DateFormat = "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ" }
);
```

### XML

You can use either the default XML serializer or the `DotNetXmlSerializer`, which uses `System.Xml.Serialization` library
from .NET. To use the `DotNetXmlSerializer` you need to configure the REST client instance:

```csharp
client.UseDotNetXmlSerializer();
```

## NewtonsoftJson (aka Json.Net)

The `NewtonsoftJson` package is the most popular JSON serializer for .NET.
It handles all possible scenarios and is very configurable. Such a flexibility
comes with the cost of performance. If you need something faster, please check
`Utf8Json` or `System.Text.Json` serializers (below).

RestSharp support Json.Net serializer via a separate package. You can install it
from NuGet:

```
dotnet add package RestSharp.Serializers.NewtonsoftJson
```

Use the extension method provided by the package to configure the client:

```csharp
client.UseNewtonsoftJson();
```

The serializer configures some options by default:

```csharp
JsonSerializerSettings DefaultSettings = new JsonSerializerSettings
{
    ContractResolver     = new CamelCasePropertyNamesContractResolver(),
    DefaultValueHandling = DefaultValueHandling.Include,
    TypeNameHandling     = TypeNameHandling.None,
    NullValueHandling    = NullValueHandling.Ignore,
    Formatting           = Formatting.None,
    ConstructorHandling  = ConstructorHandling.AllowNonPublicDefaultConstructor
};
```

If you need to use different settings, you can supply your instance of
`JsonSerializerSettings` as a parameter for the extension method.

## Utf8Json

The `Utf8Json` package is known to be the fastest JSON serializer for .NET.

RestSharp supports `Utf8Json` serializer via a separate package. You can install it
from NuGet:

```
dotnet add package RestSharp.Serializers.Utf8Json
```

Configure your REST client using the extension method:

```csharp
client.UseUtf8Json();
```

When the extension method is called without parameters, it will configure
the default options:

 - Allow private properties
 - Exclude null values
 - Use camel-case

If you need to use different options, you can provide the instance of
`IJsonFormatterResolver` as a parameter for the extension method.

:::warning
Keep in mind that this serializer is case-sensitive by default.
:::

## System.Text.Json

Microsoft included the new JSON serializer package `System.Text.Json` together with .NET Core 3.
It is a small and fast serializer that is used in the WebApi version for .NET Core 3
and beyond by default. The package is also available for .NET Standard 2.0 and .NET Framework 4.6.1 and higher.

RestSharp supports `System.Text.Json` serializer via a separate package. You can install it
from NuGet:

```
dotnet add package RestSharp.Serializers.SystemTextJson
```

Configure your REST client using the extension method:

```csharp
client.UseSystemTextJson();
```

The serializer will use default options, unless you provide your
own instance of `JsonSerializerOptions` to the extension method.

:::warning
Keep in mind that this serializer is case-sensitive by default.
:::

## Custom

You can also implement your custom serializer. To support both serialization and
deserialization, you must implement the `IRestSerializer` interface.

Here is an example of a custom serializer that uses `System.Text.Json`:

```csharp
public class SimpleJsonSerializer : IRestSerializer
{
    public string Serialize(object obj) => JsonSerializer.Serialize(obj);

    public string Serialize(Parameter bodyParameter) => Serialize(bodyParameter.Value);

    public T Deserialize<T>(IRestResponse response) => JsonSerializer.Deserialize<T>(response.Content);

    public string[] SupportedContentTypes { get; } =
    {
        "application/json", "text/json", "text/x-json", "text/javascript", "*+json"
    };

    public string ContentType { get; set; } = "application/json";

    public DataFormat DataFormat { get; } = DataFormat.Json;
}
```

The value of the `SupportedContentTypes` property will be used to match the
serializer with the response `Content-Type` headers.

The `ContentType` property will be used when making a request so the
server knows how to handle the payload.

repository: Terricide/RestSharp

gha_language: C#

repo_name: Terricide/RestSharp


text:
# Compiler changes

Here is the list of ongoing tasks to complete the effort of building the ESP32 Oberon Compiler.

- [x] Add INTEGER/BYTE/CHAR in CASE statements
- [x] User's assembly language
- [x] Add bit-wise AND/BOR/XOR/NOT for INTEGER/BYTE functions
- [x] Add MIN/MAX for INTEGER/BYTE/REAL Functions
- [x] Add SQRT function
- [x] Add WSR/RSR SYSTEM functions
- [ ] Revisit ORG.ChrToStr/ORG.StrToChr functions
- [x] Implement Const Char as a string parameter
- [x] Revisit Types descriptor
- [x] Implement Pointers management structure
- [x] Cleanup internal compiler debugging support
- [x] Revisit Logging module. No longer required.
- [x] ORG.{load,store} procedures optimization
- [x] Revisit Procedure calls (function parameters) optimization

# ESP-IDF Migration

- [x] Add CDECL Procedure calls support
- [x] Init table generator
- [x] Init code to be called from ESP-IDF
- [ ] Flash memory-based code execution -> ESP-IDF ld integration
- [x] Oberon Lib as an ESP-IDF component -> external compilation. Integration not possible.
- [x] CMake integration
- [ ] Standard modules adjustments
  + [ ] Kernel
  + [ ] In
  + [ ] Out
  + [ ] ...
- [ ] FreeRTOS behavior validation
- [ ] Interrupt procedure definition

# Compiler Support

- [x] Trap mechanism to use Break instructions/Interrupts. Abandonned. Uses call4 instruction.
- [x] Kernel Module (New, Garbage Collector, Timer)
- [ ] Complete Kernel module (WatchDog, Flash disk access)
- [x] Makefile cleanup
- [ ] Standard Modules
  + [ ] Out -> Needs a better standard RealFix procedure.
  + [x] Strings
  + [x] Math
  + [x] Strings
  + [x] In
  + [ ] File
  + [ ] Texts (ASCII only version)
- [x] Library folder
  + *and many more...*

# Potential future activities

- [ ] OTA capability
- [ ] PlatformIO integration
- [ ] Implement other Extended Oberon features
- [ ] Source code debug marking with GDB
- [ ] Optimize CASE statements when ranges are supplied as selectors
- [x] Add SHORTINT (16 bits) type
- [ ] Add LONGINT (64 bits) type
- [ ] Add DOUBLE type (and/or DoubleMath Module)
- [x] Add other transcendantal functions to Math.Mod
- [ ] In and Out modules to be compliant with Texts module


text:
---
layout: model
title: Sentence Entity Resolver for UMLS CUI Codes
author: John Snow Labs
name: sbiobertresolve_umls_findings
date: 2021-05-16
tags: [entity_resolution, clinical, licensed, en]
task: Entity Resolution
language: en
edition: Spark NLP for Healthcare 3.0.4
spark_version: 3.0
supported: true
article_header:
  type: cover
use_language_switcher: "Python-Scala-Java"
---

## Description

This model maps clinical entities and concepts to 4 major categories of UMLS CUI codes using `sbiobert_base_cased_mli` Sentence Bert Embeddings. It has faster load time, with a speedup of about 6X when compared to previous versions. Also the load process now is more memory friendly meaning that the maximum memory required during load time is smaller, reducing the chances of OOM exceptions, and thus relaxing hardware requirements.

## Predicted Entities

This model returns CUI (concept unique identifier) codes for 200K concepts from clinical findings.https://www.nlm.nih.gov/research/umls/index.html

{:.btn-box}
[Live Demo](http://nlp.johnsnowlabs.com/demo){:.button.button-orange}
[Open in Colab](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp-workshop/blob/master/tutorials/Certification_Trainings/Healthcare/3.Clinical_Entity_Resolvers.ipynb){:.button.button-orange.button-orange-trans.co.button-icon}
[Download](https://s3.amazonaws.com/auxdata.johnsnowlabs.com/clinical/models/sbiobertresolve_umls_findings_en_3.0.4_3.0_1621189546348.zip){:.button.button-orange.button-orange-trans.arr.button-icon}

## How to use

<div class="tabs-box" markdown="1">
{% include programmingLanguageSelectScalaPythonNLU.html %}
```python
...

chunk2doc = Chunk2Doc().setInputCols("ner_chunk").setOutputCol("ner_chunk_doc")

sbert_embedder = BertSentenceEmbeddings\
     .pretrained("sbiobert_base_cased_mli",'en','clinical/models')\
     .setInputCols(["ner_chunk_doc"])\
     .setOutputCol("sbert_embeddings")

resolver = SentenceEntityResolverModel\
     .pretrained("sbiobertresolve_umls_findings","en", "clinical/models") \
     .setInputCols(["ner_chunk", "sbert_embeddings"]) \
     .setOutputCol("resolution")\
     .setDistanceFunction("EUCLIDEAN")

pipeline = Pipeline(stages = [documentAssembler, sentenceDetector, tokenizer, stopwords, word_embeddings, clinical_ner, ner_converter, chunk2doc, sbert_embedder, resolver])

data = spark.createDataFrame([["""A 28-year-old female with a history of gestational diabetes mellitus diagnosed eight years prior to presentation and subsequent type two diabetes mellitus (T2DM), one prior episode of HTG-induced pancreatitis three years prior to presentation, associated with an acute hepatitis, and obesity with a body mass index (BMI) of 33.5 kg/m2, presented with a one-week history of polyuria, polydipsia, poor appetite, and vomiting."""]]).toDF("text")

results = pipeline.fit(data).transform(data)
```

</div>

## Results

```bash
|    | ner_chunk                             | cui_code   |
|---:|:--------------------------------------|:-----------|
|  0 | gestational diabetes mellitus         | C2183115   |
|  1 | subsequent type two diabetes mellitus | C3532488   |
|  2 | T2DM                                  | C3280267   |
|  3 | HTG-induced pancreatitis              | C4554179   |
|  4 | an acute hepatitis                    | C4750596   |
|  5 | obesity                               | C1963185   |
|  6 | a body mass index                     | C0578022   |
|  7 | polyuria                              | C3278312   |
|  8 | polydipsia                            | C3278316   |
|  9 | poor appetite                         | C0541799   |
| 10 | vomiting                              | C0042963   |
```

{:.model-param}
## Model Information

{:.table-model}
|---|---|
|Model Name:|sbiobertresolve_umls_findings|
|Compatibility:|Spark NLP for Healthcare 3.0.4+|
|License:|Licensed|
|Edition:|Official|
|Input Labels:|[sentence_embeddings]|
|Output Labels:|[umls_code]|
|Language:|en|
|Case sensitive:|false|

## Data Source

https://www.nlm.nih.gov/research/umls/index.html

repository: multivacplatform/spark-nlp

gha_language: Scala

repo_name: multivacplatform/spark-nlp


text:
[![Build Status](https://travis-ci.org/dcendents/android-maven-plugin.png)](https://travis-ci.org/dcendents/android-maven-plugin)
Gradle Android Maven plugin
====================

Modification to the standard Maven plugin to be compatible with android-library projects (aar).

Usage
====================

To use the android-maven-plugin, just apply the android-maven plugin in your android-library project.
Also add the plugin classpath dependency to the buildScript.

```Groovy
buildscript {
	repositories {
		mavenCentral()
	}

	dependencies {
		classpath 'com.github.dcendents:android-maven-plugin:1.2'
	}
}

apply plugin: 'com.android.library'
apply plugin: 'com.github.dcendents.android-maven'
```

You can set the maven groupId and version in the script build.gradle:
```Groovy
group = 'com.example'
version = '1.0'
```

The artifactId is set in settings.gradle:
```Groovy
rootProject.name = 'artifact'
```

Note on Releases
====================

The following table shows which version of the plugin should be used depending on the version of gradle you are currently using. Also it list the plugin name to use:

| Plugin Version | Plugin Name | Gradle Version |
| ------------- | ----------- | ----------- |
| 1.0 | android-maven | 1.8 |
| 1.1 | android-maven | 1.12 |
| 1.2 | com.github.dcendents.android-maven | 2.2 |

License
====================

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.

repository: mercury-mql/android-maven-plugin

repo_name: mercury-mql/android-maven-plugin


text:
casperjs Cookbook [![Build Status](https://secure.travis-ci.org/jenkinslaw/casperjs-cookbook.png?branch=master)](http://travis-ci.org/jenkinslaw/casperjs-cookbook)
=================
This Chef cookbook will install the precompiled casperjs binary.

Tested on centos 6.3 and ubuntu 12.10

Requirements
------------

## Platform
Tested on centos 6.3 and ubuntu 12.10

## Cookbooks

phantomjs - we used this [phantomjs cookbook](https://github.com/jenkinslaw/phantomjs) but others exist.

Attributes
----------

    Key
    Type
    Description
    Default

    <tt>['casperjs']['version']</tt>
    String
    Versino of casperjs to install
    <tt>1.0.2</tt>

    <tt>['casperjs']['install_method']</tt>
    String
    Choose from the different installation recipes included.
    <tt>package</tt>

    <tt>['casperjs']['archive']['url_prefix']</tt>
    String
    Configure where the archive is downloaded from.
    <tt>https://codeload.github.com/n1k0/casperjs/zip/</tt>

    <tt>['casperjs']['archive']['url_suffix']</tt>
    String
    Configure where the archive is downloaded from.
    <tt></tt>

    <tt>['casperjs']['git']['source_dir']</tt>
    String
    The root folder for cloning the CasperJs Git Repository.
    <tt>/usr/local/src</tt>

    <tt>['casperjs']['git']['source_url']</tt>
    String
    The URL for the CasperJs Git repository.
    <tt>https://github.com/n1k0/casperjs.git</tt>

Usage
-----

Just include `casperjs` in your node's `run_list`:

```json
{
  "name":"my_node",
  "run_list": [
    "recipe[casperjs]"
  ]
}
```

Contributing
------------

1. Fork the repository on Github
2. Create a named feature branch (like `add_component_x`)
3. Write you change
4. Write tests for your change (if applicable)
5. Run the tests, ensuring they all pass
6. Submit a Pull Request using Github

License and Authors
-------------------
Author:: Chad Nelson
Contributor(s):: David Kinzer

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.

repository: jenkinslaw/casperjs-cookbook

gha_language: Ruby

repo_name: jenkinslaw/casperjs-cookbook


text:
# emailimg-rpi
A simple tool turns a Raspberry Pi (RPi) into a security monitoring system, using email as a transport layer. The script has only been tested with an outlook.com account and a sina.com account.

# What are needed
- A Raspberry Pi (version 1-3) Model B (needs Internet connectivity)
- A camera module (this would work: https://www.raspberrypi.org/products/camera-module/)
- Python 2.7: smtplib, pyOpenSSL, ndg-httpsclient, pyasn1, PIL
- An email account (a free one can be obtained from live.com or sina.com)

## Email a JPEG image upon motion detection

Usage:

1. Install the camera module on the RPi, and enable camera module from `rspi-config` menu.

2. Obtain an email account that supports SMTP (e.g., from outlook.com or sina.com).

3. Override the corresponding strings in `.config` with the respective values, for the SMTP server name & port, email username (address), and email password.

4. Create a ramdisk of size 80M bytes to store motion-detected image files.
   ```
   mkdir /mnt/ramdisk_motion
   mount -t tmpfs -o size=80M tmpfs /mnt/ramdisk_motion
   ```

   To make the ramdisk persist over reboots, add the following lines to `/etc/fstab`:
   ```
    # ramdisk for camera capture
    tmpfs       /mnt/ramdisk_motion tmpfs   nodev,nosuid,noexec,nodiratime,size=80m   0 0
   ```

5. Run `emailimg-motion-run.sh`.

6. (Optional) To turn off the LED red light in the camera module when taking pictures, edit the file `/boot/config.txt` to add / change the following line:
    ```
    disable_camera_led=1
    ```
7. (Optional) To run the program upon system boot, create a cron job:
   ```
   crontab -e
   ```
   And add the following lines (and redirect stdout and stderr output
   to a file)
   ```
   # Upon reboot
   @reboot stdbuf -oL -eL /home/pi/bin/emailimg-rpi/emailimg-motion-run.sh > /home/pi/bin/emailimg-rpi/emailimg.log 2>&1
   ```
   In the above line, we use `stdbuf` tool in the coreutils package to
   set line buffering for stdout and stderr, so that log messages are
   written to the log file immediately. (If you wish to completely turn
   off buffering for stdout and stderr, use the `-o0 -e0` options.)

## Email a JPEG image every 10 minutes (for time-lapse photography)

Usage:
1. Follow steps 1-3 as in the above section

2. Because we are going to write and delete a lot of files, in order to prevent the SD card worn out, create a ramdisk (of size 25M bytes) to store image files created during the process.
    ```
    mkdir /mnt/ramdisk_still
    mount -t tmpfs -o size=25m tmpfs /mnt/ramdisk_still
    ```
   To make the ramdisk persist over reboots, add the following lines to `/etc/fstab`:

    ```
    # ramdisk for camera capture (added 20160306)
    tmpfs       /mnt/ramdisk_still tmpfs   nodev,nosuid,noexec,nodiratime,size=25m   0 0
    ```
3. Create a cron job to take a still picture from the RPi camera module every 10 minute. Do `crontab -e` and add the following:

    ```
    # take still picture every 10 minutes, and email
    */10 * * * * /home/pi/bin/emailimg-rpi/email_raspistill.sh 2>&1
    ```
4. Do whatever you like with the emailed images. See the next section for time-lapse photography.

## How to make a time-lapse video from still images using Imagemagick and FFMPEG

1. Put all .jpg images to a directory, say `original`. Change to this directory.

2. Before converting to video, remove image meta info (to reduce the size of the final artifect):
   ```
   list=$(find `pwd` -name '*.jpg' | sort)
   mogrify -strip ${list}
   ```
3. (Optional) Turn images into grayscale, if a black-and-white video is preferred. Save grayscale images to a separate directory, say `grayscale`.
   ```
   for i in ${list}; do convert -type Grayscale "${i}" grayscale/"${i}"; done
   ```

4. (Optional) Normalize the histogram of the images (original or grayscale) using [histmatch](http://www.fmwconcepts.com/imagemagick/histmatch/index.php). Change into the directory of interest (`orignal` or `grayscale`), put the `histmatch` script there, and then do the following.
   ```
   for i in ${list}; do ./histmatch -c gray ref.jpg "${i}" normalized/"${i}"; done
   ```
   Here, `ref.jpg` is a reference image for histogram normalization. It is usually picked from `${list}.

5. Use Imagemagick to convert images of interest (in directories `original`, `grayscale`, `normalized`, respectively) to a MPEG video, adding 0.1 second delay between frames.
   ```
   (Change into appropriate directory)
   list=$(find `pwd` -name '*.jpg' | sort)
   convert -delay 10 ${list} video.mpeg
   ```
   Turn MPEG to MP4 using ffmpeg.
   ```
   ffmpeg -i video.mpeg video.mp4
   ```

   The final product is `video.mp4`. Enjoy!

## Some SMTP server settings

* outlook.com
  - Server: smtp-mail.outlook.com
  - Port: 587
  - Note: Outlook.com is quite annoying, in that it asks for human
    "verification" over and over again after a few emails are sent through
    smtplib. I would avoid outlook.com email for this application.

* sina.com
  - Server: smtp.sina.com
  - Port: 25

##

repository: syncom/emailimg-rpi

repo_name: syncom/emailimg-rpi


text:
Java-Image-Processing-Project
=============================

DY imageFX - Image Processing project

By: Yusuf Shakeel

Date: 26-Jan-2014 Sunday

[facebook.com/yusufshakeel](https://www.facebook.com/yusufshakeel)

[youtube.com/yusufshakeel](https://www.youtube.com/yusufshakeel)

[github.com/yusufshakeel](https://www.github.com/yusufshakeel)

[plus.google.com/+YusufShakeel](https://plus.google.com/+YusufShakeel/posts)

Note
----
This project is in development stage so files will get modified quite often.

I have used NetBeans IDE 7.3.1 for this project. It is a free software and you can download it from there website [netbeans.org] (https://netbeans.org)

Content
-------

Directories:

 * src - Holds the source code files.
 * src/imageFX - This directory is the ENGINE of the project. It contains .java files to process image.
 * src/myPackage - This directory contains .java files that uses the ENGINE to give output.

Files:

 * src/imageFX/DYCanvas.java - This file contains some random canvas creating method.
 * src/imageFX/DYColor.java - This file contains hex value of colors.
 * src/imageFX/DYMosaic.java - This file contains methods to create mosaic.
 * src/imageFX/FilterImage.java - Contains filtering methods.
 * src/imageFX/ImageFX.java - Contains common image processing functions like flip, negative etc.
 * src/imageFX/MyImage.java - Contains MyImage class that is used to create image objects.
 * src/imageFX/ThresholdImage.java - Contains thresholding methods.

### How to use the imageFX package in your project?

1. Download the [Java-Image-Processing-Project](https://github.com/yusufshakeel/Java-Image-Processing-Project) repository and copy paste the imageFX directory inside your project directory.
2. Import the imageFX classes inside your java file(s) where you want to use it.

For instance, if you want to import the imageFX classes inside your Test.java file, then write the following line

`import imageFX.*;`

inside your Test.java file.

So your Test.java file may look something like this

    import java.io.*;

    import imageFX.*;

    public class Test{

        //your code goes here...

    }//class Test ends here

### For more details check the project wiki [https://github.com/yusufshakeel/Java-Image-Processing-Project/wiki] (https://github.com/yusufshakeel/Java-Image-Processing-Project/wiki)

# License

The MIT License (MIT)

Copyright (c) 2014 Yusuf Shakeel

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

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

 IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: sanonoyga/Java-Image-Processing-Project

repo_name: sanonoyga/Java-Image-Processing-Project


text:
# Protocol #

Please consult the following for agreed upon protocol as it relates to:

* [Code Review](code_review.md)
* [Git](git.md)
* [Release Management](release_management.md)

repository: ucsdlib/DeveloperGuides

gha_language: Shell

repo_name: ucsdlib/DeveloperGuides


text:
# Restic

This role handles installing and configuring Restic, including systemd services
and timers to automatically run Restic.

## Requirements

The hosts you are targeting should have the following packages:

- python >= 2.6
- python-dnf

## Role Variables

| Variable | Required | Default | Description |
| --- | --- | --- | --- |
| restic_repos | ✅ | `[]` | A list of dictionaries defining a restic repo and what files/directories to backup. The required dictionary keys are `name`, `repo`, and `files`.

See example below for format. |

## Dependencies

None

## Example Playbook

```yaml
- hosts: servers
  roles:
    - role: jaredhocutt.restic
      vars:
        restic_repos:
          - name: b2
            repo: "b2:bucketname:path/to/repo"
            env_vars:
              B2_ACCOUNT_ID: abcdef
              B2_ACCOUNT_KEY: ghijklm
              RESTIC_PASSWORD: password
            files:
              - /home/user1
              - /home/user2
```

## License

MIT

## Author Information

Jared Hocutt (@jaredhocutt)

repository: jaredhocutt/ansible-restic

repo_name: jaredhocutt/ansible-restic


text:
# Send personalized appreciation certificates to employees

See [developers.google.com](https://developers.google.com/apps-script/samples/automations/employee-certificate) for additional details.


text:
# Boilr Template for a Minimal Electron Application
This is a minimal Electron application template based on the Electron documentation.

## Contents
- `index.js` - A web page to render
- `main.js` - Starts the app and creates a browser window to render HTML.
- `package.js` - Points to the app's main file and lists its details and dependencies.

You can learn more about each of these components within the [Quick Start Guide](http://electron.atom.io/docs/latest/tutorial/quick-start).

## Install
Install [boilr](https://github.com/tmrts/boilr) first. then use,
`boilr template download tmrts/boilr-electron electron`

## Usage
`boilr template use electron <target-dir>`

## More Information
For more information please check [boilr](https://github.com/tmrts/boilr)

repository: therealssj/boilr-electron

repo_name: therealssj/boilr-electron


text:
# ProjectEuler-Task-30
Digit fifth powers
The task seems to be easy to bruteforce, thus there is a question - where are the bounds for possible digit fifth powers numbers exist.

We could easily find bounds using 1 and 9 digits - and see that even using only 9, the sum of powers will strongly lag behind number itself after 6-th digit

In solution - compute_bounds function returns numbers and power sums for input @power/digit@

license: Unlicense

gha_language: Python

gha_license_id: Unlicense


text:
# dotnet-sort-refs
[![Build status](https://ci.appveyor.com/api/projects/status/xse0bia9olr5shxr?svg=true)](https://ci.appveyor.com/project/BabuAnnamalai/dotnet-sort-refs) [![NuGet Version](https://badgen.net/nuget/v/dotnet-sort-refs)](https://www.nuget.org/packages/dotnet-sort-refs/)

A .NET Core global tool to alphabetically sort package references in your .NET Core and .NET Standard projects.

If you have benefitted from this library and has saved you a bunch of time, please feel free to buy me a coffee!

## Why use this tool?
References and package references in a project file are the most updated parts. Sorting the references helps with the following:
- Easier merges on source control (git). Without sorting the package references in the project file, you may end up with more merge conflicts to fix.
- It will be easier to go through the list of package references if you manually edit the file or view changes using a diff tool.

## Installation
```bash
dotnet tool install --global dotnet-sort-refs
```

## Usage
```text
dotnet sort-refs [arguments] [options]

Arguments:
  Path          The path to a .csproj, .fsproj or directory. If a directory is specified, all .csproj and .fsproj files within folder tree will be processed. If none specified, it will use the current directory.

Options:
  --version     Show version information
  -?|-h|--help  Show help information
  -i|--inspect  Specifies whether to inspect and return a non-zero exit code if one or more projects have non-sorted package references.
```

Note: `dotnet sort-refs` and `dotnet-sort-refs` are valid usages to run the tool.

repository: mysticmind/dotnet-sort-refs

repo_name: mysticmind/dotnet-sort-refs


text:
---
title: "An attribution-based pruning method for real-time mango detection with YOLO network"
collection: publications
permalink: /publication/2020-attr-prune
date: 2020-01-15
venue: 'Computers and Electronics in Agriculture'
# paperurl: '/files/pdf/research/Turning the Lights on.pdf'
link: 'https://www.sciencedirect.com/science/article/pii/S0168169919313717?dgcid=author'
github: 'https://github.com/GlowingHorse/Fast-Mango-Detection'
book: 'https://shirui-homepage.com/research/attr-prune/'
# code: 'https://doi.org/10.5281/zenodo.3534596'
# zenodo: 'https://zenodo.org/badge/DOI/10.5281/zenodo.3534596.svg'
# researchButton: 'https://shirui-homepage.com/research/attr-prune/'
citation: 'Rui Shi, Tianxing Li, Yasushi Yamaguchi. Computers and Electronics in Agriculture, 2020, 169: 105214.'
---


text:
---
layout: post
title: "Ember CLI Bootstrap Modals"
category: javascript
description: "A quick and easy walkthrough for integrating Twitter Bootstrap
modals into EmberJS"
keywords:
  - EmberJS
  - Twitter Bootstrap
  - Twitter Bootstrap modals
  - Modals
  - Javascript
  - CoffeeScript
---

It's really easy to create reusable modal code to integrate
[Twitter Bootstrap modals](http://getbootstrap.com/javascript/#modals) into
[EmberJS](http://emberjs.com/) projects. Here's how to do it:

## TL;DR
Demo at
[http://ember-cli-bootstrap-modal.herokuapp.com](http://ember-cli-bootstrap-modal.herokuapp.com/)

Code at
[https://github.com/mattbeedle/ember-cli-bootstrap-modal-example](https://github.com/mattbeedle/ember-cli-bootstrap-modal-example)

## The Modal code

The modal code is all the code that our modals will be built on top
of. It consists of a ```ModalController```, ```ModalView```, ```openModal``` and
```closeModal``` actions, and a ```modal``` outlet. Links to demo app and
working code are at the bottom of the article.

First, let's create a basic application template with a modal outlet into which
our modals will be rendered:

```app/templates/application.hbs```
{% highlight html %}
{% raw %}

Bootstrap Modal with Ember CLI examples

{{outlet}}

{{outlet "modal"}}
{% endraw %}
{% endhighlight %}

Now we will define a ```ModalView```. All modal views will inherit from this
view. It ensures that modal settings are consistent across all modals.

```app/views/modal.coffee```
{% highlight coffeescript %}
`import Ember from 'ember'`

ModalView = Ember.View.extend
  tagName: 'div'
  classNames: 'modal'.w()

  # didInsertElement is run once the element of the view has been inserted into
  # the DOM
  # http://emberjs.com/api/classes/Ember.View.html#event_didInsertElement
  didInsertElement: ->
    # First set the div id to "modal". "@$()" is the shortcut to get the view's
    # jQuery element
    @$().attr('id', 'modal')

    # Now set up the modal
    @$().modal
      keyboard: false
      backdrop: 'static'

    # Now show the modal
    @$().modal('show')

  # This is run when the element of the view is going to be destroyed. We
  # override it here to hide the modal first.
  # http://emberjs.com/api/classes/Ember.View.html#event_willDestroyElement
  willDestroyElement: ->
    @$().modal 'hide'

`export default ModalView`
{% endhighlight %}

Now we define a ```ModalController```. This will handle the cancel action. All other
modal controllers will inherit from this.

```app/controllers/modal.coffee```
{% highlight coffeescript %}
`import Ember from 'ember'`

ModalController = Ember.ObjectController.extend
  actions:
    cancel: ->
      # If the controller @content is set, then we need to roll it back to avoid
      # inconsistent state between client and server.
      @content.rollback() if @content

      # Now we send "closeModal" event to bubble up to the application route
      @send 'closeModal'

`export default ModalController`
{% endhighlight %}

Now we need to define the global ```openModal``` and ```closeModal``` actions.
We will do this in ```ApplicationRoute``` as everything bubbles up to here in
the end.

```app/routes/application.coffee```
{% highlight coffeescript %}
`import Ember from 'ember'`

ApplicationRoute = Ember.Route.extend
  actions:
    # This takes one argument; The template to render. It then renders it into
    # The modal outlet which we defined in the application template.
    openModal: (modal) ->
      @render modal,
        into: 'application'
        outlet: 'modal'

    # This handles removing the modal. It simply disconnects the modal outlet to
    # remove the modal. When this happens the "willDestroyElement" function will
    # be called on the ModalView, telling it to close the modal.
    closeModal: ->
      @disconnectOutlet
        outlet: 'modal'
        parentView: 'application'

`export default ApplicationRoute`
{% endhighlight %}

## Building our first modal

At this point all of the code to handle modals is complete. Now we can actually
create our first modal. Let's do this with an action fired from our index
template.

```app/templates/index.hbs```
{% highlight html %}
{% raw %}

Confirmation Modal

{% endraw %}
{% endhighlight %}

We will create an ```IndexRoute``` to handle the ```openConfirmationModal```
action.

```app/routes/index.coffee```
{% highlight coffeescript %}
`import Ember from 'ember'`

IndexRoute = Ember.Route.extend
  actions:
    openConfirmationModal: ->
      # The "openModal" event will bubble up to the ApplicationRoute and be
      # handled there.
      @send 'openModal', 'confirmation/new'

`export default IndexRoute`
{% endhighlight %}

We will need a confirmation/new template now to be rendered.

```app/templates/confirmation/new.hbs```
{% highlight html %}
{% raw %}

      <button class="close" type="button" {{action cancel on="click"}}>x</button>

Confirm

      Are you sure about this?!?!

      <button class="btn btn-default" {{action cancel on="click"}}>Nope
      <button class="btn btn-danger" {{action confirm on="click"}}>Yes, do it!

{% endraw %}
{% endhighlight %}

Now we will need to create a ```ConfirmationNewController``` to handle
the events from the confirmation/new template.

```app/controllers/confirmation/new.coffee```
{% highlight coffeescript %}
`import ModalController from 'ember-cli-bootstrap-modal-example/controllers/modal'`

# We inherit from ModalController to get the "cancel" action.
ConfirmationNewController = ModalController.extend
  actions:
    confirm: ->
      alert 'OK, it will be done!'
      @send 'closeModal'

`export default ConfirmationNewController`
{% endhighlight %}

Finall we must create a ```ConfirmationNewView``` that extends ```ModalView```
to get all of the modal view functionality.

```app/views/confirmation/new.coffee```
{% highlight coffeescript %}
`import ModalView from 'ember-cli-bootstrap-modal-example/views/modal'`

ConfirmationNewView = ModalView.extend()

`export default ConfirmationNewView`
{% endhighlight %}

## Notes & links

So that's it. Simple Bootstrap modals in EmberJS. I've created a demo app and
published it to GitHub. It includes a confirm modal, information modal and
a form modal (using ember-easyForm, ember-validations and ember-data
LocalStorage).

Demo at
[http://ember-cli-bootstrap-modal.herokuapp.com](http://ember-cli-bootstrap-modal.herokuapp.com/)

Code at
[https://github.com/mattbeedle/ember-cli-bootstrap-modal-example](https://github.com/mattbeedle/ember-cli-bootstrap-modal-example)


text:
# DREAM

This repository contains my implementations of DREAM for next basket prediction. Besides I extendted the DREAM Framework to reorder prediction scenario. And it helped me earn 39/2669 place in Kaggle Instacart Reorder Prediction Competition. For anyone who is interested, please check [this page](https://www.kaggle.com/c/instacart-market-basket-analysis) for details about the Instacart competition.

## Model

DREAM uses RNN to capture sequential information of users' shopping behavior. It extracts users' dynamic representations and scores user-item pair by calculating inner products between users' dynamic representations and items' embedding.

Refer to the following paper:

> Yu, Feng, et al. "A dynamic recurrent model for next basket recommendation." Proceedings of the 39th International ACM SIGIR conference on Research and Development in Information Retrieval. ACM, 2016.

for details about DREAM.

## Dataset

It runs on [the Instacart dataset](https://www.kaggle.com/c/instacart-market-basket-analysis) and can be used in other e-commerce datasets by modifying the input easily.

## Files

> `dream.py`
> * definition of DREAM
>
> `train.py`
> * implementation of bpr loss function
> * implemeantation of reorder bpr loss function
> * training of DREAM
>
> `eval.py`
> * calculate <u,p> score using DREAM
>
> `data.py`
> * input wrapper for DREAM
> * based on the Instacart Dataset
>
> `utils.py`
> * some useful functions
>
> `config.py`
> * DREAM configurations
>
> `constants.py`
> * some constants such as file path
>
> `Make Recommendation Using DREAM.ipynb`
> * using trained DREAM model to generate predictors for <u,p>

## Requirements

- tensorboard
- tensorboardX
- pytorch == 0.3
- pandas ==  0.19.2
- scikit-learn == 0.18.1

You need GPU to accelerate training.

## License

Copyright (c) 2018 Yihong Chen


text:
# Awesome Toy Robot Simulator Test Resolution [![Build Status](https://travis-ci.org/tiarly/awesome_toy_robot_simulator.svg?branch=develop)](https://travis-ci.org/tiarly/awesome_toy_robot_simulator)

[![forthebadge](http://forthebadge.com/images/badges/made-with-ruby.svg)](http://forthebadge.com) [![forthebadge](http://forthebadge.com/images/badges/built-with-love.svg)](http://forthebadge.com)

This is an attempt to solve the given imaginary problem.

![Gem usage](docs/awesome_toy_robot_simulator.gif)

## Description

* The application is a simulation of a toy robot moving on a square tabletop,
of dimensions 5 units x 5 units.
* There are no other obstructions on the table surface.
* The robot is free to roam around the surface of the table, but must be
prevented from falling to destruction. Any movement that would result in the
robot falling from the table must be prevented, however further valid movement
commands must still be allowed.

## Specifications

Create an application that can read in commands of the following form:

```
PLACE X,Y,F
MOVE
LEFT
RIGHT
REPORT
```

* `PLACE` will put the toy robot on the table in position X,Y
and facing `NORTH`, `SOUTH`, `EAST` or `WEST`.
* The origin (0,0) can be considered to be the `SOUTH WEST` most corner.
* The first valid command to the robot is a `PLACE` command,
after that, any sequence of commands may be issued, in any order,
including another `PLACE` command.
The application should discard all commands in the sequence
until a valid `PLACE `command has been executed.
* `MOVE` will move the toy robot one unit forward
in the direction it is currently facing.
* `LEFT` and `RIGHT` will rotate the robot 90 degrees
in the specified direction
without changing the position of the robot.
* `REPORT` will announce the X,Y and F of the robot.
This can be in any form, but standard output is sufficient.

* A robot that is not on the table can choose
to ignore the `MOVE`, `LEFT`, `RIGHT` and `REPORT` commands.
* Input can be from a file, or from standard input, as the developer chooses.
* Provide test data to exercise the application.
* It is not required to provide any graphical output
showing the movement of the toy robot.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'awesome_toy_robot_simulator'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install awesome_toy_robot_simulator

## Technical Stack

The reason why I chose to go with gem was basically for nicety of an
easy installation for whoever is trying to make use of our ToyRobot
Simulator. Not to mention the fact that it can be also used
alongside in another app as a new dependency. I have tried to write
this test solution in way that can provide scalabiliy for new upcoming
features, and to also ensure readability, by creating small classes
with basic responsabilities. That way, it can follow a more smoothly
onboarding process.

This gems is using the follwing gems for self support:

 - bundler (our default dependency manager)
 - pry (for testing purposes only)
 - simplecov (for increase/ensure test coverage)
 - rake (for creating our custom rake tasks)
 - reek (for adding nice linting for code smells)
 - rspec (our BDD testing gem)
 - rubocop (same as reek, but for more general syntax rules)

## Usage
To run our AwesomeToyRobotSimulator, just install the gem, and run:

    $ awesome_toy_robot_simulator path_for_the_given_file_to_be_processed

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/tiarly/awesome_toy_robot_simulator. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

## Code of Conduct

Everyone interacting in the AwesomeToyRobotSimulator project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/awesome_toy_robot_simulator/blob/master/CODE_OF_CONDUCT.md).


text:
---
name: Bug report
about: Create a report describing unexpected or incorrect behavior in this package
---

<!--
We know asking good questions takes effort, and we appreciate your time.
Thank you.

These comments are hidden when you submit this github issue.

Please have a search on our GitHub repository to see if a similar issue has already been posted.
If a similar issue is closed, have a quick look to see if you are satisfied by the resolution.
If not please go ahead and open an issue!
-->

### Description

<!--
Provide a general description of the bug.
-->

### Expected vs Actual behavior

<!--
What did you expect to happen.

What actually happened.
Was the output confusing or poorly described?
-->

### Steps to Reproduce

<!--
Please include code that reproduces the issue whenever possible.
The best reproductions are self-contained scripts with minimal dependencies.
-->

```python
Code goes here
```

### System Details

<!--
We need to know the the package version you are using.
Please include the output of the `dkist.system_info() function below, or fill
in the details:
-->

- DKIST Version:
- SunPy Version:
- Astropy Version:
- Python Version:
- OS information:

repository: DKISTDC/dkist

repo_name: DKISTDC/dkist


text:
# Approximate_Join
Read me - Work in Progress

This program is designed to to take two csv file and join them together based on a key that is approximate.
Primary join mechanism is using the built-in function of merge_asof from Pandas.

There are three options for the join:

    Nearest
    Table 1 > Table 2
    Table 1 < Table 2

Additionally a second join key can be specified allowing for more utility of the program.

Example Use Case:

    The following example use case was the primary reason this program was created.
    Matching Airling Flights to Weather Data

    Flight Data is specified to the minute where as Weather data was taken about once every hour, but not at the exact time.
    Additionally, there are many airports requiring a second join key to be used.


text:
# Helix

The [Helix] editor has a built-in LSP client that supports ErlangLS
out-of-the-box.

## Installation

First, make sure you have a recent Helix installation. ErlangLS configuration
was added in 22.05. If you're running an older build, you may configure
ErlangLS in the [language configuration file]:

```toml
[[language]]
name = "erlang"
language-server.command = "erlang_ls"
```

Install ErlangLS on your system. The `erlang_ls` executable must be in `$PATH`.

## Troubleshooting

Use `hx --health erlang` to check that Helix can find ErlangLS.

Run Helix in verbose mode with `hx -v` (up to three `v`s) and check the
[log file] to debug communication between Helix and ErlangLS.

## Tips and Tricks

LSP-driven auto-format is disabled by default. You can enable auto-format local
to a project by adding a `.helix/languages.toml`:

```toml
[[language]]
name = "erlang"
auto-format = true
```

Or globally in the [language configuration file].

[Helix]: https://helix-editor.com
[language configuration file]: https://docs.helix-editor.com/languages.html
[log file]: https://github.com/helix-editor/helix/wiki/FAQ#access-the-log-file

branch_name: refs/heads/mkdocs


text:
# CthCoin
A web/crypto CTF Challenge for the Hack.lu 2016

- Title: CthCoin

- Text: Cthulhu awakens and all worshippers will be rewarded greatly! A new Cryptocurrency was created, and Cthulhu generous gives away free coins. Can you break it, but be careful do not provoke him.

- Points: 150

- [Dowload]()

- Solution: You need 120 to buy the flag but only get 65. Check /robots.txt to find /debugcoins. The coin is md5ed when spending it. To perform double spending you need to alter the coin so you get a different md5 hash. As everything is signed only the signature can be altered. Signature algo is ECDSA, ECDSA is Malleable (in bitcoin known as Transaction Malleability). So for signature (r,s), the signature (r, -s (mod N)) is valid. The curve is public and inside the coin. Check watchdog.py for code.

---

# Setup

- create virtual env (python3 virtualenv3)
	`virtualenv venv`

- activate it
	`source venv/bin/activate`

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

- create a new sk.pem
	`python genkey.py`

- create database
	`python createdb.py`

- run it
	`gunicorn -w 4 -b <IP_ADDRESS>:80 ctfapp:app`

- or for debug
	`python run.py`

- watchdog/solution
	requirements.txt
	exit(1) on fail exit(0) on success
	should not be run every min as is takes quite some time

	`watchdog.py ip port`


text:
## INTERCOMMUNICATION ENDPOINTS (DO NOT USE)
The following endpoint is used by the application itself and **DOES NOT REQUIRE** user input. **PLEASE DO NOT USE WITHOUT PERMISSION**

#### UPDATE EVENT OF A FILE (DO NOT USE)
Updates an event of a file being uploaded to Quarantine and then Scanned.

```
POST    /file-upload/events/{eventType}
```

| Responses    | Status    | Description |
| --------|---------|-------|
| Ok  | 200   | Successfully update event.
| Bad Request  | 400   | Invalid Event.
| Locked  | 423   | Cannot update event. Routing request is already received for this envelope.

#### EXAMPLE (FOR FILE IN QUARANTINE)
Request (POST): localhost:8898/file-upload/events/FileQuarantineStored

Body:
```json
{
	"envelopeId": "0b215e97-11d4-4006-91db-c067e74fc653",
	"fileId": "file-id-1",
	"fileRefId": "file-ref-1",
	"created":<PHONE_NUMBER>794,
	"name": "myfile.txt",
	"contentType": "pdf",
	"metadata": {}
}
```

Response: 200

#### EXAMPLE (FOR FILE SCANNED)
Request (POST): localhost:8898/file-upload/events/FileScanned

Body:
```json
{
	"envelopeId": "0b215e97-11d4-4006-91db-c067e74fc653",
	"fileId": "file-id-1",
	"fileRefId": "file-ref-1",
	"hasVirus": false
}
```

Response: 200

Note: "hasVirus" depends on the result from clamAV. If there is a virus, then hasVirus is set to "true" otherwise if not then it would be set to "false".

#### UPLOAD FILE (DO NOT USE)
Uploads a binary file to Transient Store. This endpoint cannot be used directly to upload a file and any attempts to do so will be rejected. Only files that have been uploaded to the frontend, that have been quarantined and then scanned are accepted.
```
PUT     /file-upload/envelopes/{envelope-Id}/files/{file-Id}/{file-Ref-Id}
```
| Responses    | Status    | Description |
| --------|---------|-------|
| Ok  | 200   | Successfully uploaded file a file.  |
| Not Found | 404   |  File or Envelope not found. Unable to Upload. |

#### EXAMPLE
Request (PUT): localhost:8898/file-upload/envelopes/0b215e97-11d4-4006-91db-c067e74fc653/files/file-id-1/file-ref-1

Body: Binary File.

Response: 200

[back to README](../README.md)

repository: hmrc/file-upload

repo_name: hmrc/file-upload


text:
# Controlling the real robot
+ Controlling the real robot via ROS into wanted position using kinematic error modeling's input velocities
+ Please attach github URL when you use my code!
+ 코드를 사용시 링크를 첨부해주세요!
+ Each folders and branches has its own README.md which is A to Z explanation in detail
+ 각각의 폴더와 브런치들에 자세한 README.md(설명)이 별도로 있습니다.

### Robot - Husky from Clearpath
+ [Husky](https://www.clearpathrobotics.com/husky-unmanned-ground-vehicle-robot/)

### Referred to robot's modelling of paper :
+ **A Stable Target-Tracking Control for Unicycle Mobile Robots**, Sung-On Lee, Young-Jo Cho, Myung Hwang-Bo, Bum-Jae You, Sang-Rok Oh, Proceedings of the 2000 IEEE/RSJ International Conference on Intelligent Robots and Systems
  + **Modelling uses velocity input which is proved stable by Lyapunov stability**

### Nessecary :
+ [< Robotics System Toolbox >](https://kr.mathworks.com/help/robotics/classeslist.html)
+ Should start robot before running the MATLAB code by
  ~~~
  $ sudo service start husky_core
  ~~~
  on the board connected with husky (should be already implemented by correct installation)

## Code breaking down

+ ROS connection :

  ~~~MATLAB
  rosinit('<IP_ADDRESS>'); % type your robot's IP
  robot = rospublisher('/husky_velocity_controller/cmd_vel'); % topic name is different with other robots
  velmsg = rosmessage(robot);
  odom = rossubscriber('/husky_velocity_controller/odom');
  ~~~

  This block initialize ROS connection and make nodes subscribes and publishes the messages under topics

+ System Parameters :

  ~~~MATLAB
  K1=2;
  K2=2; %gain

  xt=1;
  yt=1; %xt= target.x, yt = target.y
  rho=sqrt((xt-Ax)^2+(yt-Ay)^2);
  ~~~
  Input Gains K1 and K2 can differ how fast the robot will move

  xt and yt is Goal position in X-Y 2D axes system

+ Calculating input :

  ~~~MATLAB
  while 1
  if rho >=0.02
    rho=sqrt((xt-Ax)^2+(yt-Ay)^2);
    psi=atan2(yt-Ay,xt-Ax);
    phi=theta-psi;
        if phi > pi
        phi = phi - 2*pi;
    end
    if phi < -pi
        phi = phi + 2*pi;
    end % for robot angle range

    velmsg.Linear.X = K1*rho*cos(phi);
    velmsg.Angular.Z = -K1*sin(phi)*cos(phi)-K2*phi;

    if velmsg.Linear.X >= 1
        velmsg.Linear.X=1;
    end
    if velmsg.Linear.X <= -1
        velmsg.Linear.X=-1;
    end
    if velmsg.Angular.Z >= 2
        velmsg.Linear.Z=2;
    end
    if velmsg.Angular.Z <= -2
        velmsg.Angular.Z=-2;
    end % saturation for robot velocity maximum range

    send(robot,velmsg); %sending input into real robot via ROS

    odomdata = receive(odom);
    pose = odomdata.Pose.Pose;
    Ax = pose.Position.X;
    Ay = pose.Position.Y;
    quat = pose.Orientation;
    angles = quat2eul([quat.W quat.X quat.Y quat.Z]);
    theta = angles(1);  %update robot's position information
  else
    velmsg.Linear.X=0;
    velmsg.Angular.Z=0;
    send(robot,velmsg);
    break;
  end
  end
  ~~~

  1.Using the modelling of the paper above, calculated the input by rho(distance between robot and goal position) and phi (subtraction between robot direction and direction from origin to goal position under World coordinate)

  2.and then saturate the input into bound which is the hardware specification of **Husky**

  3.send input to robot via ROS untill get closed to goal position within tolerance (0.02 meter in this code)

## Result clip using Gazebo

  Robot moves to (3,2) position from origin untill close enough

  Gazebo simulation can be implemented as above clip by

  ~~~shell
  $ roslaunch husky_gazebo husky_playpen.launch
  ~~~

repository: engcang/husky

repo_name: engcang/husky


text:
## Candidate Andres Ferrero

Here are the instructions to deploy the project locally and some comments about what i did to accomplish what is implemented.

I added a custom script to package.json named `dev-start`, launch it with `yarn dev-start` or `npm run dev-start` after deploying the <b>Mock-API</b>

First of all, i wanted to do a solid setup for you to see what i tend to use in a daily basis. From the most important aspects of it i can highlight:

- Eslint
- Prettier
- Airbnb linting rules
- Custom linting rules
- lint-staged
- Husky
- Customize create react app

Most of those are to guarantee code quality before pushing into repositories and accomplish homogeneity between implementations in teams, preventing conflicts on merges, etc.

I used customize-cra to not have the need to use relative routes on imports, having the symbol `~` representing the `src` folder

##Now, to the main course.

I cloned the technical test repo you provided and started to develop atop of it, changing its url origin to a new repo of mine in github, which i guess you'd be checking right now. You can watch the commits and merges on the repo to check the workflow i followed. I could've been a little more thorough with it but preferred to focus on the layout and implementation.

Having React not being a framework but instead a library leaves a lot of ground for teams to plow regarding folder organization, deciding where to do the async calls, etc.

What i propose in here is that every component should have its own folder containing the login it needs in an index file and a styles file containing the styles implemented with `styled-components`

There's also a pages folder containing more complex components that represent major Views, associated with routes. Each of those can have a components folder containing components only common for them.

I used redux-saga because i consider it to be a very potent tool, allowing you to isolate async calls and logic that you want to do in between. Preserving redux philosophy (having actions be pure) and leave reducers having the less logic possible.

## Further comments

I'm aware that the route /program/:id is a lacking a bit on design, but i felt that the home view was more than enough to prove the skills required for the test.

I'm delaying the data load into redux state to be able to showcase the loader/spinner i added ;)

I'm available for any questions regarding the tech used, the approach and/or the mindset between all implemented.

branch_name: refs/heads/develop

gha_language: JavaScript


text:
---
title: "Paper Title Number 1"
collection: publications
permalink: /publication/2009-10-01-paper-title-number-1
excerpt: 'This paper is about the number 1. The number 2 is left for future work.'
date: 2009-10-01
venue: 'Journal 1'
paperurl: 'http://academicpages.github.io/files/paper1.pdf'
citation: 'Your Name, You. (2009). "Paper Title Number 1." <i>Journal 1</i>. 1(1).'
---
1. X. Li, K. Wong. Single-Cell RNA-seq Data Interpretation by Evolutionary Multiobjective Clustering, IEEE/ACM Transactions on Computational Biology and Bioinformatics, doi.10.1109/TCBB.2019.2906601, 2019.

2. X. Li, S. Zhang, K. Wong. Single-cell RNA-seq Interpretations using Evolutionary Multiobjective Ensemble Pruning, Bioinformatics, 2019, doi. 10.1093/bioinformatics/bty1056.

3. X. Li, S. Zhang, K. Wong. Nature-Inspired Multiobjective Epistasis Elucidation from Genome-Wide Association Studies, IEEE/ACM Transactions on Computational Biology and Bioinformatics, doi. 10.1109/TCBB.2018.2849759, 2018.

4. X. Li, K. Wong. Evolutionary Multi-objective Clustering and Its Applications to Patient Stratification, IEEE Transactions on Cybernetics, doi.10.1109/TCYB.2018.2817480, 2018.

5. X. Li, K. Wong. Elucidating Genome-Wide Protein-RNA Interactions using Differential Evolution, IEEE/ACM Transactions on Computational Biology and Bioinformatics, doi. 10.1109/TCBB.2017.2776224, 2017.

6. X. Li, K. Wong. Multiobjective Patient Stratification using Evolutionary Multiobjective Optimization. IEEE Journal of Biomedical and Health Informatics, doi.10.1109/JBHI.2017.2769711, 2017.

7. X. Li, S. Ma, Multi-objective Discrete Artificial Bee Colony Algorithm for Multi-objective Permutation Flow Shop Scheduling Problem with Sequence Dependent Setup Times, IEEE Transactions on Engineering Management, 64(2)(2016): 149-165.

8. X. Li, M. Yin, Multiobjective Binary Biogeography based Optimization based Feature Selection for Gene Expression Data, IEEE Transactions on NanoBioscience, 12 (4) (2013): 343- 353.

9. X. Li, M. Li, Multiobjective Local Search algorithm based decomposition for Multiobjective Permutation Flowshop Scheduling Problem, IEEE Transactions on Engineering Management, 2015, 62(4): 544-557.

10. X. Li, K. Wong, A Comparative Study for Identifying the Chromosome-Wide Spatial Clusters from High-Throughput Chromatin Conformation Capture data, IEEE/ACM Transactions on Computational Biology and Bioinformatics, doi: 10.1109/TCBB.2017.2684800, 2017.

11. X. Li, S. Ma, K. Wong, Evolving Spatial Clusters of Genomic Regions from High-Throughput Chromatin Conformation Capture data, IEEE Transactions on NanoBioscience,16(6) (2017), 400-407.

12. Y. Wang, B. Liu, Z. Ma, K. Wong, X. Li* (corresponding author), Nature-Inspired Multiobjective Cancer Subtype Diagnosis, IEEE Journal of Translational Engineering in Health and Medicine, Accepted, 2019.

13. X. Li, M. Yin, Modified Cuckoo search algorithm with self adaptive parameter method, Information Sciences, 2015, 298:80-97.

14. X. Li, S. Ma, G. Yang, Synthesis of Difference Patterns for Monopulse Antennas by an Improved Cuckoo Search Algorithm, IEEE Antennas and Wireless Propagation Letters, 2016, doi: 10.1109/LAWP.2016.2640998.

15. S. Zhang, X. Li, Q. Lin, K.C. Wong, and J. Hancock, Synergizing CRISPR/Cas9 Off-Target Predictions for Ensemble Insights and Practical Applications. Bioinformatics, 2018.

16. K.C. Wong J. Lin, X. Li, Q. Lin; C. Liang, Y. Song, Hterodimeric DNA Motif Synthesis and Validations, Nucleic Acids Research, 2019.

17. Wong, K. C., Yan, S., Lin, Q., Li, X., & Peng, C. Deleterious Non-Synonymous Single Nucleotide Polymorphism Predictions on Human Transcription Factors. IEEE/ACM transactions on computational biology and bioinformatics. 2019.

18. X. Li, M. Yin, Modified Differential Evolution with Self-adaptive Parameters Method, Journal of Combinatorial Optimization, 2016, 31(2):546-576.

19. X. Li, M. Yin, A particle swarm inspired cuckoo search algorithm for real parameter optimization. Soft Computing, 2016, 20(4): 1389-1413.

20. X. Li, S. Ma, Multi-search Differential Evolution Algorithm, Applied Intelligence, 2016, doi: 10.1007/s10489-016-0885-9

21. X. Li, M. Yin, Parameter estimation for chaotic systems by hybrid differential evolution algorithm and artificial bee colony algorithm, Nonlinear Dynamics, 77(2014) 61-71.

22. X. Li, M. Yin, Multi-operator based Biogeography based Optimization with Mutation for Global Numerical Optimization, Computers and Mathematics with Applications, 64(9)(2012) 2833-2844.

23. X. Li, J.Y. Wang, J.P. Zhou, M. Yin, A perturb biogeography based optimization with mutation for global numerical optimization, Applied Mathematics and Computation, 2 011,218(2):598-609.

24. X. Li, M. Yin, An Opposition-Based Differential Evolution Algorithm for Permutation Flow shop Scheduling Based on Diversity Measure, Advances in Engineering Software. 55(2013)10-31.

25. X. Li, M. Yin, A Hybrid Cuckoo Search via Lévy Flights for Permutation Flow shop Scheduling Problem. International Journal of Production Research, 51(16)(2013):4732-4754.

26. X. Li, M. Yin, Self adaptive constrained Artificial Bee Colony for constrained numerical optimization, Neural Computing and Applications. 24(2014):723-734.

27. X. Li, J.N. Wang, M. Yin, Enhancing the performance of cuckoo search algorithm using orthogonal learning method, Neural Computing and Applications, 24(2014)1233-1247

28. X. Li, M. Yin, Animal migration optimization: an optimization algorithm inspired by animal migration behavior, Neural Computing and Applications. 24(2014)1867-1877.


text:
# Security Tool Integrations with TheHive

## Prerequisities

+ A running instance of [TheHive](https://github.com/TheHive-Project/TheHive)
+ [thehive4py](https://github.com/TheHive-Project/TheHive4py) which can be installed with `pip install -r requirements.txt`
+ Python 3.x

## Getting Started
You will need to make a copy of the example config file as hive_config.py and add your own domain/IP, port and API Key

repository: mrrothe/hive-integrations

repo_name: mrrothe/hive-integrations


text:
---
id: docker-verdaccio
title: Verdaccio
sidebar_label: Verdaccio
---

> **Note**: The Verdaccio Docker service is discontinued and has been replaced
> with `tasks/registry.sh`.

[Verdaccio](https://github.com/verdaccio/verdaccio) is a local private package
registry. It is primarily used to publish local development packages which are,
in turn, used by e2e and integration testing.

UI Entrypoint (primary): [<IP_ADDRESS>:4873](http://<IP_ADDRESS>:4873)

UI Entrypoint (docker - discontinued): [<IP_ADDRESS>:4873](http://<IP_ADDRESS>:4873)

username: `cna`

password: `local-registry`

## How to use

From a terminal, load the `registry.sh` script from `tasks`.

```sh
# Project root
. ./tasks/registry.sh
```

### Starting the Local Registry

Run `startLocalRegistry`

### Stopping the Local Registry

Run `stopLocalRegistry`

You may need to verify that your registry config has changed with
`_printRegistryInformation`.

The current registries should not be set to the Verdaccio registry. If
`registry.sh` is unable to revert to your old registry information, run
`useNPMRegistry` or `useYarnRegistry` to set your configuration to their
registries.

repository: MaximDevoir/create-nom-app-monorepo

repo_name: MaximDevoir/create-nom-app-monorepo


text:
### Closes #XXXX

<!-- Use Part of #XXXX if only addressing some of the issue -->

<!-- Summarize the problem being described in the issue -->

### Proposed changes

- < Bulleted summary of changes >
-

<!-- Optional: Add detailed discussion of changes here -->
<!-- Optional: Add screenshots (drag images here) -->

### Acceptance criteria

<!-- Copy the acceptance criteria from the ticket and mark if you were able to complete them -->

- [x] Fulfilled Acceptance Criteria

  <!-- If not, why not? -->

- [ ] Tests added to cover the change

  <!-- If not, why not? -->

### Requested feedback

<!-- What type of feedback would you like from reviewers? -->

branch_name: refs/heads/production


text:
# DocToc [![build status](https://secure.travis-ci.org/thlorenz/doctoc.png)](http://travis-ci.org/thlorenz/doctoc)

Generates table of contents for markdown files inside local git repository. Links are compatible with anchors generated
by github or bitbucket via a command line flag.

**Table of Contents**  *generated with [DocToc](http://doctoc.herokuapp.com/)*

- [Installation](#installation)
- [Usage](#usage)
  - [Adding toc to all files in a directory and sub directories](#adding-toc-to-all-files-in-a-directory-and-sub-directories)
  - [Adding toc to a single file](#adding-toc-to-a-single-file)
    - [Example](#example)
  - [Using doctoc to generate bitbucket compatible links](#using-doctoc-to-generate-bitbucket-compatible-links)

## Installation

    npm install -g doctoc

## Usage

### Adding toc to all files in a directory and sub directories

Go into the directory that contains you local git project and type:

    doctoc .

This will update all markdown files in the current directory and all its
subdirectories with a table of content that will point at the anchors generated
by the github markdown parser.

### Adding toc to a single file

If you want to convert only a specific file, do:

    doctoc /path/to/file

#### Example

    doctoc README.md

### Using doctoc to generate bitbucket compatible links

In order to add a table of contents whose links are compatible with anchors generated by
[bitbucket](https://bitbucket.org/), supply a `--bitbucket` flag to doctoc.

    doctoc README.md --bitbucket


text:
- [Introduction](#introduction)
- [Resources](#resources)

# Introduction

A widget that insets its child by sufficient padding to avoid intrusions by the operating system.

For example, this will indent the child by enough to avoid the status bar at the top of the screen.

It will also indent the child by the amount necessary to avoid The Notch on the iPhone X, or other similar creative physical features of the display.

When a minimum padding is specified, the greater of the minimum padding or the safe area padding will be

> SafeArea is basically a glorified Padding widget. If you wrap another widget with SafeArea, it adds any necessary padding needed to keep your widget from being blocked by the system status bar, notches, holes, rounded corners and other "creative" features by manufactures.

![-----------------------------------------------------](/PlayGround/ResourcesFiles/ReadMeResources/lines/water.png)

# Resources

- https://medium.com/flutter-community/flutter-widget-guide-safearea-widget-in-5-mins-or-less-df4620a7d08f
- https://resocoder.com/2019/11/22/make-safearea-responsive-in-flutter-responsive-widget-tutorial/ ✔

repository: charankumarpalla/laughing-buddha

gha_language: Jupyter Notebook

repo_name: charankumarpalla/laughing-buddha


text:
---
layout: post
title:  "March meeting: Interactive modules via htmlwidgets & simulating data with AlphaSimR"
date:   2019-03-12
categories: edinbr
tags:   announcement
image:
author: acaterin
comments: true
---

Hi everyone,

Our next meeting will take place on the 20th of March, from 5.30pm, in Appleton Tower, Lecture Theatre 1 (see the map below for further details). As usual, the meeting will be open for all to attend, and newcomers / beginners are very welcome!

Our **first speaker** is [Alan O'Callaghan](https://www.linkedin.com/in/alan-o-callaghan-b95864108/), PhD student in biomedical data science in the The Institute of Genetics and Molecular Medicine (IGMM). He will be discussing:

## Building interactive modules using htmlwidgets
(presentation [here](https://htmlpreview.github.io/?https://github.com/EdinbR/edinbr-talks/blob/master/2019-03-20/alan_ocallaghan_building_interactive_modules_using_htmlwidgets.html?raw=true))

>This talk focuses on the `htmlwidgets` framework in R. We will look at the mechanics of creating your own, and why you might choose to use it instead of (or alongside) other frameworks like crosstalk or Shiny. We will start with toy examples to illustrate the basics and then progress to some real use cases, from networks of Twitter interaction to exploration of principal components, in order to demonstrate why this framework is worth learning and applying to your data.

Our **second speaker** is [Martin Johnsson](https://onunicornsandgenes.blog), Postdoc at The Roslin Institute, University of Edinburgh & The Department of Animal Breeding and Genetics, Swedish University of Agricultural Sciences. He will be discussing:

## Simulating genetic data in R: an example with deleterious variants (and a pun)
(slides [here](https://github.com/EdinbR/edinbr-talks/raw/master/2019-03-20/johnsson_edinbr.pptx) and code [here](https://github.com/EdinbR/edinbr-talks/blob/master/2019-03-20/alphasimr_demo.R))

>Simulated quantitative genetic data is extremely useful for geneticists, and can be made easily in R. In this talk, I will briefly sing the praises of simulation, demonstrate a toy breeding programme simulation with the `AlphaSimR` package, and use our recent preprint ['Removal of alleles by genome editing—RAGE against the deleterious load'](Link to preprint: https://www.biorxiv.org/content/10.1101/335497v1.abstract) as a more sophisticated example."

March meeting: Interactive htmlwidgets modules & simulating data with AlphaSimR

Wed, Mar 20, 2019, 5:30 PM: Our first speaker is Alan O'Callaghan, PhD student in biomedical data science in the The Institute of Genetics and Molecular Medicine (IGMM). He will be discussing:> Buildi

Here is a map of where we'll be for the meeting, followed by a trip to the nearby St. Andrews Brewing Co. pub:

See you there!

Caterina Constantinescu

extension: markdown

gha_language: HTML

gha_license_id: NOASSERTION


text:
# Book Store Demo

This is the demo project showing how to use swagger with a symfony
project.

The things you should look at in this project are:

* [The swagger file](contract.json)
* [Validating your specification's implementation](features/bootstrap/FeatureContext.php)
* Generating a client and models from the spec `./vendor/bin/jane-openapi generate`
* [Getting real objects to work with in your controller](src/AppBundle/Controller/DefaultController.php)
* [Nice documentation](http://localhost:8000/documenation)

## Getting Started

These instructions will get you a copy of the project up and running on
your local machine.

### Prerequisities

You'll need:

* PHP 7 or greater
* Composer

### Installing

Simply run

```
composer install
```

Then

```
./bin/console server:run
```

And visit [http://<IP_ADDRESS>:8000/documentation](http://<IP_ADDRESS>:8000/documentation)

## Running the tests

### Behat

Ensure the server is running then run:

```
./vendor/bin/behat
```

## Built With

* [symfony](https://symfony.com/) - Symfony is a set of reusable PHP components and a PHP framework for web projects
* [jane/open-api](https://github.com/janephp/openapi) - Generate a PHP Client API (PSR7 compatible) given a OpenAPI (Swagger) specification.
* [fitbug/guzzle-swagger-validation-middleware](https://github.com/fitbug/guzzle-swagger-validation-middleware) - A guzzle middleware that can be used to validate if requests and responses match what is defined in the schema
* [swagger-ui](http://swagger.io/swagger-ui/) - Swagger UI is a dependency-free collection of HTML, Javascript, and CSS assets that dynamically generate beautiful documentation and sandbox from a Swagger-compliant API.

## Contributing

Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/purplebooth/book-store/tags).

## Authors

* **Billie Thompson** - *Initial work* - [PurpleBooth](https://github.com/PurpleBooth)

See also the list of [contributors](https://github.com/purplebooth/book-store/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: PurpleBooth/book-store

repo_name: PurpleBooth/book-store


text:
---
layout: default
---

# 1996-02-11 - A Rant about Senator James Exon

## Header Data

From<EMAIL_ADDRESS>(Timothy C. May)

To<EMAIL_ADDRESS>Message Hash: 9ed23fc18b8e74e9537c0a7119bb247f5fcefbcd77cd5440d29fb1857d0d3b45

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-02-11 04:16:59 UTC

Raw Date: Sun, 11 Feb 1996 12:16:59 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Timothy C. May)
Date: Sun, 11 Feb 1996 12:16:59 +0800
To<EMAIL_ADDRESS>Subject: A Rant about Senator James Exon
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 1:57 AM 2/10/96, Mark Allyn<PHONE_NUMBER> wrote:
>Allright. That does it.
>
>I am going to volunteer to try to make a perl script that
>I will make available that will automatically email every
>congressman that has an email address. I will include a pre
>pared text of the email message. All you would have to do is
>to sign it and it would send the same message to all of them
>with email addresses automatically. I can even have it have
>several prepaired texts so that they are all slightly different
>so that any funky gatekeepers at the congress email sites that
>attempt to keep out spams could be defeated.
>
>What do you think? Is this worth it?

Here's something I did about Senator James Exon:

My complaint about James Exon

I would like to take a moment to comment on James Exon's statements. What
follows is a set of observations I have made about inane zombies.  If he gets his way, I might
very well kill somebody. This is explicitly or implicitly expressed or
presupposed in most of the material I plan to present. To Exon, terrorism
is a kind of religion. This is not the first time we've had trouble with
unreasonable goofy-types, and it certainly won't be the last. His claims
are a cesspool of alarmism.

If you need proof that he is off his rocker, then just take a look at him.
Exon has a driving need to reduce human beings and many other living
organisms to engineered products and mere cogs in the social machine.
Ostensibly, he does not intend to insult my intelligence, but in fact,
insipid porn stars like him tend to conveniently ignore the key issues of
this or any other situation. Speaking of insincere megalomaniacs, it would
be downright ungrateful for him to censor any incomplicitous principles.
It's a sad world where fickle worthless-types have the power to feed us a
diet of robbery, murder, violence, and all other manner of trials and
tribulations. After all, I myself unequivocally maintain that Exon should
take more responsibility for his actions. To put it another way, he likes
to have difficult social issues presented to him in simple, black-and-white
terms.

I don't see how he can be so abusive.  Rather, it means that his attempts to turn
the trickle of alcoholism into a tidal wave are just a game to him.
Although Exon has tremendous popular appeal, Exon has come very, very close
to making me defend my rights. He should just quit whining about
everything. He feels he has not only a right, but also a duty, to toy with
our opinions. His idea of a good time is to torture jealous radical
hedonists. An inner voice tells me that Exon's claims are pure tripe. To
sum it all up, pesky deranged moviegoers like James Exon often think they
have the right to flush all my hopes and dreams down the toilet.

-Tim May

P.S. As many of you may already know, a "rant generator" can be found at
http://www-csag.cs.uiuc.edu/individual/pakin/complaint

Boycott espionage-enabled software!
We got computers, we're tapping phone lines, we know that that ain't allowed.
---------:---------:---------:---------:---------:---------:---------:----
Timothy C. May              | Crypto Anarchy: encryption, digital money,
<EMAIL_ADDRESS>408-728-0152 | anonymous networks, digital pseudonyms, zero
W.A.S.T.E.: Corralitos, CA  | knowledge, reputations, information markets,
Higher Power: 2^756839 - 1  | black markets, collapse of governments.
"National borders aren't even speed bumps on the information superhighway."

{% endraw %}
```

## Thread

+ Return to [February 1996](/archive/1996/02)

+ Return to "["Declan B. McCullagh" <declan+@CMU.EDU>](/authors/declan_b_mccullagh_declan_at_cmu_edu_)"
+ Return to "[Ed Carp <erc@dal1820.computek.net>](/authors/ed_carp_erc_at_dal1820_computek_net_)"
+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_got_net_timothy_c_may_)"

+ 1996-02-11 (Sun, 11 Feb 1996 12:16:59 +0800) - A Rant about Senator James Exon -<EMAIL_ADDRESS>(Timothy C. May)_
  + 1996-02-11 (Sun, 11 Feb 1996 08:04:05 +0800) - [Re: A Rant about Senator James Exon](/archive/1996/02/1b70c077691ad1643ce8f9ed9e68581c08d465eb01af04129b254a10390f9658) - _"Declan B. McCullagh"<EMAIL_ADDRESS>    + 1996-02-11 (Sun, 11 Feb 1996 18:15:47 +0800) - [Re: A Rant about Senator James Exon](/archive/1996/02/4830c961d744f96576d4e213c91ca0531bf9e6ebb896d921842531f1face274a) - _Ed Carp<EMAIL_ADDRESS>      + 1996-02-11 (Sun, 11 Feb 1996 20:28:05 +0800) - [Re: A Rant about Senator James Exon](/archive/1996/02/1591baef0f13ab4698c690127543b9b185ba7a82fa87e3331aa9911905839d11) - _"Declan B. McCullagh"<EMAIL_ADDRESS>


text:
# miTweet
### Screenshots of UI

![Screenshot of landing page](https://github.com/vinitshahdeo/miTweet/blob/master/img/Capture1.PNG)
![Screenshot of homepage](https://github.com/vinitshahdeo/miTweet/blob/master/img/Capture2.PNG)

![Screenshot of redirected page](https://github.com/vinitshahdeo/miTweet/blob/master/img/Capture3.PNG)
![Screenshot of link page](https://github.com/vinitshahdeo/miTweet/blob/master/img/Capture4.PNG)


text:
# Fitness-Tracker
## Description
Fitness Tracker is an application that allows users to log multiple exercises in a workout on a given day. The app is created to help consumers reach their fitness goals faster because they can track their workout progress. With Fitness Tracker, users can track the name, type, weight, sets, reps, and duration of exercises. If the exercise is a cardio exercise, users can also track their distance traveled.
## Usage
When first arrving to the application, users will be prompted the stats of their last workout if there is any. Users can either continue or add new workout. Depending on the type of exercise, users insert different information for the exercise. If the exercise is a resistance exercise, users will log the exercise name, weight, reps, sets, and duration. If the exercise is a cardio exercise, exercise name, distance, and duration are needed. The Dashboard tab on the upper left corner contains stats of a user's exercises performed in the last seven days.
## Demo
![demo](fitnessTracker.gif)
## Deployed Website
https://trackingyourworkout.herokuapp.com/
## Tech
* HTML
* CSS
* Javascript
* Node js
* MongoDB
* Mongoose
## Author
* Github account: https://github.com/sarah-nguyen1993
* Email<EMAIL_ADDRESS>## License
![badge](https://img.shields.io/badge/license-MIT-green)


text:
Just trying out some stuff.

#

#### ToDo:
- [   ] Implement periodic background sync [https://web.dev/periodic-background-sync/](https://web.dev/periodic-background-sync)

- [   ] Make use of Notification Triggers [https://web.dev/notification-triggers](https://web.dev/notification-triggers/)

- [   ] Use Badging for app icons API [https://web.dev/badging-api](https://web.dev/badging-api)
- [   ] Add user login support:
  - [   ] For local security
  - [   ] For remote syncs
- [   ] Add stored data encryption

- [   ] ...