text:
# Process Map

[![Build Status]][Github Action Link] [![Coverage - Codecov status]][Coverage - Codecov link] [![Coverage - Coveralls status]][Coverage - Coveralls link] [![Github Version]][Github Release Page] [![CRAN Version]][CRAN Link] [![Download Stats]][CRAN Link] [![License]][License Page]

[Build Status]: https://github.com/twang2218/pmap/workflows/main/badge.svg
[Github Action Link]: https://github.com/twang2218/pmap/actions/workflows/main.yml

[CRAN Version]: http://www.r-pkg.org/badges/version/pmap
[CRAN Link]: https://cran.r-project.org/web/packages/pmap/index.html

[Github Version]: https://img.shields.io/github/release/twang2218/pmap.svg
[Github Release Page]: https://github.com/twang2218/pmap/releases

[Coverage - Coveralls status]: https://coveralls.io/repos/github/twang2218/pmap/badge.svg?branch=master
[Coverage - Coveralls link]: https://coveralls.io/github/twang2218/pmap?branch=master

[Coverage - Codecov status]: https://codecov.io/gh/twang2218/pmap/branch/master/graph/badge.svg?token=NZvs1lfOvG
[Coverage - Codecov link]: https://codecov.io/gh/twang2218/pmap

[Download Stats]: https://cranlogs.r-pkg.org/badges/grand-total/pmap?color=brightgreen

[License]: https://img.shields.io/cran/l/pmap.svg
[License Page]: https://github.com/twang2218/pmap/blob/master/LICENSE.md

The goal of `pmap` is to provide the functionality of generating a process map from an event log with the user's preference.

## Installation

An older version of `pmap` is available on [CRAN](https://cran.r-project.org/web/packages/pmap/index.html), if you prefer to install this version, you can install it by:

```R
install.packages("pmap")
```

> However, based on the [CRAN policy](https://cran.r-project.org/web/packages/policies.html#Submission), a developer shouldn't submit a package to CRAN more than once within a month, therefore the [GitHub repo](https://github.com/twang2218/pmap/releases) will be the primary release channel, and the package will be submitted to CRAN only when it is possible. That is, the package version in CRAN can be a bit outdated.

To install the latest version, you can install `pmap` from GitHub directly:

```R
devtools::install_github("twang2218/pmap")
```

And, the users have the options to choose the installed version by specifying the version number in the command, as I [git tagged](https://github.com/twang2218/pmap/tags) each release:

```R
devtools::install_github("twang2218/pmap", ref = "v0.6.0")
```

## Usage

This is a demonstration of how to use `pmap` to create a process map from an event log. `sepsis` dataset in the `eventdataR` package will be used in the demonstration.

### Data preparation

Like any data analysis task, the first but the most important thing is to prepare our data.

Before the actual preparation steps, we should have a common ground on the terminology to be used later. There are mainly four terms, `Case`, `Activity`, `Category` and `Event`. The relation between the terms can be described as the following graph.

And `eventlog` is a collection of `Event`. So, each row in the `eventlog` represents an `Event` object, and each `Event` contains several attributes, including:

* when - `timestamp`;
* who - `case_id`;
* what - `activity` and `category`;

Therefore `pmap` requires three mandatory fields and one optional field in the given `eventlog` data frame:

* `timestamp`: Represent the timestamps of the events when they occurred. The data type should be `POSIXct`. For the case of data type of `timestamp` is `character`, the package will attempt to convert the column to `POSIXct`, but it's just handy in some cases, it's better to make sure the `timestamp` column is in correct data type.
* `case_id`: Represent `Case` ID in the process paths. It is used to calculate the activity frequency or process performance.
* `activity`: Activity name.
* `category`(_optional since v0.4.0_): It is used to differentiate the grouped activities by different colors for a better visualization purpose. For example, the marketing activities with different purposes can be visualized by different colors, with one purpose each. If `category` is missing, the `activity` name will be used as `category` for coloring by default.

> `category` was previously called `event_type`, and required before `v0.3.2`. It is no longer necessary after `v0.4.0`.

Now, let's do the data preparation.

``` r
library(eventdataR)
library(dplyr)
library(pmap)

# Prepare the event log data frame
eventlog <- eventdataR::sepsis %>%
    select(timestamp, case_id, activity) %>%
    na.omit()
```

Check `eventlog` data frame structure.

```R
> head(eventlog)
# A tibble: 6 x 3
  timestamp           case_id activity
  <dttm>              <chr>   <chr>
1 2014-10-22 11:15:41 A       ER Registration
2 2014-10-22 11:27:00 A       Leucocytes
3 2014-10-22 11:27:00 A       CRP
4 2014-10-22 11:27:00 A       LacticAcid
5 2014-10-22 11:33:37 A       ER Triage
6 2014-10-22 11:34:00 A       ER Sepsis Triage
> str(eventlog)
eventlog [15,190 × 3] (S3: eventlog/tbl_df/tbl/data.frame)
 $ timestamp: POSIXct[1:15190], format: "2014-10-22 11:15:41" ...
 $ case_id  : chr [1:15190] "A" "A" "A" "A" ...
 $ activity : Factor w/ 16 levels "Admission IC",..: 4 10 3 9 6 5 8 7 2 3 ...
 - attr(*, "case_id")= chr "case_id"
 - attr(*, "activity_id")= chr "activity"
 - attr(*, "activity_instance_id")= chr "activity_instance_id"
 - attr(*, "lifecycle_id")= chr "lifecycle"
 - attr(*, "resource_id")= chr "resource"
 - attr(*, "timestamp")= chr "timestamp"
 - attr(*, "na.action")= 'omit' Named int [1:24] 442 443 444 445 446 447 448 449 450 451 ...
  ..- attr(*, "names")= chr [1:24] "442" "443" "444" "445" ...
```

### Create a process map

You can create a process map from the `eventlog` directly by running only one command:

```R
# Create process map
p <- create_pmap(eventlog)
# Render the process map
render_pmap(p)
```

The result will be shown in `Viewer` window if you're using R Studio, or in a new browser window if you're running the code from a Terminal.

### Prune the process map

As you can see, the above result is a bit messy, however, we can prune some edges with smaller volume to simplify the process map. It is a better way to find the common paths in the process.

```R
p %>% prune_edges(0.5) %>% render_pmap()
```

It's better, but we can improve it even better by pruning some not very important nodes as well.

```R
p %>% prune_nodes(0.5) %>% prune_edges(0.5) %>% render_pmap()
```

Or, if you want a more interactive approach, you can start a Shiny server app with a slide bar for pruning the nodes and/or edges by a certain percentage. Just be careful, the more the edges and nodes, the slower the process will be. Let's keep `50%` nodes and `50%` edges in our example:

```R
render_pmap_shiny(p, nodes_prune_percentage = 0.5, edges_prune_percentage = 0.5)
```

### Expand the loop

The above process map is great to find the valuable insights as we can immediately observe something very interesting insight from the map: the loop between `CRP` and `Leucocyte`. Is this because of a small group of cases repeatedly went through these two steps many many times? or is this because most cases went through the loop just a few times? To answer the question, we can expand the loop by distinct the repeated activity.

```R
p <- create_pmap(eventlog, distinct_repeated_activities = TRUE)
```

By this way, each new activity name will be attached with the occurrence sequence number of the activity in the path, so the same activity occurs multiple times in the path will have a different name, which means different nodes in the final map. The newly generated the process map will be much more complex than before, so we need prune it further.

```R
p %>% prune_nodes(0.5) %>% prune_edges(0.8) %>% render_pmap()
```

It's interesting to see that there isn't much connection between first time `CRP (1)` and `Leucocyte (1)`, however, the back and forth happened after `Admission NC`.

### Time is the key

Are this back and forth activity loop because of some kind of regular check after `Admission NC`? We are not sure from previous process map, because we don't know how long between each activity occurred. By default, the edge label will be the number of cases went between the two connected activities. We can change it for the duration of those connected activities to understand more about the process in a timely manner.

As there are multiple cases went through the path, we need to decide how to summarize the duration, such as:

* the maximum duration
* the minimum duration
* the mean duration
* the median duration

We can specify the kind of duration by given an `edge_label` argument to the `create_pmap()`.

```R
p <- create_pmap(eventlog, edge_label = "mean_duration")
p %>% prune_nodes(0.5) %>% prune_edges(0.8) %>% render_pmap()
```

or, it can be changed after the process map created by using `adjust_edge_label()` function.

```R
p <- adjust_edge_label(p, label = "mean_duration")
render_pmap(p)
```

By adding the duration between each path into the process map, we can eliminate the problem immediately, as it's not a loop. `Leucocyte` almost always occurred immediately after `CRP` occurred, but not the otherwise. It means `CRP` and `Leucocyte` occurred together in the same sequence, might belong to a blood test pack, and the patients will be tested regularly after `Admission NC`.

And we can also discover the patients would normally be released 2 days after `CRP` and `Leucocyte` test. It might because the test results came back ok, the patients will be released after 2 days observation without any further issue.

We can get that information from the process map clearly.

### Persistent the result

If you're happy with the result, you can save the process map to a PDF or other file format by replace `render_pmap()` with `render_pmap_file()`.

```R
p <- create_pmap(eventlog, edge_label = "mean_duration")
p %>% prune_nodes(0.5) %>% prune_edges(0.8) %>% render_pmap_file("sepsis_process_map.pdf")
```

gha_language: R

gha_license_id: NOASSERTION


text:
# DrinkMixerBot

Telegram bot to find drinks by ingredients

Uses [CocktailDB API](https://www.thecocktaildb.com/)

### Usage

Enter your ingredients (separated by **,**) like **rum,coffee**.

### Commands

| Command | Description |
| :---:              |                   :--- |
| **/repeat_ingredients** | Get another drink with same ingredients|
| **/random_drink** | Get completely random drink
| **/find_drink** | Find drink by name
| **/about** | Show information about the bot and the author
| **/usage** | Show usage

### [Try it out!](https://t.me/DrinkMixerBot)

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: Python

gha_license_id: MIT

license_type: permissive


text:
# GenerativeGraphics

## Installation
### Requirements
#### Hardwares Required:
Machine Capable of running Windows 10
Intel Real Sense 415/435 Depth Cameras
#### Software Required:
Unity version 2017.4.38f1 - (required for development only)
Nuitrack (required for client and developer)
### Step 1: Nuitrack
  [Installation Page](http://download.3divi.com/Nuitrack/doc/Installation_page.html)

  Once you've downloaded navigate to where the Nuitrack File downloaded. (On my machine it automatically went to Program Files) and head over to the activation_tools and run the Nuitrack.exe

  ![alt text](https://github.com/sumara523/GenerativeGraphics/blob/master/images/NuitrackExe.PNG)

  ![alt_text](https://github.com/sumara523/GenerativeGraphics/blob/master/images/ActivationTool.PNG)

   Once you find Nuitrack.exe run it and complete the compatability test (NOTE: Must have Real Sense Camera Plugged or .oni installed and configured in nuitrack_config file to succesfully pass). After you pass the compatability test the text box to activate license should be ungreyed and you should be able to enter in a license key (log in [here](https://cognitive.3divi.com/app/nuitrack/login/) using account information provided by Clay and activate either a trial license (only works for 3 minutes) or the Pro License). You have to run compatibility test with camera plugged in to activate a license.

 ![alt text](https://github.com/sumara523/GenerativeGraphics/blob/master/images/NuitrackLogin.PNG)

 [Here](https://github.com/3DiVi/nuitrack-sdk) is link to nuitrack sdk repo if you want to look at code examples. Should also be possible  [here](http://download.3divi.com/Nuitrack/doc/index.html) to find more info on API architecture and find Unity specific tutorials.

 We imported the Nuitrack Unity Package found [here](https://github.com/3DiVi/nuitrack-sdk/tree/master/Unity3D) in the aboce mentioned repo and imported it as an asset in the unity project to access the api but you shouldn't have to as it should be included in the New Unity Project.

### Ease Development
If you don't want to have to connect the camera every time you make a small change and want to see it  you can download a .oni file (essentially just a video file with depth information. Easy to find places to download them if you just search online. Also [here](http://www.cs.pitt.edu/~huyang/kinect/ml.oni) is the example file we used for testing and add the file path of the oni file to the nuitrack_config file under the OpenNI in the FileRecord Section
![alt text](https://github.com/sumara523/GenerativeGraphics/blob/master/images/ConfigLocation.PNG)
![alt text](https://github.com/sumara523/GenerativeGraphics/blob/master/images/NuitrackConfig.PNG)

and now Unity will run the video contained in the .oni file instead of a live capture from the depth camera.
Some things to look out for is if you copy the file path(make sure to place between quotation marks) you may have to flip the slashes in order for it to work. Using the .oni file also only works if you have the trial license applied but for development it shoudn't be a problem, if the time runs up you can just close the Unity program and run again.
### Step 2: Running executable
Once you've downloaded Nuitrack and activated the license the ISB.exe will be runnable and you will be able to see how the project looks at this point. (NOTE: If don't activate license .exe will run but skeleton will immediately freeze up. Trial License should run but has time limit. Pro License should run with no time limit)
### Installing Unity for develpoment
[Link for proper version download](https://unity3d.com/get-unity/download/archive)
Navigate to 2017.x and get .4.38
Once you have Unity you can download the New Unity Project and open it up in Unity and the correct scene should be loaded in and if not the scene you are looking to load in is Generative Graphics.
DO NOT have the collabortion service turned on and push code to git. Unity corrupts some files while doing this. Instead, push and pull from github for collaborating on the project.

## Unity Program Structure
### Camera and Directional Light
Our Unity scene must contain a Camera and a Directional Light. The default settings should be okay, except the background on the camera should be changed to black.
![alt text](https://github.com/sumara523/GenerativeGraphics/blob/master/images/camera.png)

### Nuitrack Scripts
The default values should be okay here as well, though all we need is skeletal tracking for this project.

### GameObject
This 'GameObject' contains all of the different objects that will be used in the program. On the right side, each of the fields should be set as follows:
![alt text](https://github.com/sumara523/GenerativeGraphics/blob/bens_readme/images/game_objects.png)
#### Type Joint
In our program we use 16 joints. Set the size to 16, and ensure to set the elements in the correct order as shown here, as these indexes are used in the code.
For the remaining objects, under the "project" tab on the lower part of the screen, open up assets -> Generative Graphics and you should see the following objects.
![alt text](https://github.com/sumara523/GenerativeGraphics/blob/bens_readme/images/assets.png)
Drag Particle_System_1 from this box over to the right into both the "Prefab Joint" and "Prefab Connection" fields as shown under the list of joints. This will render the particle system we have created on each of the joints and connections that we create in the code.

Next, drag the particle system called "Particle System" to the field "Prefab Updward" as shown

Finally, drag the two sliders from this box over to their respective prefab fields. "Emission Slider" goes into the "Emission" field and "Emission Upward Slider" goes into "Emission Slider"

To run, go to "File" and select "Build & Run"

gha_language: C#


text:
---
title: Terraspace vs Terraform
nav_text: Terraform
categories: vs
---

In [How Terraspace Works]({% link _docs/intro/how-terraspace-works.md %}), a simple explanation is provided on how Terraspace works. Essentially:

1. A plain old terraform module is built in the `.terraspace-cache` folder.
2. We cd into the folder.
3. And run terraform apply

Simple. Right?

However, Terraspace is much more than a simple wrapper script. It's a full-fledged framework. It makes developing Terraform code easier and more fun. It has:

{% include intro/features.md %}

Though Terraform provides the essential building blocks to write infrastructure-as-code, it leaves much up you to figure out. Terraspace provides a framework on top of Terraform to help you build infrastructure-as-code much more quickly.

## Wood vs Framework

Let's say you are writing a web application in your programming language of choice: Java, Python, Ruby, etc.

Would you just start creating files and just start writing the web app code in that language?

Probably not. You would likely start by choosing a framework first. For example:

Language | Framework
---|---
Java | Spring
Python | Django
Ruby | Rails

Let's say we're building a house. Not using a framework is liken to running off to the forest and cutting down trees for wood. Then using that wood to build doors, windows, etc. Finally, we start constructing the house. But we proceed with no blueprints or architectural plans.  This is how most terraform development is done today.

Terraspace provides a framework to help you get a head start right off the bat. This is because the framework provides an organized structure, conventions, and convenient tooling.

## Life Without Terraspace Part 1

Let's walk through what terraspace does to help understand what life without terraspace is like.

Let's say we have these folders and files in the ~/infra folder:

    app/modules/vm
    app/stacks/vm
    config/terraform/backend.tf
    config/terraform/provider.tf

Here's a brief explanation of the files:

* app/modules/vm - the reusable library code or "functions"
* app/stacks/vm - business logic that makes use of the vm module lib code
* config/terraform/backend.tf - configures the statefile backend
* config/terraform/provider.tf - configures the cloud provider

Without terraspace, the first step would be copy the files over to a ~/project directory. Maybe something like this:

    cd ~
    mkdir -p project/modules
    mkdir -p project/stacks
    cd ~/infra # terraspace project folder
    cp -r app/modules/vm ~/project/modules/vm
    cp -r app/stacks/vm ~/project/stacks/vm
    cp config/terraform/backend.tf ~/project/stacks/vm/backend.tf
    cp config/terraform/provider.tf ~/project/stacks/vm/provider.tf

Now, you might think that we can cd into the `~/project/stacks/vm` folder and run `terraform apply`, right?

But we must edit the `~/project/stacks/vm/backend.tf` file first. Because there are advantages to using [different statefiles]({% link _docs/state/approaches.md %}) and avoiding a monolithic statefile. We don't want all of our eggs in one basket. So we edit the file.

    vim ~/project/stacks/vm/backend.tf # edit the state path

We probably want to use different tfvar files for dev and prod environments. We also may want to use some common base tfvars. So we create more files.

    vim ~/project/stacks/vm/base.tfvars
    vim ~/project/stacks/vm/dev.tfvars
    vim ~/project/stacks/vm/prod.tfvars

Now we can cd in and run `terraform apply` right? Well, not quite yet. We have to remember to specify the tfvar files to be used, something like this:

    cd ~/project/stacks/vm
    terraform apply -var-file base.tfvars -var-file dev.tfvars
    terraform apply -var-file base.tfvars -var-file prod.tfvars

So we're finally done for now and are happy with what we've come up with. We'll probably write some wrapper scripts, typically bash, to glue things together and make the commands shorter.

## Life Without Terraspace Part 2

Then a month later, your boss comes up and asks you, let's take the **same** terraform code and deploy it to different AWS accounts. We want to separate the dev and prod resources in different accounts for security reasons. Makes sense.

Now, what do you do?

Here's what most do:

    mkdir ~/accounts
    cp -r ~/project ~/accounts/project-1
    cp -r ~/project ~/accounts/project-2

There! We solved the problem!

But we really didn't. We've introduced another, larger problem: **duplication**.

Now, we must update configs and source code in multiple places.  So then, we start trying to restructure files into reusable library code in separate folders. Maybe something like this:

    accounts/shared/vm
    accounts/project-1/vm
    accounts/project-2/vm

We still need also to figure out the structure for tfvar files though. We start pondering; maybe we should generate the files?

Then you're asked to also support multiple regions. At this point, you're might even try this:

    accounts/shared/vm
    accounts/us-east-1/project-1/vm
    accounts/us-east-1/project-2/vm
    accounts/us-west-2/project-1/vm
    accounts/us-west-2/project-2/vm

It's like building the [Winchester House](https://en.wikipedia.org/wiki/Winchester_Mystery_House). Ultimately, we end up with a science project.

## Life with Terraspace

Terraspace answers and solves these questions right out of the gates. Here's an example of multiple-regions for AWS:

    app/stacks/demo/tfvars
    ├── us-east-1
    │   ├── dev.tfvars
    │   └── prod.tfvars
    └── us-west-2
        ├── dev.tfvars
        └── prod.tfvars

For AWS, switching region can be done by changing `AWS_REGION`.

    AWS_REGION=us-east-1 terraspace up demo
    AWS_REGION=us-west-2 terraspace up demo

You can use the same code for different environments in the different regions also:

    AWS_REGION=us-east-1 TS_ENV=prod terraspace up demo
    AWS_REGION=us-west-2 TS_ENV=prod terraspace up demo

For more details, check out: [Tfavrs Layering]({% link _docs/tfvars/full-layering.md %})

Terraspace also provide a standard directory structure:

    ├── app
    │   ├── modules
    │   │   └── instance
    │   └── stacks
    │       └── demo
    └── config
        └── terraform
            ├── backend.tf
            └── provider.tf

For more details, see: [Directory Structure]({% link _docs/intro/structure.md %}).

There's a lot more that Terraspace provides. These examples are simply the tip of the iceburg. Learn more by reading through the [Terraspace Docs]({% link _docs/intro.md %}).

## Summary

Terraspace is not just a simple wrapper script that calls out to Terraform. It makes it a lot easier and quicker to work with Terraform. Though Terraform is a powerful tool and allows you to write infrastructure-as-code, it leaves a lot up to you to figure out. Terraspace is a framework that does just that. It provides an organized structure, conventions, and convenient tooling to help you get things done quickly.

{% include vs/related-article.md %}

repository: Grummfy/terraspace-docs

repo_name: Grummfy/terraspace-docs


text:
+++
title = "2021-11-15"

+++
## कार्त्तिकः-08-11,मीनः-उत्तरप्रोष्ठपदा🌛🌌◢◣तुला-विशाखा-07-30🌌🌞◢◣ऊर्जः-08-24🪐🌞सोमः
- Indian civil date: 1943-08-24, Islamic: 1443-04-09 Rabīʿ ath-Thānī/ al-ʾĀkhir
- संवत्सरः - प्लवः
- वर्षसङ्ख्या 🌛- शकाब्दः 1943, विक्रमाब्दः 2078, कलियुगे 5122
___________________
- 🪐🌞**ऋतुमानम्** — शरदृतुः दक्षिणायनम्
- 🌌🌞**सौरमानम्** — शरदृतुः दक्षिणायनम्
- 🌛**चान्द्रमानम्** — शरदृतुः कार्त्तिकः
___________________

## खचक्रस्थितिः
- |🌞-🌛|**तिथिः** — शुक्ल-एकादशी►06:39; शुक्ल-द्वादशी►
- 🌌🌛**नक्षत्रम्** — उत्तरप्रोष्ठपदा►18:06; रेवती► (मीनः)
- 🌌🌞**सौर-नक्षत्रम्** — विशाखा►
___________________
- 🌛+🌞**योगः** — वज्रम्►25:29*; सिद्धिः►
- २|🌛-🌞|**करणम्** — विष्टिः►06:39; बवः►19:17; बालवः►
- 🌌🌛- **चन्द्राष्टम-राशिः**—सिंहः
___________________
- 🌞-🪐 **मूढग्रहाः** - बुधः (8.23° → 7.63°), मङ्गलः (12.44° → 12.76°)
- 🌞-🪐 **अमूढग्रहाः** - शनैश्चरः (-75.02° → -74.07°), शुक्रः (-45.83° → -45.67°), गुरुः (-90.73° → -89.81°)
___________________

## दिनमान-कालविभागाः
- 🌅**सूर्योदयः**—06:22-12:04🌞-17:46🌇
- 🌛**चन्द्रोदयः**—15:11; **चन्द्रास्तमयः**—03:42(+1)
___________________
- 🌞⚝भट्टभास्कर-मते वीर्यवन्तः— **प्रातः**—06:22-07:47; **साङ्गवः**—09:13-10:38; **मध्याह्नः**—12:04-13:29; **अपराह्णः**—14:55-16:20; **सायाह्नः**—17:46-19:20
- 🌞⚝सायण-मते वीर्यवन्तः— **प्रातः-मु॰1**—06:22-07:07; **प्रातः-मु॰2**—07:07-07:53; **साङ्गवः-मु॰2**—09:24-10:10; **पूर्वाह्णः-मु॰2**—11:41-12:27; **अपराह्णः-मु॰2**—13:58-14:43; **सायाह्नः-मु॰2**—16:15-17:00; **सायाह्नः-मु॰3**—17:00-17:46
- 🌞कालान्तरम्— **ब्राह्मं मुहूर्तम्**—04:41-05:31; **मध्यरात्रिः**—22:48-01:20
___________________
- **राहुकालः**—07:47-09:13; **यमघण्टः**—10:38-12:04; **गुलिककालः**—13:29-14:55
___________________
- **शूलम्**—प्राची दिक् (►09:24); **परिहारः**–दधि
___________________

## उत्सवाः
- आकाशदीप-समापनम्, उन्मीलनी महाद्वादशी, कृत्तिका-सोमवासरः, तुलसी-विवाहः, तुला-कावेरी-स्नान-समापनम्, मन्वादिः-(स्वारोचिषः-[२]), सर्व-उत्थान-एकादशी, हक्लदीघाटी-युद्धम् #४९५, हरिवासरः
### आकाशदीप-समापनम्

End of a month long offering of Akasha Dipam.

#### Details
- [Edit config file](https://github.com/jyotisham/adyatithi/blob/master/temples/Tamil/relative_event/kRttikA-maNDala-pArAyaNa-ArambhaH/offset__-1/AkAzadIpa-samApanam.toml)
- Tags: TamilnaduTempleFestivals

### हरिवासरः
- →12:57

The first quarter of dvādaśī tithi is not suitable for breaking fast (pāraṇa), and is known as harivāsaraḥ. Break fast once harivāsaraḥ is over.

अज्ञानतिमिरान्धस्य व्रतेनानेन केशव।
प्रसीद सुमुखो नाथ ज्ञानदृष्टिप्रदो भव॥
वैद्यनाथदीक्षितीये तिथिनिर्णयकाण्डे विष्णुधर्मे---
असम्भाष्यांस्तु सम्भाष्य तुलस्यतसिकादलम्।
द्वादश्यामच्युतफलम् आगस्त्यं पत्रमेव वा।
आमलक्याः फलं वापि पारणे प्राश्य शुद्ध्यति॥

#### Details
- [Edit config file](https://github.com/jyotisham/adyatithi/blob/master/time_focus/monthly/ekAdashI/description_only/harivAsaraH.toml)
- Tags: MonthlyVratam EkadashiVratam

### हक्लदीघाटी-युद्धम् #४९५

Event occured on 1526-11-15 (gregorian). Julian date was converted to Gregorian in this reckoning. Hemachandra vikramAditya, aka Hemu, was vanquished by mogols invading under akbar and his regent bairAm khAn (though they stayed in the rear - 8 miles away). Hemu was aided by afghAn-s who had been earlier deposed by bAbur's invasion. Hemu was atop an elephant named hawAi. His left was led by his sister's son, Ramya, and the right by Shadi Khan Kakkar.

Mogol army was led by Ali Quli Khan Shaibani in the center, Sikandar Khan Uzbak on the right and Abdulla Khan Uzbak towards the left. Vanguard led by Husain Quli Beg and Shah Quli Mahram.

Both the wings of the Mughal army had been driven back and Hemu moved his contingent of war elephants and cavalry forward to crush their centre. Hemu was on the cusp of victory when he was wounded in the eye by a Mughal arrow and collapsed unconscious. This triggered a panic in his army which broke formation and fled.

The elephant carrying the wounded Hemu was captured and led to the Mughal camp. Bairam Khan asked the 13-year-old Akbar to behead Hemu, but he refused to take the sword to a dying man. Akbar was persuaded to touch Hemu's head with his sword after which Bairam Khan executed him. Hemu's head was sent to Kabul while his body was gibbeted on a gate in Delhi. A minaret was subsequently constructed of the heads of the other dead.

Hemu's family who lived in Machari (near Alwar) was captured by Pir Muhammad. Pir Muhammad offered to spare the life of Hemu's elderly father if he converted to Islam. When the old man refused, he was executed. Hemu's Smadhi Sthal, constructed during Akbar's reign by supports, supposedly on the spot where he died, is now occupied by migrant muslims and converted to a dargAh.

#### Details
- [Edit config file](https://github.com/jyotisham/adyatithi/blob/master/mahApuruSha/xatra-later/julian/day/11/05/hemachandra-vikramAdityo_hataH.toml)
- Tags:

### कृत्तिका-सोमवासरः

Do puja to Shiva/Parvati, perform fast.

#### Details
- References
  - Skanda Puranam
- [Edit config file](https://github.com/jyotisham/adyatithi/blob/master/devatA/shaiva/description_only/kRttikA~sOmavAsaraH.toml)
- Tags: MonthWeekdayFestivals

### मन्वादिः-(स्वारोचिषः-[२])

Observed on Śukla-Dvādaśī tithi of Kārttikaḥ (lunar) month (Aparāhṇaḥ/vyaapti).

#### Details
- References
  - Vaidyanātha-Dīkṣitīyam
- [Edit config file](https://github.com/jyotisham/adyatithi/blob/master/time_focus/yugAdiH/lunar_month/tithi/08/12/manvAdiH~%28svArOciSaH~%5B2%5D%29.toml)
- Tags: ManvadiDays

### सर्व-उत्थान-एकादशी

The Shukla-paksha Ekadashi of kārttika month is known as utthāna-ekādaśī.

#### Details
- [Edit config file](https://github.com/jyotisham/adyatithi/blob/master/time_focus/monthly/ekAdashI/description_only/utthAna-EkAdazI.toml)
- Tags: MonthlyVratam EkadashiVratam

### तुला-कावेरी-स्नान-समापनम्

End of Tula Kaveri Snanam. Also known as ta:kaḍaimugam.

#### Details
- [Edit config file](https://github.com/jyotisham/adyatithi/blob/master/devatA/nadI/relative_event/kRttikA-maNDala-pArAyaNa-ArambhaH/offset__-1/tulA-kAvErI-snAna-samApanam.toml)
- Tags: TamilnaduTempleFestivals

### तुलसी-विवाहः

Observed on Śukla-Dvādaśī tithi of Kārttikaḥ (lunar) month (Madhyāhnaḥ/puurvaviddha).

#### Details
- [Edit config file](https://github.com/jyotisham/adyatithi/blob/master/devatA/misc-flora/lunar_month/tithi/08/12/tulasI-vivAhaH.toml)
- Tags: CommonFestivals

### उन्मीलनी महाद्वादशी

repository: namaljayathunga/jyotisha

gha_language: TeX

repo_name: namaljayathunga/jyotisha


text:
---
layout: post
title: Fix git push error in pycharm or other IDE
date: 2018-05-14
author: deng liuyan
header-img: "img/alarm.jpg"
catalog: true
tags:
    - ENV
    - Skill
---

#### The error detail:
you can git add,commit,push in terminal,but cannot push with IDE,the error info is ```Could not read from remote repository```;

#### Fix:
open `Preference` -> open `Version Control` -> click `git` -> select `SSH execute` to `Native`.

extension: markdown


text:
---
title: Create digital identity run by Ethereum

contributors: [Vourhey]
---

One of the Robonomics services is [Digital Passport Registration](https://dapp.robonomics.network/#/passport/) for arbitrary data. The service allows you to create a digital identity saving the hashes of the data to the public blockchain and assigning a unique address.

You may find "Digital passport registration" service in [Robonomics DApp](https://dapp.robonomics.network/) in the "Services" section or just follow this [direct link](https://dapp.robonomics.network/#/passport/).

## Video walkthrough

The following video shows a progress of Robonomics Whitepaper registration:

https://www.youtube.com/embed/E8R6VbZvf9w

## Step-by-step in pictures

### 1. Open the service

![Digital passport registration applying form](./images/case_digital_passport_1.jpg "Digital passport registration applying form")

### 2. Add necessary information and files

Please note, it is possible to add multiple images.

![Filled Form](./images/case_digital_passport_2.jpg "Filled Form")

### 3. Sign the demand

![Sign the demand for digital passport creation](./images/case_digital_passport_3.jpg "Sign the demand for digital passport creation")

### 4. Approve tokens

The service charges a small fee. But first you must approve the required amount of tokens to be spent from your account.

![Approve Tokens](./images/case_digital_passport_4.jpg "Approve Tokens")

### 5. Accept the offer and sign the message again

![Send Order](./images/case_digital_passport_5.jpg "Send Order")

### 6. Have a look at the created passport

![The Digital Identity](./images/case_digital_passport_6.jpg "The Digital Identity")

The process of registration takes some time. In the end you will see a link to the created identity.

repository: airalab/robonomics-wiki

gha_language: Vue

repo_name: airalab/robonomics-wiki


text:
# ReactJs development problem solutions

## Remove `react-router-dom` `Link` underscore

```javascript
<Link to={'/accounts'} style={{ color: 'inherit', textDecoration: 'inherit'}}>
```

[https://stackoverflow.com/a/56158634](https://stackoverflow.com/a/56158634)

## set textfiled value

```javascript
<input type="text" placeholder="First Name" onChange={e => setfName(e.target.value)} />
```

[https://stackoverflow.com/a/57343140](https://stackoverflow.com/a/57343140)

## axios instance set header

```javascript
Object.assign(instance.defaults, {headers: {authorization: 'foo bar'}});
//or
instance.defaults.headers.common['Authorization'] = authToken;
```

[https://github.com/axios/axios/issues/209](https://github.com/axios/axios/issues/209)

## Cannot read property of undefined in Reactjs

```javascript
{this.state.list && <MyMeetingList meetings={this.state.list} />}
```

[https://stackoverflow.com/a/47744911](https://stackoverflow.com/a/47744911)

## Note: the react docs suggest that user-defined components must be capitalized before their use in JSX to avoid being treated as HTML elements.

## material UI add background images

```javascript
import React from 'react';

import Paper from 'material-ui/Paper';

import IconButton from 'material-ui/IconButton';
import ActionHome from 'material-ui/svg-icons/action/home';

import Image from '../img/main.jpg'; // Import using relative path

const styles = {
    paperContainer: {
        backgroundImage: `url(${Image})`
    }
};

export default class Home extends React.Component{
    render(){
        return(
            <Paper style={styles.paperContainer}>
                Some text to fill the Paper Component
            </Paper>
        )
    }
}
```

[https://stackoverflow.com/a/47145247](https://stackoverflow.com/a/47145247)

## Minified React error #152

Remove comments in the first line of returns

[https://stackoverflow.com/a/62849721](https://stackoverflow.com/a/62849721)

repository: nootfly/TIL

gha_language: HTML

repo_name: nootfly/TIL


text:
Homework: Dependency Solver
===========================

Continue reading here only after you read
  [the problem description](https://rgrig.github.io/plad/homework.html).

Grading
-------

You will be graded automatically, using the command

```
./outside-test.sh YOUR_GITHUB_USERNAME
```

If this command does not produce sensible output, you get 0 marks.
So, make sure it works.

(You may get some errors about 'unseen' tests, unless you change tests/inside-test.sh.
These errors don't count.)

-------
For some reason when I clone the repo into docker I don't have permission to run the scripts

to fix, run:
```
chmod 755 *
```


text:
[![Build Status](https://dev.azure.com/microsoftgraph/Graph%20Developer%20Experiences/_apis/build/status/Dotnet/Dotnet%20Beta%20Preview?branchName=master)](https://dev.azure.com/microsoftgraph/Graph%20Developer%20Experiences/_build/latest?definitionId=199&branchName=master)  [![nuget](https://img.shields.io/nuget/v/Microsoft.Graph.Beta.svg)](https://www.nuget.org/packages/Microsoft.Graph.Beta/)

# Microsoft Graph Beta .NET Client Library

<!--
[![Build status](https://ci.appveyor.com/api/projects/status/m8qncaosr2ry4ks6/branch/master?svg=true)](https://ci.appveyor.com/project/MIchaelMainer/msgraph-sdk-dotnet/branch/master)
[![NuGet Version](https://buildstats.info/nuget/Microsoft.Graph)](https://www.nuget.org/packages/Microsoft.Graph/)
-->

Integrate the [Microsoft Graph Beta API](https://graph.microsoft.com) into your .NET project!

The Microsoft Graph Beta .NET Client Library 0.x targets .NetStandard 1.1 and .Net Framework 4.5.

The Microsoft Graph Beta .NET Client Library 4.x targets .NetStandard 2.0 and .Net Framework 4.6.2.

The Microsoft Graph Beta .NET Client Library 5.x targets .NetStandard 2.0

## Installation via NuGet

To install the client library via NuGet:

* Search for `Microsoft.Graph.Beta` in the NuGet Library, or
* Type `Install-Package Microsoft.Graph.Beta -PreRelease` into the Package Manager Console.

## Using the beta client along with the v1.0 library

The Beta library is generated with the `Microsoft.Graph.Beta` namespace. This means that it can be used alongside the V1 package by using the `Microsoft.Graph` namespace while using the `Microsoft.Graph.Beta` namespace from the beta library.

## Getting started

Please see [msgraph-sdk-dotnet](https://github.com/microsoftgraph/msgraph-sdk-dotnet) for information on getting started with this library.

## Notes

### Upgrading to v4

Between 0.x and 4.x there were some major breaking changes:

 * .NET Standard minimum version bumped from `netStandard1.3` to `netstandard2.0`
 * .NET Framework minimum version bumped from `net45` to `net462`
 * Replacing Newtosoft.Json with System.Text.Json
 * Upgrading Microsoft.Graph.Core dependency to version 2.0.0

View the upgrade guide [here](https://github.com/microsoftgraph/msgraph-sdk-dotnet/blob/dev/docs/upgrade-to-v4.md)..

### Upgrading to v5

View the upgrade guide [here](https://github.com/microsoftgraph/msgraph-sdk-dotnet/blob/feature/5.0/docs/upgrade-to-v5.md)..

## Issues

To view or log issues, see [issues](https://github.com/microsoftgraph/msgraph-beta-sdk-dotnet/issues).

This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode<EMAIL_ADDRESS>with any additional questions or comments.

## Other resources

* NuGet Package: [https://www.nuget.org/packages/Microsoft.Graph.Beta](https://www.nuget.org/packages/Microsoft.Graph.Beta)

## Building library locally

If you are looking to build the library locally for the purposes of contributing code or running tests, you will need to:

- Have the .NET Core SDK (> 1.0) installed
- Run `dotnet restore` from the command line in your package directory
- Run `nuget restore` and `msbuild` from CLI or run Build from Visual Studio to restore Nuget packages and build the project

> Due to long file names you may need to run `git config --system core.longpaths true` before cloning the repo to your system.

## License

Copyright (c) Microsoft Corporation. All Rights Reserved. Licensed under the MIT [license](LICENSE.txt). See [Third Party Notices](https://github.com/microsoftgraph/msgraph-sdk-dotnet/blob/master/THIRD%20PARTY%20NOTICES) for information on the packages referenced via NuGet.

repository: microsoftgraph/msgraph-beta-sdk-dotnet

repo_name: microsoftgraph/msgraph-beta-sdk-dotnet


text:
# Kafka Sink

> NOT IMPLEMENTED YET!
> This page is an implementation proposal.

## Usage

Send body to a kafka broker.

```yaml
type: kafka-sink
settings:
  host: localhost:9092
  topic: my-topic
  partition: 0
```

## Record

This node publishes record with this additional fields:

```json
{
  // kafka metadata
}
```

repository: eudaimoniatech/light-webhook

branch_name: refs/heads/main

repo_name: eudaimoniatech/light-webhook


text:
# gatling-zeromq

[![Build Status](https://travis-ci.org/softwaremill/gatling-zeromq.svg?branch=master)](https://travis-ci.org/softwaremill/gatling-zeromq)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.softwaremill.gatling-zeromq/gatling-zeromq_2.11/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.softwaremill.gatling-zeromq/gatling-zeromq_2.11)
[![Dependencies](https://app.updateimpact.com/badge/636824687711752192/gatling-zeromq.svg?config=compile)](https://app.updateimpact.com/latest/636824687711752192/gatling-zeromq)

## Goal of the project

The aim of the project is to allow load testing of applications using [ZeroMQ](http://zeromq.org) with the help of the [Gatling tool](http://gatling.io).

## Adding gatling-zeromq to your project

SBT dependency:

```scala
"com.softwaremill.gatling-zeromq" %% "gatling-zeromq" % "0.1.0"
```

Gradle dependency:
```groovy
"com.softwaremill.gatling-zeromq:gatling-zeromq_2.11:0.1.0"
```

`gatling-zeromq` is available for Scala 2.11 and requires Java 8.

You need to add a dependency on Gatling tool to your project since it is not bundled in this library.

## Running tests

Tests in the project can be started with:
```scala
sbt gatling:test
```

For more information look at the [Gatling SBT plugin](http://gatling.io/docs/current/extensions/sbt_plugin/).

## ZeroMQ connector

The project uses [JeroMQ](https://github.com/zeromq/jeromq) as the ZeroMQ connector.

## Configuration

Before running a scenario, you have to provide host and port to connect to. For example:
```
  val config = zmqConfig
    .host("localhost")
    .port("8916")
```

## Message patterns

The plugin supports:
* the publishing side of the PUB-SUB pattern (`zmqPub("...")`),
* the requesting side of the REQ-REP pattern (`zmqReq("...")`),
* and the pushing side of the PUSH-PULL pattern (`zmqPush("...")`),

## Sending data

Sending of a message and a multi-part message is supported:
```
scenario("Scenario A")
    .exec(
        zmqPub("a request")
            .send("a message")
    )

scenario("Scenario B")
    .exec(
        zmqPub("a request")
            .sendMore("a multi")
            .sendMore("part")
            .send("message")
    )
```

Types of data can be `String`, `Array[Byte]`, numeric ones and [Gatling's Expression Language strings](http://gatling.io/docs/current/session/expression_el/#el) as well.

## Contributing

Take a look at the [open issues](https://github.com/softwaremill/gatling-zeromq/issues) and pick a task you'd like to work on!

repository: mleegwt/gatling-zeromq

repo_name: mleegwt/gatling-zeromq


text:
[@redhat-cloud-services/vulnerabilities-client](../README.md) › [Globals](../globals.md) › [InsightsRule](insightsrule.md)

# Interface: InsightsRule

**`export`**

**`interface`** InsightsRule

## Hierarchy

* **InsightsRule**

## Index

### Properties

* [associated_cves](insightsrule.md#associated_cves)
* [change_risk](insightsrule.md#change_risk)
* [description](insightsrule.md#description)
* [generic](insightsrule.md#generic)
* [kbase_node_id](insightsrule.md#kbase_node_id)
* [playbook_count](insightsrule.md#playbook_count)
* [reboot_required](insightsrule.md#reboot_required)
* [rule_id](insightsrule.md#rule_id)
* [summary](insightsrule.md#summary)

## Properties

###  associated_cves

• **associated_cves**: *Array‹string›*

*Defined in [packages/vulnerabilities/git-api/api.ts:630](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L630)*

List of CVEs associated with the rule.

**`memberof`** InsightsRule

___

###  change_risk

• **change_risk**: *number | null*

*Defined in [packages/vulnerabilities/git-api/api.ts:618](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L618)*

Indicates how likely remediation can change environment on the remediatied system.

**`memberof`** InsightsRule

___

###  description

• **description**: *string | null*

*Defined in [packages/vulnerabilities/git-api/api.ts:588](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L588)*

Description of the rule.

**`memberof`** InsightsRule

___

###  generic

• **generic**: *string | null*

*Defined in [packages/vulnerabilities/git-api/api.ts:600](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L600)*

Generic information about the rule.

**`memberof`** InsightsRule

___

###  kbase_node_id

• **kbase_node_id**: *number | null*

*Defined in [packages/vulnerabilities/git-api/api.ts:624](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L624)*

ID of associated Red Hat knowledgebase article.

**`memberof`** InsightsRule

___

###  playbook_count

• **playbook_count**: *number | null*

*Defined in [packages/vulnerabilities/git-api/api.ts:612](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L612)*

Number of available Ansible playbooks for remediation/mitigation.

**`memberof`** InsightsRule

___

###  reboot_required

• **reboot_required**: *boolean | null*

*Defined in [packages/vulnerabilities/git-api/api.ts:606](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L606)*

Indicator whter reboot is required to mitigate vulnerability.

**`memberof`** InsightsRule

___

###  rule_id

• **rule_id**: *string*

*Defined in [packages/vulnerabilities/git-api/api.ts:582](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L582)*

ID(s) of associated security rule(s).

**`memberof`** InsightsRule

___

###  summary

• **summary**: *string | null*

*Defined in [packages/vulnerabilities/git-api/api.ts:594](https://github.com/RedHatInsights/javascript-clients/blob/master/packages/vulnerabilities/git-api/api.ts#L594)*

Summary of the rule.

**`memberof`** InsightsRule

repository: mkholjuraev/javascript-clients

repo_name: mkholjuraev/javascript-clients


text:
#Forum - E-Commerce Website

#Provide a description of the application use case scenario that you have selected for your final
project.
This application is a limited selection e-commerce website stocking a variety of essential products i.e Household, Grocery and Apparel. It employs the Builder Pattern which allows us to build a complex object step by step. Through which the selected product is generated with product details, added to a cart, could be removed from the cart and cart is checked out.

#Use Case Scenario
A customer needs to pick up some essentials where she logs on to this e-commerce website. The customer would be the primary actor using this system. The system contains an inventory of products: Grocery, Household and Apparel,
a shopping cart and quantity selection. The goal is it to easily browse the product list, add it to the shopping cart, remove it and checkout their cart when they are ready.

#Describe what are your main software design concepts regarding this application.
Using the Builder Design Pattern for this project helped craft the functionality of this e-commerce website. The Director class containing the Construct() refers to the Builder interface to initiate building the parts of a complex object. This interface is then implemented by ProductBuilder (ConcreteBuilder) which generates an abstract Product class that is extended by the ConcreteProduct classes (Household, Grocery and Apparel) which return the User selected product i.e Windex from Household, Handbag from Apparel.

#What are the design goals in your project?
The design goal was to encapsulate code for construction and representation
as needed to accomodate a variety of products without having to hard-code and avoid duplicate code. It allows for more control over constructing more complex objects. This pattern entails referencing and delegating responsibility
down to the generation of a specific Product.

#How is the flexibility, of your implementation, e.g., how you add or remove in future new types?
It is a flexible system as it allows us to vary internal representation yet going forward in the future a separate ConcreteBuilder  would be necessary if new type of products have to be added/

#How is the simplicity and understandability of your implementation?
It's a simple implementation where the ProductBuilder class implements the Builder interface to generate a Product object with common attributes for all products which is then extended by class of the user selected product e.g. Household.

#How you avoided duplicated code?
Use of this design pattern allowed encapsulation of code for construction of the final product which helped us avoid repetition of the same code.

Github Repo Link: https://github.com/alina-akram/metcs-met-cs665-assignment-project-alina-akram

# Project Template

This is a Java Maven Project Template

# How to compile the project

We use Apache Maven to compile and run this project.

You need to install Apache Maven (https://maven.apache.org/)  on your system.

Type on the command line:

```bash
mvn clean compile
```

# How to create a binary runnable package

```bash
mvn clean compile assembly:single
```

# How to run

```bash
mvn -q clean compile exec:java -Dexec.executable="edu.bu.met.cs665.Main" -Dlog4j.configuration="file:log4j.properties"
```

We recommand the above command for running the project.

Alternativly, you can run the following command. It will generate a single jar file with all of the dependencies.

```bash
mvn clean compile assembly:single

java -Dlog4j.configuration=file:log4j.properties -classpath ./target/JavaProjectTemplate-1.0-SNAPSHOT-jar-with-dependencies.jar  edu.bu.met.cs665.Main
```

# Run all the unit test classes.

```bash
mvn clean compile test

```

# Using Findbugs

To see bug detail using the Findbugs GUI, use the following command "mvn findbugs:gui"

Or you can create a XML report by using

```bash
mvn findbugs:gui
```

or

```bash
mvn findbugs:findbugs
```

For more info about FindBugs see

http://findbugs.sourceforge.net/

And about Maven Findbug plugin see
https://gleclaire.github.io/findbugs-maven-plugin/index.html

You can install Findbugs Eclipse Plugin

http://findbugs.sourceforge.net/manual/eclipse.html

SpotBugs https://spotbugs.github.io/ is the spiritual successor of FindBugs.

# Run Checkstyle

CheckStyle code styling configuration files are in config/ directory. Maven checkstyle plugin is set to use google code style.
You can change it to other styles like sun checkstyle.

To analyze this example using CheckStyle run

```bash
mvn checkstyle:check
```

This will generate a report in XML format

```bash
target/checkstyle-checker.xml
target/checkstyle-result.xml
```

and the following command will generate a report in HTML format that you can open it using a Web browser.

```bash
mvn checkstyle:checkstyle
```

```bash
target/site/checkstyle.html
```

# Generate  coveralls:report

You can find more info about coveralls

https://coveralls.io/

```bash
mvn -DrepoToken=YOUR-REPO-TOCKEN-ON-COVERALLS  cobertura:cobertura coveralls:report
```


text:
# Sheeted App

## Requirements

- docker-compose
- Node.js >= 14

## Development

Installation:

```
$ npm install
```

Run docker containers:

```
$ docker-compose up -d
```

Run server:

```
$ npm run build
$ npm start
```

repository: realglobe-Inc/sheeted

gha_language: TypeScript

repo_name: realglobe-Inc/sheeted


text:
---
layout: page
title: About me
image: /img/profile.jpg
---

<img src="/img/profile.jpg" alt="Drawing" style="width: 200px;"/>

Hi there!

My name is Marcelo Perlin. I live in city of Porto Alegre, south of Brazil and I work as an assistant professor of Finance in Federal University of Rio Grande do Sul (UFRGS). I received my PhD in Finance from Reading University (ICMA Centre, UK) in 2010 and I have a substantial experience creating computer scripts for applied research in Finance. You can find more details about my past and current work in my [personal homepage](https://sites.google.com/site/marceloperlin/).

In the computational side, I had a working relationship with Matlab for at least 5 year before switching to R. I was impressed in learning how much easier it was to manipulate and process data with R, once you understand its syntax. I wrote several CRAN packages and now I'm currently writing a book about R and Finance that I hope to publish soon (see details [here](https://msperlin.github.io/myrbook/)).

In this blog I will write about my CRAN packages and any other ideas about finance and R or research papers that I'm currently working on. The content, however, will be mostly about R.

Got a question? Fell free to drop me an email at [marceloperlin@gmail.com](marceloperlin@gmail.com).

Best,

Marcelo.


text:
# GuicyBukkit
A library to use Guice with Bukkit/Spigot, with simplicity in mind.

GuicyBukkit allows you to add listeners and commands to your plugin with Guice. And that's pretty much it.

* [Documentation](https://github.com/jeuxjeux20/guicy-bukkit/wiki)

gha_language: Java


text:
# LAMMPSBuilder

Builder for [LAMMPS](https://github.com/lammps/lammps) using
[BinaryBuilder.jl](https://github.com/JuliaPackaging/BinaryBuilder.jl). It
currently builds the following LAMMPS versions:

 - `stable_3Mar2020`
 - `stable_7Aug2019`

for the following platforms:

 - Linux (`x86_64`, `aarch64`, `ppc64le`)

repository: pabloferz/LAMMPSBuilder

repo_name: pabloferz/LAMMPSBuilder


text:
# logservable

> `git log` as an observable stream of JSON.

[![NPM version](http://img.shields.io/npm/v/logservable.svg?style=flat-square)](https://www.npmjs.com/package/logservable) [![NPM downloads](http://img.shields.io/npm/dm/logservable.svg?style=flat-square)](https://www.npmjs.com/package/logservable) [![Build Status](http://img.shields.io/travis/JamieMason/logservable/master.svg?style=flat-square)](https://travis-ci.org/JamieMason/logservable) [![Maintainability](https://api.codeclimate.com/v1/badges/d0a0296af896b46cc528/maintainability)](https://codeclimate.com/github/JamieMason/logservable/maintainability)

## Table of Contents

-   [🌩 Installation](#-installation)
-   [📝 API](#-api)
-   [🙋🏿♀ Getting Help](#♀-getting-help)
-   [👀 Other Projects](#-other-projects)
-   [🤓 Author](#-author)

## 🌩 Installation

    npm install --save logservable

## 📝 API

### `logservable.commits`

`logservable.commits` returns an [RxJS Observable][observable] which takes an [RxJS Observer][observer];

```js
import { commits } from "logservable";
import { take } from "rxjs/operators";

const commit$ = commits("/Users/foldleft/Dev/my-project", {
  fieldNames: ["authorDateRelative", "authorName", "commitHash"],
  oldestFirst: false
});

commit$.pipe(take(3)).subscribe({
  next(commit) {
    console.log(
      "%s committed %s %s",
      commit.authorName,
      commit.commitHash,
      commit.authorDateRelative
    );
  },
  error(err) {
    console.error("The Stream gave me an error: ", err);
  },
  complete() {
    console.log("The Stream told me it is done.");
  }
});
```

Our example would produce;

    Guybrush Threepwood committed ad7b84e54c62809c7d46b9bb77087a007d1967b5 2 hours ago
    Elaine Marley committed 12c1cde06cdca28d9b41c9cdf667b3e4ff894ca1 2 hours ago
    Herman Toothrot committed 60121fda22cd43a04716c8a76fa803bf1a81e217 6 hours ago
    The Stream told me it is done.

#### Arguments

##### `directory:String`

Absolute path to your locally cloned git repository.

##### `options.fieldNames:String[]`

Optional array of strings representing the data required from each git commit (defaults to all).

    authorDate
    authorDateRelative
    authorEmail
    authorName
    body
    commitHash
    commitNotes
    committerDate
    committerDateRelative
    committerEmail
    committerName
    parentHashes
    reflogIdentityEmail
    reflogIdentityName
    reflogSelector
    reflogSubject
    sanitizedSubjectLine
    subject
    treeHash

For more information see the [Git Pretty Formats Documentation](https://git-scm.com/docs/pretty-formats).

##### `options.oldestFirst:Boolean`

Whether to read the commits in order of oldest to newest (defaults to false).

##### `options.skipMergeCommits:Boolean`

Whether to exclude merge commits from being returned (defaults to true).

### `logservable.tags`

`logservable.tags` returns an [RxJS Observable][observable] which takes an [RxJS Observer][observer];

```js
import { tags } from "logservable";
import { take } from "rxjs/operators";

const tag$ = tags("/Users/foldleft/Dev/my-project");

tag$.pipe(take(3)).subscribe({
  next(tag) {
    console.log("commit %s is tagged as %s", tag.commitHash, tag.tagName);
  },
  error(err) {
    console.error("The Stream gave me an error: ", err);
  },
  complete() {
    console.log("The Stream told me it is done.");
  }
});
```

Our example would produce;

    commit 11eb97230097883288ae565dda7d78b467d8d991 is tagged as 0.1.0
    commit 4b106112ac52c81196e53a4b81cc3543b4aa42c6 is tagged as 0.2.0
    commit 5f6ee8821fbebd01d0910125698afb495c36509c is tagged as 0.3.0
    The Stream told me it is done.

#### Arguments

##### `directory:String`

Absolute path to your locally cloned git repository.

[observable]: http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html

[observer]: http://reactivex.io/rxjs/class/es6/MiscJSDoc.js~ObserverDoc.html

## 🙋🏿♀ Getting Help

Get help with issues by creating a [Bug Report] or discuss ideas by opening a [Feature Request].

[bug report]: https://github.com/JamieMason/logservable/issues/new?template=bug_report.md

[feature request]: https://github.com/JamieMason/logservable/issues/new?template=feature_request.md

## 👀 Other Projects

If you find my Open Source projects useful, please share them ❤

-   [**eslint-formatter-git-log**](https://github.com/JamieMason/eslint-formatter-git-log)
ESLint Formatter featuring Git Author, Date, and Hash
-   [**eslint-plugin-move-files**](https://github.com/JamieMason/eslint-plugin-move-files)
Move and rename files while keeping imports up to date
-   [**eslint-plugin-prefer-arrow-functions**](https://github.com/JamieMason/eslint-plugin-prefer-arrow-functions)
Convert functions to arrow functions
-   [**ImageOptim-CLI**](https://github.com/JamieMason/ImageOptim-CLI)
Automates ImageOptim, ImageAlpha, and JPEGmini for Mac to make batch optimisation of images part of your automated build process.
-   [**Jasmine-Matchers**](https://github.com/JamieMason/Jasmine-Matchers)
Write Beautiful Specs with Custom Matchers
-   [**karma-benchmark**](https://github.com/JamieMason/karma-benchmark)
Run Benchmark.js over multiple Browsers, with CI compatible output
-   [**self-help**](https://github.com/JamieMason/self-help#readme)
Interactive Q&A Guides for Web and the Command Line
-   [**syncpack**](https://github.com/JamieMason/syncpack#readme)
Manage multiple package.json files, such as in Lerna Monorepos and Yarn Workspaces

## 🤓 Author

I'm [Jamie Mason] from [Leeds] in England, I began Web Design and Development in 1999 and have been Contracting and offering Consultancy as Fold Left Ltd since 2012. Who I've worked with includes [Sky Sports], [Sky Bet], [Sky Poker], The [Premier League], [William Hill], [Shell], [Betfair], and Football Clubs including [Leeds United], [Spurs], [West Ham], [Arsenal], and more.

[![Follow JamieMason on GitHub][github badge]][github]      [![Follow fold_left on Twitter][twitter badge]][twitter]

[github badge]: https://img.shields.io/github/followers/JamieMason.svg?style=social&label=Follow

[twitter badge]: https://img.shields.io/twitter/follow/fold_left.svg?style=social&label=Follow

[arsenal]: https://www.arsenal.com

[betfair]: https://www.betfair.com

[github]: https://github.com/JamieMason

[jamie mason]: https://www.linkedin.com/in/jamiemasonleeds

[leeds united]: https://www.leedsunited.com/

[leeds]: https://www.instagram.com/visitleeds

[premier league]: https://www.premierleague.com

[shell]: https://www.shell.com

[sky bet]: https://www.skybet.com

[sky poker]: https://www.skypoker.com

[sky sports]: https://www.skysports.com

[spurs]: https://www.tottenhamhotspur.com

[twitter]: https://twitter.com/fold_left

[west ham]: https://www.whufc.com

[william hill]: https://www.williamhill.com

repository: JamieMason/logservable

repo_name: JamieMason/logservable


text:
# Boggle

## Introduction

This is a backend code of game [Boggle](https://en.wikipedia.org/wiki/Boggle).

There are 3 methods included: [`POST`](#POST), [`PUT`](#PUT), and [`GET`](#GET):

- [`POST`](#POST): This method is used when system calls to create a new game, a `json`
object represents the game will be returned
- [`PUT`](#PUT): This method is the interaction between player and server.
When user input a word, this method is triggered and it will check whether it is
a valid answer and update the game accordingly.

- [`GET`](#GET): This method returns a `json` object represents the game to user.

## Functionality
### Global variable

- `game_data_key_id`: hash map to store game with key is id

- `game_data_key_token`: hash map to store game with key is token

- `test_board`: default board that is get from `test_board.txt`

- `dictionary`: set of all allowed words to play, get from `dictionary.txt`

### POST

- Parameters:
  + `duration` (required): the time (in seconds) that specifies the duration of
    the game
  + `random` (required): if `true`, then the game will be generated with random
    board.  Otherwise, it will be generated based on input.
  + `board` (optional): if `random` is not true, this will be used as the board
    for new game. If this is not present, new game will get the default board
    from `test_board.txt`
- `create_game` is generated first. It first gets
and check required parameters. If either those values is invalid, it will return
`400` error, else function `start_game` is generated
- `start_game` receive `duration` and `random` as input. `Board` is set as the
description above. A `game` json object is then created with attributes:
    + `id`: ID of game
    + `token`: token of game
    + `duration`: duration of game in seconds
    + `board`: board of game as described
    + `time_left`: time remaining for game, initially is set to equal `duration`
    + `points`: points that a player gained, initially set to 0
    + `timestamp`: time clock when game is created, it is used to calculate
    `time_left`
- Game is added to 2 hash maps. Finally, a response status `201` is created.

### PUT

- Parameters:
  + `id` (required): The ID of the game
  + `token` (required): The token for authenticating the game
  + `word` (required): The word that can be used to play the game
- `interact_with_game` function is generated under method `PUT`.
It first checks `id` and `token`. If either of these violates the data in one
of the hashmaps, a `400` status is returned, else `word` is called then passed
to `receive_word` function
- `receive_word` receives `word` and `game` as inputs:
    + `word` isn't in `dictionary` or `board`: return `400` response
    + `word` is in `dictionary`: `time_left` is updated:
        - `time_left` < 0: return `400` response
        - `time_left` > 0: increases point by 3 and return updated game with
        `200` response

### GET

- Parameters:
  + `id` (required): The ID of the game
- `interact_with_game` function is generated under method `GET`.
If `id` isn't in `game_data_key_id`: return `404` response,
else return game with `200` response

repository: tran-quang-thanh/boggle

repo_name: tran-quang-thanh/boggle


text:
## Welcome to GitHub Pages

You can use the [editor on GitHub](https://github.com/chAwater/chAwater.github.io/edit/master/README.md) to maintain and preview the content for your website in Markdown files.

### Resources
- Jekyll
    - http://jekyllthemes.org/
    - https://github.com/thelehhman/plainwhite-jekyll
- Pelican
    - https://docs.getpelican.com/en/stable/
    - http://www.pelicanthemes.com
    - https://github.com/nasskach/pelican-blueidea
- Gridea
    - https://gridea.dev
    - https://github.com/getgridea/gridea-theme-simple
- GitHub
    - https://github.com/github/personal-website
- Emoji
    - https://github.com/caiyongji/emoji-list/blob/master/README.md
- docsify
    - https://docsify.js.org/#/zh-cn/
- hexo
    - https://hexo.io

### Ideas & Projects
#### SEVN + AI
- AlphaGo/Zero
- https://overthemoon.games
#### JetsonXavier
#### SkierFinder
- MaskRCNN
#### AlphaFold
#### 流苏

### Markdown

Markdown is a lightweight and easy-to-use syntax for styling your writing. It includes conventions for

```markdown
Syntax highlighted code block

# Header 1
## Header 2
### Header 3

- Bulleted
- List

1. Numbered
2. List

**Bold** and _Italic_ and `Code` text

[Link](url) and ![Image](src)
```

For more details see [GitHub Flavored Markdown](https://guides.github.com/features/mastering-markdown/).

### Jekyll Themes

Your Pages site will use the layout and styles from the Jekyll theme you have selected in your [repository settings](https://github.com/chAwater/chAwater.github.io/settings). The name of this theme is saved in the Jekyll `_config.yml` configuration file.

### Support or Contact

Having trouble with Pages? Check out our [documentation](https://help.github.com/categories/github-pages-basics/) or [contact support](https://github.com/contact) and we’ll help you sort it out.


text:
## API

ChromaTerm can color the output of your module with minimal effort. The API
has three different ways in which you can highlight.

### [`Color`](../color)

A `Color` is the simplest way to highlight text.

```
#!python
from chromaterm import Color

color = Color('bold')

# The string is bold-styled
color.print('Hello World!')
```

!!! tip
    See the [initializer of `Color`](../color/#chromaterm.Color.__init__) for
    more details on the format of a color.

---

### [`Rule`](../rule)

This class will only highlight the text matching a regular expression.

You can use a `Rule` to highlight significant words without having to go through
every message in your program.

```
#!python
from chromaterm import Color, Rule

rule = Rule('World', color=Color('b#412100'))

# Only "World" is colored
rule.print('Hello World!')
```

---

### [`Config`](../config)

Multiple rules can be bundled into an instance of `Config`.

When highlighting, the text is first matched against all of the rules' regular
expressions and then the colors are added to the text. This makes matching more
accurate as the color (ANSI codes) of one rule won't interfere during the
matching of another.

```
#!python
from chromaterm import Color, Config, Rule

config = Config()
config.add_rule(Rule('Goo', color=Color('underline')))
config.add_rule(Rule('Good', color=Color('b#00aa00')))

# "Goo" is underlined, but "Good" is green
config.print('Good')
```

---

## Decorators

All of the API classes can be used as decorators. This saves you from having to
explicitly reference the object. Here's an example with `Color`, but it's the
same case with `Rule` and `Config`.

```
#!python
from chromaterm import Color

@Color('f#00dd00')
def multiply(x, y):
    return x * y

# The output will be colored green
print(multiply(5, 10))
```

---

## Group-specific Rules

The highlighting of a [Rule](../rule) can be further limited to groups within
the regular expression. By default, the entire match (group 0) is highlighted.

```
#!python
from chromaterm import Color, Rule

rule = Rule('Hello (World)!')
rule.add_color(Color('underline'), group=1)

# Only "World" is underlined
rule.print('Hello World!')

# The regex did not match, and so the "World" group is not underlined
rule.print('Hi World!')
```

---

## Highlighting Precedence

!!! note
    The points below are very peculiar and ones you likely won't have to worry
    about; they're only here to document the behavior.

When the `Config` class has multiple rules and they match the same text, the
following occurs:

* If one match is inside another (encapsulates it), the color of the inner match
  remains unchanged.
* If two rules match the same text exactly, the latest rule added to the `Config`
  instance will color the match.
* If two rules have partially-overlapping matches, the overlap is colored by the
  trailing match (the latter one in the text).

repository: userpipename/ChromaTerm

repo_name: userpipename/ChromaTerm


text:
---
layout: default
---

# 1994-05-17 - Key Servers...

## Header Data

From: Matthew Cable<EMAIL_ADDRESS>To: CypherPunks<EMAIL_ADDRESS>Message Hash: 3dae39d80e5992a1bb7ed1a1f9e2cfc327aca910bfd6c01243bdf6651b73c38b

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-05-17 01:10:46 UTC

Raw Date: Mon, 16 May 94 18:10:46 PDT

## Raw message

```
{% raw  %}From: Matthew Cable<EMAIL_ADDRESS>Date: Mon, 16 May 94 18:10:46 PDT
To: CypherPunks<EMAIL_ADDRESS>Subject: Key Servers...
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Question for all of you.

With the announcement of the 2.6 release, there is a specific mention of
Keyservers which accept 2.6- keys violating RSA's intellectual copyrights...

This has coincided with the dissapearence of nearly all the key servers ....

Is something afoot?  And what do you think RSA has up its sleeve?

*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
	   	     mcable@[jade,emerald,cs].tufts.edu
       \|/<EMAIL_ADDRESS>  Matthew Cable
      <0-0><EMAIL_ADDRESS>  MTUC Jackson Labs
----o00-O-00o-----    http://www.cs.tufts.edu/~mcable/     Tufts University
     GCS/MU -d+ -p+ c++++ l++ u++ e+ m++(*) s++ !n h+ f* g+ w++ t+ r- y+
*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*

{% endraw %}
```

## Thread

+ Return to [May 1994](/archive/1994/05)

+ Return to "[Matthew Cable <mcable@Emerald.tufts.edu>](/authors/matthew_cable_mcable_at_emerald_tufts_edu_)"

+ 1994-05-17 (Mon, 16 May 94 18:10:46 PDT) - Key Servers... - _Matthew Cable<EMAIL_ADDRESS>


text:
# Likewise
Info 490 Capstone Project - Winter & Spring 2020.
AA05 : Tiffany Lai, Brian Uyeda, Olivia Tang and Joanna Tan.

## About
Oftentimes, leaving for university is the first time that many students are living independently on their own. They are displaced from their existing support systems and thrown into an unfamiliar environment. This can be a very overwhelming feeling because college introduces many new stressors to the individual. Students might feel lost and may lack the awareness necessary to tackle newfound problems. Instead of navigating the new territory blindly, this project aims to provide students a supportive platform and space to ask questions and seek advice from other students who have gone through the same situations. It is a place for students to safely voice questions or concerns to just to find a common ground with others.

There are currently very little resources at the University of Washington structured around providing a space for students to seek advice from others. Many events such as Q&A sessions for specific topics occur but this project hopes to offer students to ask for advice at any given time. Moreover, by taking the time to voice stressors or understand what other people are going to, a new level of connection and understanding for other people can occur.

## What's currently here (2/6/2020)
* Read me file to initialize and provide the intended project vision. Includes contact information to reach the team.
* License file to indicate how other users can utilize the base code and reproduce or add content to it later on

## What to expect
* Documentation for the project including code and research data that we collect
* Interactive web-based social platform of some sort to invite understanding and interaction between students who feel estranged or disconnected or just want to seek advice from other students
* We are currently deciding on how we want to conduct user research and finding possible inspirations for the layout of our landing page. Our next steps following this stage will help us decide how we want to prioritize developing the features for our website.

## Contact
If you need to make a general inquiry to the entire team, please email us at<EMAIL_ADDRESS>

Additionally, you can reach individual students via:
Tiffany Lai<EMAIL_ADDRESS>
Brian Uyeda<EMAIL_ADDRESS>
Olivia Tang<EMAIL_ADDRESS>
Joanna Tan<EMAIL_ADDRESS>

gha_language: JavaScript


text:
# `--format` output across commands (i.e. `ls`, `inspect`)

## Why?

- Often output excludes fields available (ie `ls` commands)
- Avoid wrapping excessive data when running `docker container ls` etc (... windows container image names especially!)
- These `templates` are frustrating at times! But worth learning!

## JSON is your friend

- Use `json` output to see full list of what's available
  - `--format "{{json .}}"`
  - And how to refer to fields in your custom format strings even if not targeting `json` output
  - `Fields` are case sensitive
  - and sometimes named different than in `table` formatted headers
- `jq` is your friend (pipe to it)

## References

- [Format command and log output](https://docs.docker.com/config/formatting/)
  - basic examples, an introduction to formatters
- Also, refer to individual command reference docs
  - for fields available, casing, and usage
  - sometimes a command is both a top-level command and nested under a management command, you might find docs in either reference docs
    - i.e. [`docker ps` formatting section](https://docs.docker.com/engine/reference/commandline/ps/#formatting)
      - NOT `docker container ps` reference!

## Override default formatting

- Store your preferred formats in `~/.docker/config.json` (docker client config)
  - i.e. `psFormat`
- Or, consider a `shell` `alias`/`function`
- Or a `snippet` that expands via any snippet tool


text:
---
title: TiDB Migration Tools Overview
summary: Learn an overview of the TiDB migration tools.
---

# TiDB Migration Tools Overview

TiDB provides multiple data migration tools for different scenarios such as full data migration, incremental data migration, backup and restore, and data replication.

This document introduces the user scenarios, supported upstreams and downstreams, advantages, and limitations of these tools. You can choose the right tool according to your needs.

## [TiDB Data Migration (DM)](/dm/dm-overview.md)

| User scenario |Data migration from MySQL-compatible databases to TiDB|
|---|---|
| **Upstream** | MySQL, MariaDB, Aurora, MySQL |
| **Downstream** | TiDB |
| **Advantages** |

A convenient and unified data migration task management tool that supports full data migration and incremental replication

Support filtering tables and operations

Support shard merge and migration

 |
| **Limitation** | Data import speed is roughly the same as that of TiDB Lightning's [logical import mode](/tidb-lightning/tidb-lightning-logical-import-mode.md), and a lot lower than that of TiDB Lightning's [physical import mode](/tidb-lightning/tidb-lightning-physical-import-mode.md). So it is recommended to use DM to migrate full data with a size of less than 1 TiB. |

## [Dumpling](/dumpling-overview.md)

| User scenario | Full data export from MySQL or TiDB |
|---|---|
| **Upstream** | MySQL, TiDB |
| **Downstream (the output file)** | SQL, CSV |
| **Advantages** |

Support the table-filter feature that enables you to filter data easier

Support exporting data to Amazon S3

 |
| **Limitation** |

If you want to restore the exported data to a database other than TiDB, it is recommended to use Dumpling.

If you want to restore the exported data to another TiDB cluster, it is recommended to use Backup & Restore (BR).

 |

## [TiDB Lightning](/tidb-lightning/tidb-lightning-overview.md)

| User scenario | Full data import into TiDB |
|---|---|
| **Upstream (the imported source file)** |

Files exported from Dumpling

Parquet files exported by Amazon Aurora or Apache Hive

CSV files

Data from local disks or Amazon S3

 |
| **Downstream** | TiDB |
| **Advantages** |

Support quickly importing a large amount of data and quickly initializing a specific table in a TiDB cluster

Support checkpoints to store the import progress, so that `tidb-lightning` continues importing from where it lefts off after restarting

Support data filtering

 |
| **Limitation** |

If [physical import mode](/tidb-lightning/tidb-lightning-physical-import-mode-usage.md) is used for data import, during the import process, the TiDB cluster cannot provide services.

 If you do not want the TiDB services to be impacted, perform the data import according to TiDB Lightning [logical import mode](/tidb-lightning/tidb-lightning-logical-import-mode-usage.md).

 |

## [Backup & Restore (BR)](/br/backup-and-restore-overview.md)

| User scenario | Migrate a large amount of TiDB custer data by backing up and restoring data |
|---|---|
| **Upstream** | TiDB |
| **Downstream (the output file)** | SST, backup.meta files, backup.lock files |
| **Advantages** |

Suitable for migrating data to another TiDB cluster

Support backing up data to an external storage for disaster recovery

 |
| **Limitation** |

When BR restores data to the upstream cluster of TiCDC or Drainer, the restored data cannot be replicated to the downstream by TiCDC or Drainer.

BR supports operations only between clusters that have the same `new_collations_enabled_on_first_bootstrap` value.

 |

## [TiCDC](/ticdc/ticdc-overview.md)

| User scenario | This tool is implemented by pulling TiKV change logs. It can restore cluster data to a consistent state with any upstream TSO, and support other systems to subscribe to data changes. |
|---|---|
| **Upstream** | TiDB |
| **Downstream** | TiDB, MySQL, Kafka, Confluent |
| **Advantages** | Provide TiCDC Open Protocol |
| **Limitation** | TiCDC only replicates tables that have at least one valid index. The following scenarios are not supported:

The TiKV cluster that uses RawKV alone.

The DDL operation `CREATE SEQUENCE` and the `SEQUENCE` function in TiDB.

 |

## [TiDB Binlog](/tidb-binlog/tidb-binlog-overview.md)

| User scenario | Incremental replication between TiDB clusters, such as using one TiDB cluster as the secondary cluster of another TiDB cluster |
|---|---|
| **Upstream** | TiDB |
| **Downstream (or the output file)** | TiDB, MySQL, Kafka, incremental backup files |
| **Advantages** | Support real-time backup and restore. Back up TiDB cluster data to be restored for disaster recovery |
| **Limitation** | TiDB Binlog is incompatible with some TiDB versions. It is recommended that you use [TiCDC](/ticdc/ticdc-overview.md). |

## [sync-diff-inspector](/sync-diff-inspector/sync-diff-inspector-overview.md)

| User scenario | Comparing data stored in the databases with the MySQL protocol |
|---|---|
| **Upstream** | TiDB, MySQL |
| **Downstream** | TiDB, MySQL |
| **Advantages** | Can be used to repair data in the scenario where a small amount of data is inconsistent |
| **Limitation** |

Online check is not supported for data migration between MySQL and TiDB.

JSON, BIT, BINARY, BLOB and other types of data are not supported.

 |

## Install tools using TiUP

Since TiDB v4.0, TiUP acts as a package manager that helps you manage different cluster components in the TiDB ecosystem. Now you can manage any cluster component using a single command.

### Step 1. Install TiUP

```shell
curl --proto '=https' --tlsv1.2 -sSf https://tiup-mirrors.pingcap.com/install.sh | sh
```

Redeclare the global environment variable:

```shell
source ~/.bash_profile
```

### Step 2. Install components

You can use the following command to see all the available components:

```shell
tiup list
```

The command output lists all the available components:

```bash
Available components:
Name            Owner    Description
----            -----    -----------
bench           pingcap  Benchmark database with different workloads
br              pingcap  TiDB/TiKV cluster backup restore tool
cdc             pingcap  CDC is a change data capture tool for TiDB
client          pingcap  Client to connect playground
cluster         pingcap  Deploy a TiDB cluster for production
ctl             pingcap  TiDB controller suite
dm              pingcap  Data Migration Platform manager
dmctl           pingcap  dmctl component of Data Migration Platform
errdoc          pingcap  Document about TiDB errors
pd-recover      pingcap  PD Recover is a disaster recovery tool of PD, used to recover the PD cluster which cannot start or provide services normally
playground      pingcap  Bootstrap a local TiDB cluster for fun
tidb            pingcap  TiDB is an open source distributed HTAP database compatible with the MySQL protocol
tidb-lightning  pingcap  TiDB Lightning is a tool used for fast full import of large amounts of data into a TiDB cluster
tiup            pingcap  TiUP is a command-line component management tool that can help to download and install TiDB platform components to the local system
```

Choose the components to install:

```shell
tiup install dumpling tidb-lightning
```

> **Note:**
>
> To install a component of a specific version, use the `tiup install <component>[:version]` command.

### Step 3. Update TiUP and its components (optional)

It is recommended to see the release log and compatibility notes of the new version.

```shell
tiup update --self && tiup update dm
```

## See also

- [Deploy TiUP offline](/production-deployment-using-tiup.md#deploy-tiup-offline)
- [Download and install tools in binary](/download-ecosystem-tools.md)


text:
# Using fonts

You can render font faces either directly on EGL surfaces as bitmap fonts, or
using vector outlines on OpenVG surfaces. Before you can render text, you will
need to load fonts from either a file or from a folder which may contain many
font faces.

Create a font object using the following code:

```
  // Create a set of font faces
  fonts, err := gopi.Open(rpi.VGFont{
    PPI: 72
  }, logger)
  if err != nil { /* Handle error */ }
  defer fonts.Close()
```

When opening a `VGFont` instance, you should supply a PPI parameter which is
the density of pixels of your display in pixels per inch (PPI). If you set
this value to zero or omit it, then fonts will be sized in pixels rather than
points.

## Loading font faces from a file

You can then load fonts either individually or in a folder.  There may be further faces within
the file. You can determine the number of faces within the file using the method
`GetNumFaces()`. For example,

```
   if face.GetNumFaces() > 0 {
      face, err := fonts.OpenFaceAtIndex(path,1)
      if err != nil { /* Handle error */ }
      defer fonts.DestroyFace(face)
   }
```

You can query the font families which have been loaded using the `GetFamilies()`
method and return a set of faces for one family using the `GetFaces()` method.
For example,

```
  for _, family := range fonts.GetFamilies() {
    for _, face := range fonts.GetFaces(family,khronos.VG_FONT_STYLE_ANY) {
	  // Do something with the face here
	}
  }
```

The `GetFaces()` method allows for one of the following flags:

  * khronos.VG_FONT_STYLE_ANY
  * khronos.VG_FONT_STYLE_BOLDITALIC
  * khronos.VG_FONT_STYLE_BOLD
  * khronos.VG_FONT_STYLE_ITALIC

## Loading font faces from a folder

You can use the method `OpenFacesAtPath` to load several font files at once,
for example from a folder. In order to use this, you need to implement a callback
function which can return true (to continue examining files and folders) or
false (to ignore a file or folder). For example,

```
  err := this.Fonts.OpenFacesAtPath(path, func(filename string, info os.FileInfo) bool {
    if strings.HasPrefix(info.Name(), ".") {
      // ignore hidden files and folders
      return false
    }
	if info.IsDir() {
      // recurse into folders
	  return true
	}
	if path.Ext(filename) == ".ttf" || path.Ext(filename) == ".TTF" {
	  // support TTF loading
	  return true
	}
	return false
  })
  if err != nil { /* handle error */ }
```

## Rendering text onto bitmap surfaces

You can render fonts directly onto bitmap surfaces. In order to do this,
use the `PaintText` method of a `khronos.EGLBitmap`. For example,

```
  surface := egl.CreateBackground("DX",1.0)
  surface.bitmap.PaintText("Hello, World!",face,khronos.EGLWhiteColor,surface.GetFrame().BottomLeft(),72.0)
```

The origin argument is the baseline of the text, so painting is both above and
below the origin, where the text has characters with descenders (for example,
"p" and "q").

## Rendering text onto OpenVG surfaces

TODO

## Examples

There are two examples in the [examples](https://github.com/djthorpe/gopi/tree/master/examples/vgfont)
folder.

  * `font_example.go` demonstrates how to load fonts and query which fonts are loaded.
  * `dx_example.go` demonstrates how to render text on bitmap surfaces.

For example,

```
  gopi% dx_example -fontpath etc/fonts -font Roboto -size 72
```

repository: CodeLingoBot/gopi

repo_name: CodeLingoBot/gopi


text:
# NI LabVIEW CLI - VIPM Operations Add-On
This add-on adds the following VIPM operations to the [NI LabVIEW Command Line Interface](http://www.ni.com/en-us/support/downloads/software-products/download.ni-labview-command-line-interface.html "NI LabVIEW CLI download"). This add-on supports LabVIEW 2014 or later.
* VIPM Install Package File
* VIPM Uninstall Package

## How to install
1. Install the [NI LabVIEW Command Line Interface](http://www.ni.com/en-us/support/downloads/software-products/download.ni-labview-command-line-interface.html "NI LabVIEW CLI download").
Note: LabVIEW 2018 or later automatically install the NI LabVIEW CLI.  However, you can also download and install it separately, and it supports LabVIEW 2014 or later.
2. Install the "NI LabVIEW Command Line Interface - VIPM Operations" add-on by downloading/installing the latest package (.nipkg) in the [Exports](https://github.com/allenh-ni/ni-labview-cli-custom-operations/tree/master/Exports) folder.
3. Install the [JKI VIPM API](http://sine.ni.com/nips/cds/view/p/lang/en/nid/210804) and [OpenG Libraries](http://sine.ni.com/nips/cds/view/p/lang/en/nid/209027) in all versions of LabVIEW you want to support. **Note:** The JKI VIPM API requires the paid VIPM Pro license.

## How to use
Run the following commands from the command-line interface.

### VIPMInstallPackageFile
`LabVIEWCLI -OperationName VIPMInstallPackageFile -PackagePath <path of VIPM package file (.vip)> -LabVIEWVersion <labview version string>`

-PackagePath : Specifies the path to the VIPM package file (.vip) to install

-LabVIEWVersion : Specifies the version of LabVIEW to install the VIPM package to (e.g. "17.0", "17.0 (64-bit)", "18.0", "18.0 (64-bit)", ...)

### VIPMUninstallPackage
`LabVIEWCLI -OperationName VIPMUninstallPackage -PackageName <package name> -LabVIEWVersion <labview version string>`

-PackageName: Specifies the name of the VIPM package to install (e.g. package_abc_api-<IP_ADDRESS>)

-LabVIEWVersion : Specifies the version of LabVIEW to uninstall the VIPM package from (e.g. "17.0", "17.0 (64-bit)", "18.0", "18.0 (64-bit)", ...)

## Reference
For more information on how to create/install custom NI LabVIEW CLI operations, refer to this [help topic](http://zone.ni.com/reference/en-XX/help/371361R-01/lvhowto/cli_creating_operations/ "Creating Custom NI LabVIEW CLI Operations").


text:
# New template

## Sidebar

In order to have sidebar, then you can create your own `_sidebar.md` (see _sidebar.md) for an example):

First, you need to set `loadSidebar` to **true**. Details are available in the [configuration paragraph](options.md).

repository: xdan/docium

repo_name: xdan/docium


text:
# Remote containers for VSCode

Installing the `Remote - Containers` VSCode extension
will allow you to open a project inside the `leanprovercommunity/mathlib` container
(meaning you don't even need a local copy of lean installed).

The file `/.devcontainer/devcontainer.json` sets this up:
if you have the extension installed, you'll be prompted to ask if you'd like to run inside the
container, no configuration necessary.

See `/.docker/README.md` for a description of the `leanprovercommunity/mathlib` container.

repository: leanprover-community/mathlib

gha_language: Lean

repo_name: leanprover-community/mathlib


text:
# Titan Control Center - Visualization Frontend

The [Titan Control Center](https://doi.org/10.1016/j.simpa.2020.100050)
is a scalable monitoring infrastructure for [Industrial DevOps](https://industrial-devops.org/).
It allows to monitor, analyze and visualize the electrical power consumption of
devices and machines in industrial production environments.

This repository contains the visualization frontend of the Titan Control Center. It is a
single-page application written in Typescript and Vue.js.

## Developing

To work on this project, clone this repository and execute:

```shell
npm install
```

In order to start a development server running on `http://localhost:8070` execute:

```shell
npm run serve
```

A good tool for working on this software is [Visual Studio Code](https://code.visualstudio.com/).
In order to get things like autocompletion for `.vue` files, you need to install
the [vetur](https://vuejs.github.io/vetur/) plugin. When you open a vue file the
first time, Visual Studio Code suggests to install this plugin. Further, the
[ESLint](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint)
plugin should be installed to get notifications on violated coding guideline
already during developing.

The visualization frontend highly depends on external data sources, more
specifically, the other Titan CCP microservices. In order to let the frontend
access them, you need to start a reverse proxy that redirects all calls to
the other services. We provide such a reverse proxy as part of the frontend,
which can be started be started via:

```shell
docker run --rm --name titan-ccp-frontend --network host -e "SENSOR_MANAGEMENT_BASE_URL=http://<host>:<port>" -e "HISTORY_BASE_URL=http://<host>:<port>" -e "STATS_BASE_URL=http://<host>:<port>" -d industrialdevops/titan-ccp-frontend
```

Note: The application intended for development is running at port 8070, whereas a the
application running at port 8080 is the compiled one running in the Docker container.
If you want to build this reverse proxy by yourself, follow the steps described below.

## Building

To build the visualization frontend for use in production execute:

```shell
npm install
npm run build
```

This will create some files in `dist`. These files along with the `index.html`
can then be copied on a web server for productive usage.

This repository also contains a Dockerfile. Adjust the `nginx.conf` file accordingly
and run `docker build -t titan-ccp-frontend .` to create an image from it (after
building it with npm).

## Running

To start a container execute:

```shell
docker run --rm --name titan-ccp-frontend -p <port>:8080 -e "SENSOR_MANAGEMENT_BASE_URL=http://<host>:<port>" -e "HISTORY_BASE_URL=http://<host>:<port>" -e "STATS_BASE_URL=http://<host>:<port>" -d titan-ccp-frontend
```

## Reference

Please cite the Titan Control Center as follows:

> S. Henning, W. Hasselbring, *The Titan Control Center for Industrial DevOps analytics research*, Software Impacts 7 (2021), DOI: [10.1016/j.simpa.2020.100050](https://doi.org/10.1016/j.simpa.2020.100050).

BibTeX:

```bibtex
@article{Henning2021,
    title = {The Titan Control Center for Industrial DevOps analytics research},
    journal = {Software Impacts},
    volume = {7},
    pages = {100050},
    year = {2021},
    doi = {10.1016/j.simpa.2020.100050},
    author = {Sören Henning and Wilhelm Hasselbring},
}
```

repository: cau-se/titan-ccp-frontend

repo_name: cau-se/titan-ccp-frontend


text:
## A simple neural network module for relational reasoning
Module implemention from "[A simple neural network module for relational reasoning](https://arxiv.org/abs/1706.01427)"

In this paper we describe how to use Relation Networks (RNs) as a simple plug-and-play module to solve problems that fundamentally hinge on relational reasoning.

## Tutorial
Get [Tutorial](https://ne7ermore.github.io/post/relation-net/) if know Chinese

## Requirement
* python 3.7
* pytorch 1.0.0
* numpy 1.13.1

## DataBase
bAbI - bAbI is a pure text-based QA dataset. There are 20 tasks, each corresponding to a particular type of reasoning, such as deduction, induction, or counting.

## train

Step.1 - prepare corpus

```python
python3 corpus.py
```

Step.2 - Train data
```python
python3 train.py
```


text:
# Xmeme

# App Live on
https://xmemesstream.herokuapp.com/

## Project Description
A Meme Stream Page where users can post memes by providing their name, a caption for the meme and the URL for the meme image as input. The page retrieves and displays the latest 100 posted Memes (names + meme images + caption).

## Tech/framework used
This project is built using Django framework where users can post memes and view all of them. The api is built using django REST framework.

## Prerequisites
Run "install.sh" to deal with all the dependencies

## Serving the App
Run "server_run.sh" to get your backend server up and running

## Flows
1. Users will post Memes by providing these inputs

   -- Name of the person posting the meme

   --Caption for the Meme

   --URL of the Meme image

2. Users will view the latest 100 memes posted

  -- If they post a new meme, it will get listed. Note that these submitted memes will be shown one below the other.

  -- Each meme should display the name of the meme maker, the caption for the meme and the image pulled from the meme URL.

##  Project Overview
1. The backend shall be capable of receiving the posted meme inputs from the frontend and store them in a database.
2. The backend shall be capable of fetching the list of memes from the database and send them to the frontend.
3. The interaction between the frontend and backend shall be based on a REST API with support for the below 3 endpoints.
4. Endpoint to send a meme to the backend

  -- HTTP Method - POST

  -- Endpoint - /memes

  --Json Body contains these inputs:
    - name, url, caption

  --The backend should allocate a unique id for the meme and return it as a json response.

  --Example request:

  `curl --location --request POST 'http://localhost:8081/memes' --header 'Content-Type: application/json' --data '{"name": "varun kumar","caption": "Is this a meme ?","url":     "https://urlme.me/hello/typed_a_url/made_a_meme.jpg"}'`

Endpoint to fetch the latest 100 memes created from the backend
HTTP Method - GET
Endpoint - /memes
Error:
If there are no memes available, an empty array shall be returned.
Example request:

`curl --location --request GET 'http://localhost:8081/memes'`

Endpoint to specify a particular id (identifying the meme) to fetch a single Meme.
HTTP Method - GET
Endpoint - /memes/<id>
Error:
If a meme with that Id doesn’t exist, a 404 HTTP response code should be returned.
Example request:

`curl --location --request GET 'http://localhost:8081/memes/<id>'`

repository: aryanndhir/Xmeme

repo_name: aryanndhir/Xmeme


text:
# Chrome Release Cycle

[TOC]

## Overview

Chrome pushes a new stable version to the public every 6 weeks while
taking 7 weeks to stabilize the beta branch.

## Schedule

![Schedule](images/release_cycle.png)
* Feature freeze and branch point dates are fixed, but release dates may change
depending on the build quality.
* There would be some adjustment in the release schedule due to Chrome no
meeting weeks or holidays.

## Key Dates

### Feature Freeze

**2 weeks** before the branch point, the feature freeze is declared! Any feature
planned to launch with this milestone should be code-complete (its
implementation should be done) and enabled on Trunk/Canary so that the test team
can give initial feedback. By the feature freeze, all strings must be landed!

### Branch Point

**Every 6 weeks**, the latest canary is declared as the new milestone
stabilization branch with a number (used as the branch name) associated with it.
The feature enhancement should be completed by the branch point and all
ReleaseBlock-Beta bugs should be fixed. Avoid committing big and risky changes
close to the branch point!

### First Beta

**2 weeks** after the branch point, the first beta release is pushed. All
disabled tests associated with the release milestone should be completely
addressed. New beta builds are pushed weekly until the stable release.

### Stable Cut

The Thursday before the stable release date, the last build from the beta branch
is cut as the release build. All ReleaseBlock-Stable bugs should be fixed by the
stable cut, which consequently corresponds to the absolute last date a merge to
the release branch should be taken for inclusion in the initial stable release.
The stable cut will, unless there are exceptions, use the final beta as its
basis. For Chrome OS, the stable cut date may be different than the rest of
Chrome.

### Stable Release

**7 weeks** after the branch point a new major version is released. The
stable rollout is staged over time so that any issues can be detected early and
addressed before they reach all users. Each Chrome platform has a different
stable rollout plan and the schedule below can vary based on circumstances:

*  **Desktop**: Desktop consists of three main platforms, Windows, Mac, and
Linux. Linux is ramped up to 100% immediately. Mac and Windows follow a
staged rollout as follows:
    * 5% deployment ->15% deployment ->50% deployment ->100% deployment.
*  **Android**: Android releases both Chrome and WebView with each release, and
follows a pattern similar to:
    * 1% deployment -> 5% deployment -> 10% deployment -> 50% deployment
    -> 100% deployment.
*  **iOS**: iOS follows a phased release with no control over the following
rollout percentage schedule:
    * Day 1: 1% -> Day 2: 2% -> Day 3: 5% -> Day 4: 10% -> Day 5: 20%
    -> Day 6: 50% -> Day 7: 100%.

### Stable Refresh

A stable refresh is defined as a release of a new Chrome build outside of the
normal release schedule to fix critical bugs detected during the stable rollout.
Except for extremely critical issues (e.g. security or privacy escalations),
a Chrome stable refresh should not be pushed more than **2 weeks** after the
initial build has been released to the public. In this case, we should consider
punting any detected production issues to the next release.

## More Info

For more information, see these [guidelines for considering branch dates in project planning](../release_branch_guidance.md).

repository: Samsung/Castanets

repo_name: Samsung/Castanets


text:
# CRAZY ANAGRAMS

Crazy anagrams is a game where the player is given a randomly generated 9-letter string. The player is then given 25 seconds to find as many words as they can. They are given 1 point for each letter in the word they found (NOTE: Words can only be more than one letter). Have fun and check out the scoreboard for the top scores!

## How to install & play:

Download or clone the repository.
Run ‘bundle install’ to install the required gems.
Run 'ruby bin/run.rb'

License:

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


text:
# homebrew-fks

CLI binaries related to Kubernetes at Meltwater.

This [homebrew](https://brew.sh) tap is created for convenience. It ensures that the correct kubectl version is installed.

Current CLI binaries in this tap:

- dyff
- kubectl
- kops
- kustomize
- helm2
- helm3
- helmfile
- sops (installed with helm3 as a dependency)
- vals (installed with helm3 as a dependency)

To install a formula run:

```
brew install meltwater/fks/<FORMULA>
```

--

If you are interested in creating your own homebrew tap you can look [here](https://docs.brew.sh/Taps), [here](https://docs.brew.sh/How-to-Create-and-Maintain-a-Tap) and [here](https://medium.com/prodopsio/creating-homebrew-taps-for-private-internal-tools-c41363d58ab0).

repository: meltwater/homebrew-fks

gha_language: Ruby

repo_name: meltwater/homebrew-fks