text:
---
layout: post
title: Adventures with NetworkX
---
I was wanting to do some network analysis and stumbled upon this gem of a library! Well, any manipulation of any sort, you name it, Networkx has it!

In case you’re looking for automated tools that do stuff for you or if you’re too lazy to code, check out Gephi, its really cool(like really).

Otherwise Networkx is our Go-to guy(/girl! Calm down you people! :P )

I am no expert but here are some of the things that wowed me the first time I encountered them :

Brilliant support for Bipartite Graph : Networkx provides brilliant support of functions and iterators for Bipartite graphs. Even though there is no separate class for Bipartite graphs, but you could try out the following and witness the magic unfold :

<code> import networkx as nx

<code> from networkx.algorithms import bipartite

<code> X = nx.DiGraph()

<code> X.add_nodes_from(<list-of-nodes-Type-1>, bipartite = 0)

<code> X.add_nodes_from(<list-of-nodes-Type-2, bipartite = 1)

<code> """ If you don’t believe that the above 4 lines created a bipartite graph see for yourself """

<code> print(bipartite.is_bipartite(X))

Haha so now, all you need to do is add edges and visualize this graph using Matplotlib or any other great plotting library.

Random Graphs : If you’ve heard about the Preferential Attachment Model and the Small World Theory, you’ll know what I’m talking about. Networkx allows us to work with random models like Erdos Renyi, Barabasi Albert, Watts-Strogatz and many more. So, its great if you’d like to experiment with random graphs and models.
Network Statistics : From the usual network stats like Centrality, Clustering, Connectedness to complex ones like HITS, Adamic-Adar, Jaccard Coefficient, Page Rank etc; Networkx makes life easy for you!
Support for Classical Algorithms like Dijkstra, Minimum Spanning Tree, DFS, BFS and many more.

path: /_posts/2017-12-21-: Adventures with Networkx.md


text:
# Ping-Pong View

You can read [here](https://blog.kie.org/2020/10/kogito-tooling-examples-how-to-create-a-more-complex-custom-view.html) a step-by-step tutorial of how this custom View was built.

This package exposes the necessary files for you to create a Ping-Pong View Envelope with you own Ping-Pong View implementation.

It's divided in the following submodules:

1. `api`
   - Provides the APIs that the Channel/Envelope expose to each other.
1. `embedded`
   - Provides a convenience React component to embed a Ping-Pong View in a Web application.
1. `envelope`
   - Provides the necessary class for a Channel to create a Ping-Pong View Envelope.

repository: kiegroup/kogito-tooling-examples

branch_name: refs/heads/main

extension: md

gha_language: TypeScript

license_type: permissive

repo_name: kiegroup/kogito-tooling-examples


text:
# @dojo/loader
<!-- start-github-only -->

[![Build Status](https://travis-ci.org/dojo/loader.svg?branch=master)](https://travis-ci.org/dojo/loader)
[![codecov.io](http://codecov.io/github/dojo/loader/coverage.svg?branch=master)](http://codecov.io/github/dojo/loader?branch=master)
[![npm version](https://badge.fury.io/js/%40dojo%2Floader.svg)](https://badge.fury.io/js/%40dojo%2Floader)

This package provides a JavaScript AMD loader useful in applications running in either a web browser, node.js or nashorn.

`@dojo/loader` does not have any dependencies on a JavaScript framework.

- [Usage](#usage)
- [Support](#support)
- [Features](#features)
- [How do I contribute?](#how-do-i-contribute)
  - [Code Style](#code-style)
  - [Installation](#installation)
  - [Testing](#testing)
- [Licensing information](#licensing-information)

## Note
<!-- end-github-only -->

We strongly recommend using the `@dojo/cli` build tools for a Dojo 2 application over a runtime loader such as `@dojo/loader`.

## Usage

To use `@dojo/loader`, install the package:

```bash
npm install @dojo/loader
```

## Support

| Environment	| Version	|
|---------------|----------:|
| IE			| 10+		|
| Firefox		| 30+		|
| Chrome		| 30+		|
| Opera			| 15+		|
| Safari		| 8, 9		|
| Android		| 4.4+		|
| iOS			| 7+		|
| Node			| 0.12+		|
| Nashorn		| 1.8+		|

## Features

- AMD loading
- CJS loading (in a node environment)
- Plugins:
	- [text](https://github.com/dojo/core/blob/master/src/text.ts)
	- [has](https://github.com/dojo/core/blob/master/src/has.ts)
- Loading in a Nashorn environment

Use a script tag to import the loader. This will make `require` and `define` available in the global namespace.

``` html
<script<EMAIL_ADDRESS>```

The loader can load both AMD and CJS formatted modules.

There is no need to use the Dojo 1.x method of requiring node modules via `dojo/node!` plugin anymore.

## How do I contribute?

We appreciate your interest!  Please see the [Guidelines Repository](https://github.com/dojo/guidelines#readme) for the
Contributing Guidelines.

### Code Style

This repository uses [`prettier`](https://prettier.io/) for code styling rules and formatting. A pre-commit hook is installed automatically and configured to run `prettier` against all staged files as per the configuration in the project's `package.json`.

An additional npm script to run `prettier` (with write set to `true`) against all `src` and `test` project files is available by running:

```bash
npm run prettier
```

### Installation

To start working with this package, clone the repository and run `npm install`.

In order to build the project run `grunt dev` or `grunt dist`.

### Testing

Test cases MUST be written using Intern using the Object test interface and Assert assertion interface.

90% branch coverage MUST be provided for all code submitted to this repository, as reported by istanbul’s combined coverage results for all supported platforms.

## Licensing information

© 2004–2018 [JS Foundation](https://js.foundation/) & contributors. [New BSD](http://opensource.org/licenses/BSD-3-Clause) license.

<!-- doc-viewer-config
{
	"api": "docs/api.json"
}
-->

repository: dojo/loader

branch_name: refs/heads/master

gha_license_id: NOASSERTION

repo_name: dojo/loader


text:
# MS-101 Microsoft 365 Mobility and Security

## Resources
* [Pratice Exam](https://examtopics.com)
* [The New Certification tracks](https://query.prod.cms.rt.microsoft.com/cms/api/am/binary/RE2PjDI)
* [MS-101 on DDLS](https://www.ddls.com.au/courses/microsoft/office-365/microsoft-ms-101t00-microsoft-365-mobility-and-security/)
* [MS-101 Exam Details](https://www.microsoft.com/en-us/learning/exam-ms-101.aspx)
* [Out of Hours - Intune Stuff](https://oofhours.com/category/microsoft-intune/)
* [Common Passwords for Attack Simulator](https://github.com/jeanphorn/wordlist)
* [Enabling Sensitvity Labels](https://docs.microsoft.com/en-au/azure/active-directory/users-groups-roles/groups-assign-sensitivity-labels)
* [The Office 365 ATP Recommended Configuration Analyzer (ORCA)](https://github.com/cammurray/orca)
* [Cloud App Security Docs](https://docs.microsoft.com/en-us/cloud-app-security/)
* [Regular Expressions for Sensitive Info Types](https://regex101.com/)
* [Insider Risks](https://docs.microsoft.com/en-us/microsoft-365/compliance/insider-risk-management-policies?view=o365-worldwide)
* [Eliminate weak passwords on-premises](https://docs.microsoft.com/en-us/azure/active-directory/authentication/concept-password-ban-bad-on-premises)
* [Eliminate weak passwords in the cloud](https://docs.microsoft.com/en-us/azure/active-directory/authentication/concept-password-ban-bad)
* [Information Barriers](https://docs.microsoft.com/en-us/microsoft-365/compliance/information-barriers-policies)
* [Windows as a Service Resources](https://docs.microsoft.com/en-us/windows/deployment/update/waas-mobile-updates)
* [Cloud App Security Stuff](https://docs.microsoft.com/en-us/cloud-app-security/)
* [GitHub: Accessing Secure Score via the Graph API](https://github.com/OfficeDev/O365-Cloud-Sec-Tooling/blob/master/Securescore/README.md)
* [Related Document: Using the Office 365 Secure Score API](https://blogs.technet.microsoft.com/office365security/using-the-office-365-secure-score-api/)
* [Enabling Sensitvity Labels](https://docs.microsoft.com/en-au/azure/active-directory/users-groups-roles/groups-assign-sensitivity-labels)
* [The Office 365 ATP Recommended Configuration Analyzer (ORCA)](https://github.com/cammurray/orca)
* [Custom Sensitive Information Types](https://joannecklein.com/2018/08/07/build-and-use-custom-sensitive-information-types-in-office-365/)
* [Content Types and Search Schema](https://joannecklein.com/2018/09/12/content-type-filters-in-modern-sharepoint/)
* [SharePoint Content Types in DLP](https://joannecklein.com/2018/01/25/a-sharepoint-content-type-dlp-policy/)
* [Creating content types](https://sharegate.com/blog/sharepoint-content-types-understand-use-create) - please also research Hub Content Type
* [Nesting Group Limitations AAD](https://docs.microsoft.com/en-us/azure/active-directory/enterprise-users/directory-service-limits-restrictions)

## Videos & Other
* [**Demonstration: Sensitive information types - 5 minutes**](https://www.microsoft.com/videoplayer/embed/RE4yqxc)
* [**Demonstration: Trainable classifiers – 4 Minutes**](https://www.microsoft.com/videoplayer/embed/RE4yg7t)
* [Guided Demonstration - Trainable Classifiers](https://mslearn.cloudguides.com/en-us/guides/Protect%20sensitive%20data%20with%20Microsoft%20Information%20Protection)
* [**Guided demonstration: DLP policies for Microsoft Teams**](https://teams-dlp-interactive-guide.azureedge.net/)
* [**Video: Endpoint Data Loss Prevention (DLP) – What it is and how to set it up in Microsoft 365 8 minutes**](https://www.youtube.com/watch?v=XO2zMA3w1wA)
* [Learn about Microsoft 365 Endpoint data loss prevention](https://docs.microsoft.com/en-us/microsoft-365/compliance/endpoint-dlp-learn-about?view=o365-worldwide)
* [Get started with Endpoint data loss prevention](https://docs.microsoft.com/en-us/microsoft-365/compliance/endpoint-dlp-getting-started?view=o365-worldwide)
* [Using Endpoint data loss prevention](https://docs.microsoft.com/en-us/microsoft-365/compliance/endpoint-dlp-using?view=o365-worldwide)
* [Onboarding tools and methods for Windows 10 devices](https://docs.microsoft.com/en-us/microsoft-365/compliance/dlp-configure-endpoints?view=o365-worldwide)
* [**Guided demonstration: Endpoint DLP 30 Mins**](https://ms-endpoint-dlp.azureedge.net/)

## Cloud App Security
* [Cloud App Security Guided Demonstration](https://mslearn.cloudguides.com/en-us/guides/Discover,%20protect,%20and%20control%20your%20apps%20with%20Microsoft%20Cloud%20App%20Security)
* [Combining Cloud App Security with Conditional Access](https://youtu.be/1K66pDwzaf0)
* [Cloud App Security to Protect File downloads to non managed devices](https://youtu.be/vD9C9jwDuv4)
* [Cloud App Security](https://youtu.be/DyUmFWfJQvU)
* [Wizarding World of cloud App Security](https://youtu.be/TLm6F0pKT7E)
* [Conditional Access App Control with CAS](https://youtu.be/CvsjM8TX81c)
* [Session Policy in CAS](https://youtu.be/hPW3E51cIac)
* [Block Uploads in CAS](https://youtu.be/nGg2XyQWJ4o)

## Cloud App Security Training Material
* [Microsoft Cloud App Security Demo Lab](https://docs.microsoft.com/en-us/cloud-app-security/getting-started-with-cloud-app-security)
* [The Microsoft Cloud App Security (MCAS) Ninja Training (March 2021 Update)](https://techcommunity.microsoft.com/t5/security-compliance-and-identity/the-microsoft-cloud-app-security-mcas-ninja-training-march-2021/ba-p/1877343)

## Defender
* [Defender for Identity -Advanced Threat Protection (Domain Controllers)](https://youtu.be/EGY2m8yU_KE)
* [Microsoft Threat Protection](https://docs.microsoft.com/en-us/learn/paths/m365-security-threat-protection)
* [Defender for Identity (Domain Controllers)](https://youtu.be/EGY2m8yU_KE)
* [Defender for Identity Set up](https://www.youtube.com/watch?v=rMHNJb2IXJ0&t=226s)
* [Configuring Defender for Identity](https://youtu.be/rMHNJb2IXJ0?t=229)
* [Windows defender Advanced Threat Protection](https://youtu.be/qxeGa3pxIwg)
* [Defender for EndPoint Advanced Threat Protection – Windows 10 etc](https://youtu.be/HkQZR9RBbPE)
* [Windows Defender Application Control](https://youtu.be/J7fSeYEftRE)
* [Defender for Endpoint Evaluation Demo](https://docs.microsoft.com/en-us/microsoft-365/security/defender-endpoint/evaluation-lab?view=o365-worldwide)
* [Advanced Threat Hund Defender for Endpoint](https://youtu.be/4NQphnL0YR8)
* [Defender for Endpoint Resources](https://techcommunity.microsoft.com/t5/microsoft-defender-for-endpoint/become-a-microsoft-defender-for-endpoint-ninja/ba-p/1515647
)
* [Defender for Endpoint as a StandAlone Licence](https://www.infusedinnovations.com/blog/secure-intelligent-workplace/microsoft-defender-atp-standalone-is-now-available
)
* [Defender for Endpont Ninja Training](https://techcommunity.microsoft.com/t5/microsoft-defender-for-endpoint/become-a-microsoft-defender-for-endpoint-ninja/ba-p/1515647)
* [Application Guard](https://www.youtube.com/watch?v=J7fSeYEftRE)
* [Application Guard 2](https://youtu.be/J7fSeYEftRE)
* [Exploit Guard](https://youtu.be/pnaYdBP35dc)
* [Defender for Endpoint Deployment Guide](https://youtu.be/gx9jnG5tZmM)

## EDiscovery
* [Advanced eDiscovery Analytics Solutions: How to Efficiently Organize and Reduce Data for Review](https://youtu.be/dgkLkxX_YrE)
* [EDiscovery Channel - Everything!](https://www.youtube.com/channel/UCFJbJglx-or89yg9RanFTQg/videos)
* [Do more with Advanced EDiscovery](https://youtu.be/-25S-Vz7u1Q)
* [New Guide Adv EDiscovery - Use Chrome](https://content.cloudguides.com/en-us/guides/Advanced%20eDiscovery)

## EndPoint Mgr/Intune
* [Transfer Config Manager WorkLoads to Intune](https://www.anoopcnair.com/sccm-co-management-configuration-8/)
* [Co-Management](https://youtu.be/0jsNNrQNqog)
* [Windows UpGrade Logs](https://youtu.be/O91NLxyEHY8)
* [Config Client Roll Out](https://youtu.be/bHWRBaaVCPg)
* [Pre-Provisioned](https://youtu.be/nE5XSOBV0rI)
* [Intune Training Videos -YouTube Channel](https://www.youtube.com/channel/UCfmMlhX5TW8cicxHw6ExYVA)
* [Add apps to Microsoft Intune](https://learn.microsoft.com/en-us/mem/intune/apps/apps-add)
* [Deploy Apps](https://www.youtube.com/watch?v=FGZ7hrVBSE4)
* [Intune app installation error reference](https://learn.microsoft.com/en-us/troubleshoot/mem/intune/app-management/app-install-error-codes)

## Enrolling Apple
* [Enrolling Apple Devices](https://www.bing.com/videos/search?view=detail&mid=B95025DB56689F135BB7B95025DB56689F135BB7&q=apple&shtp=GetUrl&shid=84d5fb5c-0d12-4f19-bbb3-1d0502dd896c&shtk=SG93IFRvIEF1dG9tYXRpY2FsbHkgRW5yb2xsIEFwcGxlIERldmljZXMgaW4gSW50dW5l&shdk=TW9kZWwgY29uc3VsdGFudCBBbXkgWml0dGEgc2hvd3Mgc3RlcC1ieS1zdGVwIGhvdyB0byBlbnJvbGwgZXhpc3RpbmcgQXBwbGUgZGV2aWNlcyBpbnRvIE1pY3Jvc29mdCBJbnR1bmUgZm9yIGEgbW9yZSBjZW50cmFsaXplZCBtYW5hZ2VtZW50IGV4cGVyaWVuY2UgYW5kIGltcHJvdmVkIGVmZmljaWVuY3ku&shhk=ckKfmGPNddBeAEqj%2FpEQHafLPKKcwQ%2FQQMp8XspN1zo%3D&form=VDSHOT&shth=OVP.bbuBoPcqmkIUObGUvM0BOgEsCo)
* [Apple DEP Process](https://docs.microsoft.com/en-us/mem/intune/enrollment/device-enrollment-program-enroll-ios#:~:text=You%20can%20set%20up%20Intune%20to%20enroll%20iOS%2FiPadOS,and%20MacBooks%20can%20be%20shipped%20directly%20to%20users.?msclkid=1f665c5eb61911ec9d727a07fe726ccd)
* [IOS/iPadOS deviceEnrllment](https://youtu.be/gIQruL22G_Q?t=146)
* [Apple Business Manager](https://youtu.be/rihqfkkaHLQ?t=87)
* [Connecting Apple Business Manager with InTune](https://youtu.be/VHEy621jhHs?t=145)

##  Microsoft Sentinel
* [Microsoft Sentinel-Quick Start](https://youtu.be/p2BK8SAUGG0)
* [Microsoft Sentinel Setup & Config](https://youtu.be/Cyd16wVwxZc)
## AutoPilot
* [Demostrate Autopilot deployment](https://learn.microsoft.com/en-us/windows/deployment/windows-autopilot/demonstrate-deployment-on-vm?source=recommendations)
* [AutoPilot Walkthrough](https://youtu.be/KYVptkpsOqs)
* [Windows AutoPilot](https://youtu.be/4K4hC5NchbE)
* [Windows AutoPilot through Business Store](https://www.microsoft.com/en-us/videoplayer/embed/3b30f2c2-a3e2-4778-aa92-f65dbc3ecf54?autoplay=false)
## Other
* [Seamless Single Sign On - PTA](https://youtu.be/PyeAC85Gm7w)
* [Azure Analytics](https://youtu.be/T2Vpi6ph8ck)
* [Windows Analytics](https://youtu.be/4Kb78NmfV6E)
* [Regular Expressions](https://youtu.be/sa-TUpSx1JA)
* [Information Barriers](https://youtu.be/461LfU06RbA?t=416)
* [Phishing](https://youtu.be/MCYC8kV1mmc)
* [Secure Score](https://youtu.be/jzfpDJ9Kg-A)
* [Secure score API (JSON)](https://youtu.be/vg3QKQWVD6Y)
* [Microsoft Graph](https://youtu.be/PI9NO5rayiY)
* [Compliance Manager Demo](https://youtu.be/r1vs8NdSXKQ?list=PLXPr7gfUMmKyMW5RRW9kmLjX31OTwqhf5)

license: MIT

repository: DDLSTraining/Engage

gha_language: PowerShell

gha_license_id: MIT

repo_name: DDLSTraining/Engage


text:
## Most important rule: All commits must be made in **dev** branch.
Other than that, the guidelines stated below are very lax and you can start contributing in no time

## Features and UI/UX Changes
Elder Launcher focuses on **Legibility** and **Simplicity**. All new features and visual changes must adhere to this.

Before working on any new major features or changing the appearance of the app, please post about in the relevant section of the project's Github Discussions [page](https://github.com/itsarjunsinh/elder_launcher/discussions). This is to ensure your work aligns with the vision of the project.

## Translations
Adding new translations or improving existing translations is hugely beneficial. However, please send separate PRs for translation changes.
ie. Do not include them with PRs bugfix/feature/UI changes.

❌ Commit: Added Welsh; Fixed (some bug)

❌ Commit: Added Welsh; Added (some feature)

✔ Commit: Added Welsh

## Code Quality
Follow existing indentation pattern of the project. If your commits don't reflect this, then your PRs will not be accepted.

> *Code styling guidelines will be added in the future.*


text:
# User Directory

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Deployed Application: https://dchiev.github.io/User-Directory/

GitHub Repo: https://github.com/dchiev/User-Directory

## Description

This application shows all of your users in one table.

## Table of Contents

\*[Installation](#installation)

\*[Usage](#usage)

\*[License](#license)

\*[Contributing](#contributing)

\*[Tests](#tests)

\*[Questions](#questions)

# Installation

To install necessary dependencies, run the following command:

npm install

## Usage

This is a react app. Make sure to take a look at the src directory for all components

## License

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Contributing

Make sure to give descriptive commits.

## Tests

To run tests, run the following command:

N/A

## Questions

If you have any questions about the repo, contact me directly at npm install react-bootstrap bootstrap. You can find more of my work at [github.com/Dchiev](github.com/Dchiev)

repository: dchiev/User-Directory

repo_name: dchiev/User-Directory


text:
---
title: "Stitching SLATE Clusters on Chameleon"
overview: "A guide to spinning up stitched SLATE clusters on two different Chameleon sites."
published: true
permalink: blog/chameleon-stitched-clusters.html
attribution: The SLATE Team
layout: post
type: markdown
tag: draft
---

Chameleon is an OpenStack-based research platform for provisioning compute and networking resources.
Chameleon has the capability to create a virtual LAN with hosts stitched over two geographically disparate sites.
In this blog post, we demonstrate how to setup two SLATE clusters at separate sites, stitched together with a VLAN.
We will also run various tests to determine network performance over this stitched link.

For a more basic SLATE-on-Chameleon setup, please see the [Deploying a SLATE Cluster on Chameleon](https://slateci.io/blog/slate-on-chameleon.html) blog post. If you have no experience with Chameleon, we recommend that you read through and follow this blog post first to familiarize yourself with the platform.

<!--end_excerpt-->

## Requirements

To run a SLATE cluster on [Chameleon](https://www.chameleoncloud.org/), you must first have access to a Chameleon account, as well as be on an existing Chameleon project.
The [Chameleon Getting Started Guide](https://chameleoncloud.readthedocs.io/en/latest/getting-started/index.html) contains lots of useful information regarding this.
Other helpful Chameleon documentation includes [this page](https://chameleoncloud.readthedocs.io/en/latest/technical/networks/networks_stitching.html#connecting-stitchable-isolated-networks-across-chameleon-sites) on network stitching.

Additionally, you must have a SLATE account with an access token.

### Chameleon Blazar Client

Due to Chameleon limitations, a stitched network can only be created with the OpenStack CLI.
Install the OpenStack/Chameleon Blazar client for creating leases.
It can be downloaded with the following command:
```bash
pip install git+https://github.com/ChameleonCloud/python-blazarclient.git
```
{:data-add-copy-button='true'}
It is important to be aware of different client versions, as Chameleon expects version `2.2.2` to be used.

### Application Credential

You must also have an unrestricted application credential for both Chameleon sites, ["CHI@UC"](https://chi.tacc.chameleoncloud.org/project/) and ["CHI@TACC"](https://chi.uc.chameleoncloud.org/project/).

To do this, log into the first site's portal.
1. In the left sidebar, navigate to the "Identity" tab, and click "Application Credentials".
1. Then, click "Create Application Credential", fill out the name field, and check the "Unrestricted" box.
1. Click "Create Application Credential" again, and download the `openrc` file somewhere safe.

Then, repeat these steps for the other site.

## Chameleon Setup

### Network Lease

A stitch-able network lease must be created at each Chameleon site.
First, authenticate with a Chameleon site by running this command:
```bash
source /path/to/openrc.sh
```
{:data-add-copy-button='true'}
This `openrc.sh` file is the application credential you created earlier.
You should have one for each site.

Then, use the following command to create a network lease:
```bash
`blazar lease-create --reservation resource_type=network,network_name=<network_name_here>,resource_properties='["==","$physical_network","exogeni"]' --start-date <start_date> --end-date "<end_date>" <lease_name>`
```
{:data-add-copy-button='true'}
Note that the start and end date parameters must include a time as well.
The time and date should be specified with the following format:
```bash
"YYYY-MM-DD HH:MM"
```
The time zone is UTC, and a 24-hour clock should be used.
Additionally, the network lease command needs to have a start time later than the current time, and an end time no later than 7 days after the start time.
Note that the networks we will create are only going to be active during the time the lease is active, so ensure you have allocated sufficient time.

Repeat these steps for the other Chameleon site.
Note that these networks or leases cannot be named the same thing.

Once the leases have instantiated correctly, a network will automatically be created at each site.
This can be verified on the online portal, using the "Networks" tab.

Once both networks are up, a ticket will need to be submitted to the [Chameleon help desk](https://www.chameleoncloud.org/user/help/).
This ticket should request the creation of an AL2S circuit between the sites, and should specify the Project ID, network name, and network ID of each network.
This information can be found by clicking on each network name.
Additionally, the lifetime of the stitched network should also be specified.
Set this lifetime to be the same as the lifetime of your network leases.
This circuit will enable our hosts at different physical sites to talk to each other as if they were on the same LAN.

Submit a ticket containing this information, and wait for it to be approved.

### Network Setup

#### Create a router

Next, a router must be created to serve as a default gateway for our instances to access the rest of the internet.

1. Login to one of the Chameleon portals.
1. Navigate to the "Routers" section under the "Network" tab on the left sidebar.
1. Then, on the right-hand side, click the "Create Router" button.
1. Next, name this router. We like to use `slate-router`.
1. Click the external network drop-down menu, and select "public".
1. Leave everything else as-is, and click "Create Router".
1. Repeat these steps for the other Chameleon site.

#### Create a subnet

Next, we will create a subnet under our existing network.

1. Login to one of the Chameleon portals.
1. Navigate to the left sidebar and select "Network", then select "Networks" underneath this.
1. Locate the network that was already created for you, and click the drop down menu next to your network on the right side.
1. From the drop down menu, select "Create Subnet".
1. The only value that needs to be changed here is the "Network Address" parameter (no subnet name is needed). Use `<IP_ADDRESS>/24` for the network address.
1. Following this, click "Next" again. You will be brought to the "Subnet Details" section. Leave this as-is, and click "Create".
1. Repeat these steps on the other Chameleon site/portal.

If you would like to learn more about networks in Chameleon, more information can be found in the [Chameleon documentation](https://chameleoncloud.readthedocs.io/en/latest/technical/networks.html).

#### Connect your router to your new network

Here, we will connect the router object we made to our custom network.

1. Login to one of the Chameleon portals.
1. Navigate back to the "Routers" section under the "Network" tab on the left sidebar.
1. Click on the name of the router you created earlier (most likely called `slate-router`).
1. Select the "Interfaces" tab, and then click "Add Interface"
1. Under the "Subnet" drop-down menu, select the network that was created earlier.
1. Leave everything else as-is, and click "Submit".
1. Repeat these steps on the other Chameleon site/portal.

### Instance Setup

Now, we need to launch two compute nodes, on the subnets that we already created.
More detailed instructions regarding creating instances and associating IP addresses can be found in the [Getting Started Guide](https://chameleoncloud.readthedocs.io/en/latest/getting-started/index.html).

#### Launch Instances

1. First, login to one of the Chameleon portals.
1. Click the "Reservations" tab on the left side, and select the "Leases" menu underneath it.
1. Click "Create Lease", and configure a lease for as much time as you need.
1. In the lease-creation box, switch to the "Hosts" tab, and check the "Reserve Hosts" box.
1. Set the minimum and maximum number of hosts to 1.
1. Set the node type property to `compute_haswell` or `compute_skylake`.
1. Click through the remainder of the lease creation wizard, until a reservation is created.
1. Next, navigate to the "Instances" page under the "Compute" menu on the left-hand side.
1. Then, on the right side of the page, click the "Launch Instance" button.
1. Under the "Details" tab, give this instance a name (we like `slate-instance`). Additionally, select the reservation that was previously created.
1. Under the "Source" tab, select "Image" under the "Select Boot Source" drop-down menu. Then, select the `CC-CentOS7` image.
1. Under the "Networks" tab, make sure that the only network that is selected is our new network.
1. Under the "Key Pair" tab, make sure you have configured the correct SSH keys. This is explained in more detail in [this documentation](https://chameleoncloud.readthedocs.io/en/latest/getting-started/index.html#getting-started).
1. Click the "Launch Instance" button, and wait for the instance to spin up. This may take 5 to 10 minutes.
1. Repeat these steps for the other site.

#### Associate Public IP and Log In

To access our instance, we need to NAT a floating public IP to our instance.
1. First, login to one Chameleon portal.
1. Next, go to the "Network" tab on the left and select "Floating IPs".
1. Click the "Allocate IP to Project" button located on the right side.
1. Leave the default settings and click "Allocate IP".
1. Once an IP address has been allocated, click the "Associate" button to the right of the IP address.
1. From the "Port to be Associated" menu, select the instance you created earlier.
1. Click "Associate"
1. Repeat for the other instance on the other Chameleon site.

For more information regarding associating floating IP addresses, visit the [Chameleon Getting Started Guide](https://chameleoncloud.readthedocs.io/en/latest/getting-started/index.html).

To login to any Chameleon node, log in as user `cc`, with `ssh cc@<PUBLIC_INSTANCE_IP>`.
The public instance IP is the floating public IP that we assigned earlier.
This user should have password-less `sudo` access.

#### Disable Firewall

Before you go any further, make sure any firewalls are disabled, as they will impact cluster creation.
On Chameleon, `ufw` is often running, even on CentOS.
Disable it with `sudo ufw disable`.

#### Assign Cluster Hostnames

Our testing software, perfSONAR, requires a DNS name, not an IP address.
To get around this, we are simply going to edit the `/etc/hosts` file on both of our clusters.
Open this file on both nodes, and append the following lines:
```bash
<node_1_internal_ip> cluster1.slateci.net
<node_2_internal_ip> cluster2.slateci.net
```
{:data-add-copy-button='true'}
The internal IP of each node can be found from each node's respective web portal.
These IPs will be assigned from the `<IP_ADDRESS>/24` subnet that we created earlier.

## Testing

### Test Basic Connectivity

First, use the ping command on each node to reach the other node.

From the first cluster, run: `ping cluster2.slateci.net`.

From the second cluster, run: `ping cluster1.slateci.net`.

If these ping commands succeed, we have successfully stitched the two Chameleon sites together!

### Testing with iPerf

Next, as a preliminary method of verifying throughput, `iperf` can be used.
If `iperf` is not already installed, it can be installed with:
```bash
sudo yum install iperf
```
{:data-add-copy-button='true'}
Note that both nodes will need to have `iperf` installed.

Afterwards, run an iPerf server on the first node with this command:
```bash
iperf -s
```
{:data-add-copy-button='true'}
Then, run the iPerf client on the second node and connect to the server on the first node with this command:
```bash
iperf -c <node_1_internal_ip>
```
{:data-add-copy-button='true'}
After a little while, the test will complete, and you should see bandwidth results.
If desired, you can run this test in reverse by swapping the locations of the client and server.
Alternately, iPerf's `-r` or `-d` options can be used for running bi-directional tests.

### Testing with perfSONAR

The `perfsonar-testpoint` application can be installed with its default values.
Do this with the following command wherever you have the slate client available:
```bash
slate app install perfsonar-testpoint --cluster <cluster_2> --group <your_group>
```
{:data-add-copy-button='true'}

The `perfsonar-checker` application will require a small amount of configuration.
First, to fetch its configuration file, run:
```bash
slate app get-conf --dev perfsonar-checker > perfsonar-checker.conf
```
{:data-add-copy-button='true'}
Navigate to the `Instance` section, and give your application an appropriate instance tag.
Next, navigate to the `PerfsonarChecker` section, and change the `Dest1` parameter to the appropriate hostname that was set up earlier in `/etc/hosts/`.
The `Dest2` and `Dest3` values can be commented out, or left as-is, if you would also like to run tests to those endpoints.

Now, we are ready to install this application with this command:
```bash
slate app install --dev perfsonar-checker --cluster <cluster_1> --group <your_group> --conf perfsonar-checker.conf
```
{:data-add-copy-button='true'}
After the application finishes installing, an instance ID will be printed out.
Take note of this ID.
Then, give the application some time to run, and check the results with this command:
```bash
slate instance logs --max-lines 0 <perfsonar_checker_instance_id>
```
{:data-add-copy-button='true'}
More information about perfSONAR and the expected results can be found in the [PerfSONAR Checker Blog Post](https://slateci.io/blog/perfsonar-checker.html).

## Other Testbeds

Similar setups can be created on other testbeds as well.
The testing methods outlined in the post will also work on other testbeds.
Additionally, the SLATE Nginx application (without ingress controller) can be used to test.
Host an Nginx instance on both nodes, and access each instance from the opposing node over NodePort using `curl`.

CloudLab-to-CloudLab setups have been verified to work, as well as GENI-to-Chameleon@UC.

More documentation about stitching networks between Chameleon and other testbeds/external domains can be found in the [Chameleon documentation](https://chameleoncloud.readthedocs.io/en/latest/technical/networks/networks_stitching.html#connecting-stitchable-isolated-networks-across-chameleon-sites).

## Contact Us

If you have any additional comments or questions, please contact [our team](https://slateci.io/community/)!

gha_language: JavaScript


text:
# SAML certificate management in Gluu Server

SAML Certificate is being used for SAML protocol based SSO.
Generally this is a self signed certificate with longer validity ( 1 year to 10
years ).

In order to get this feature: Configuration --> Manage Certificates.

![Image](https://raw.githubusercontent.com/GluuFederation/docs/master/sources/img/oxTrustConfiguration/Manage_SSL_cert.png?raw=true)

Gluu Server Administrator need to use both private key and certificate to
update the SAML cert. Use "DA..-SHIB.crt" section (the lower box) of "Manage
server SSL certificates"  to perform this operation.

Private key cannot be password protected and certificate should be base64 with
"crt" extension.

Upload the private key and public certificate with "Upload Key" and "Upload
Cert" button respectively. Update the configuration and wait for 10 mins. Our
configuration management system ( Puppet ) will perform the rest of the
operation to configure certificate inside IDP.


text:
## Power observatory Mexico update nodes-load_zones location script
This file describes the near real-time script that retrieves and processes the [Local Marginal Prices datasets]() for display on Resource Watch as the following datasets:

* [Mexico Energy Local Marginal Prices ](https://bit.ly/3tjnuF8)
* [Mexico Energy Load assigned ](https://bit.ly/3N347bt)

This dataset was provided by the source as an excel file. The excel file was transformed into a table and the resulting tables were then uploaded to Carto. One table holds the node level data and the other the load zones data.

This script fetches the location of the nodes and load zones in Mexico.

Please see the [Python script](https://github.com/resource-watch/nrt-scripts/blob/master/loc_mxene_mexico_nodes_catalog/contents/src/__init__.py) for more details on this processing.

**Schedule**

This script is run daily. The exact time that the script is run to update the dataset can be found in the the `time.cron` file. This time is in Coordinated Universal Time (UTC), expressed in cron format.

###### Note: This script was adapted to NRT form by [Eduardo Castillero Reyes](https://wrimexico.org/profile/eduardo-castillero-reyes) based on scripts developed by an external consultant.

repository: resource-watch/nrt-scripts

gha_language: Python

repo_name: resource-watch/nrt-scripts


text:
OpenGamma Build-Config
----------------------
This is configuration used to support maven builds.

The recommended approach to share checkstyle configuration between projects is to use a jar like this.
Other configuration, such as for PMD or FindBugs, could be added into the jar.

This project is released as Open Source Software under the
[Apache v2.0 license](http://www.apache.org/licenses/LICENSE-2.0.html).

[![OpenGamma](http://developers.opengamma.com/res/display/default/chrome/masthead_logo.png "OpenGamma")](http://developers.opengamma.com)

repository: jaydenwhyte/OG-Tools

repo_name: jaydenwhyte/OG-Tools


text:
# nr-email-microservice [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE) [![img](https://img.shields.io/badge/Lifecycle-Retired-d45500)](https://github.com/bcgov/repomountie/blob/master/doc/lifecycle-badges.md)

The NR Email Microservice project is a result of refactoring the NR Messaging Service Showcase application.  We have created a microservice from its backend so that other projects can use the CMSG-Messaging-API with the least amount of effort as possible.

This Microservice can be deployed as a container in your product to enable sending email, and checking the status.  Optionally, it can be protected with OpenID Connect and JWT.

You need to contact<EMAIL_ADDRESS>to get an account for your application.

## Showcase Application

The microservice is currently implemented directly as the backend of the [NR Messaging Service Showcase application](https://github.com/bcgov/nr-messaging-service-showcase).

repository: jujaga/nr-email-microservice

repo_name: jujaga/nr-email-microservice


text:
# NAME
Transport — TCP-like connection

# LIBRARY
MeasurementKit (libmeasurement_kit, -lmeasurement_kit).

# SYNOPSIS
```C++
#include <measurement_kit/net.hpp>

namespace mk {
namespace net {

class Transport {
  public:
    virtual void emit_connect() = 0;
    virtual void emit_data(Buffer buf) = 0;
    virtual void emit_flush() = 0;
    virtual void emit_error(Error err) = 0;

    virtual void on_connect(std::function<void()>) = 0;
    virtual void on_data(std::function<void(Buffer)>) = 0;
    virtual void on_flush(std::function<void()>) = 0;
    virtual void on_error(std::function<void(Error)>) = 0;

    virtual void record_received_data() = 0;
    virtual void dont_record_received_data() = 0;
    virtual Buffer &received_data() = 0;
    virtual void record_sent_data() = 0;
    virtual void dont_record_sent_data() = 0;
    virtual Buffer &sent_data() = 0;

    virtual void set_timeout(double) = 0;
    virtual void clear_timeout() = 0;

    virtual void write(const void *, size_t) = 0;
    virtual void write(std::string) = 0;
    virtual void write(Buffer) = 0;

    virtual void close(std::function<void()>) = 0;

    virtual std::string socks5_address() = 0;
    virtual std::string socks5_port() = 0;
};

} // namespace net
} // namespace mk

void write(Var<Transport> txp, Buffer buf, Callback<Error> cb);

void readn(Var<Transport> txp, Var<Buffer> buff, size_t n, Callback<Error> cb,
           Var<Reactor> reactor = Reactor::global());

void read(Var<Transport> t, Var<Buffer> buff, Callback<Error> callback,
          Var<Reactor> reactor = Reactor::global());

```

# DESCRIPTION

The `Transport` is a TCP like connection to another endpoint. You typically
construct a transport using the `net::connect()` factory method.

A `Transport` is an event emitter class, meaning that it defines functions to
emit and intercept specific events. The following events are defined:

- *connect*: emitted when the connection is established (this is currently only
  used when you connect a SOCKS5 transport)
- *data*: emitted when data was received from the network
- *flush*: emitted when the output buffer is empty
- *error*: emitted when a error occurs

By default the handlers of all these events are empty (i.e. they do nothing
when they are called).

In addition the `Transport` also allows to record the received and the sent data,
and to set and clear the I/O timeout.

The `write()` family of methods allow to write respectively a C style buffer, a
C++ string, and a `Buffer` object. All these functions fill the send buffer, and
a corresponding *flush* event would be emitted when it is empty.

The `close()` method initiates a close operation. The callback passed as first
argument would be called when the `Transport` have been actually closed. We
recommend always making sure that a `Transport` has been closed before continuing,
as shown in the following snippet:

```C++
/* Some code */
transport->close([=]() {
    /* Continuation code after transport was closed */
});
```

Failure to do so MAY result in memory errors, since it is an underlying assumption
of MeasurementKit code that the `Var<Transport>` object would only exit from the
scope after the `Transport` itself has actually been closed.

The `socks5_address()` and `socks5_port()` methods return respectively the SOCKS5
address and port being used, if any. Otherwise the empty string is returned.

The `write()` function is syntactic sugar that schedules an asynchronous write
operation on a transport and calls the provided callback when either an error
occurs or the underlying buffer has been flushed.

The `readn()` function is syntactic sugar that starts an asynchronous read
operation on a transport and only returns whether either `n` bytes have been
read or an error occurred. The `read()` function is a wrapper that calls
the `readn()` function with `n` equal to `1`.

# HISTORY

The `Transport` class appeared in MeasurementKit 0.1.0. The `read()`, `readn()`,
and `write()` functions were added in v0.2.0.

repository: measurement-kit/debian-packaging

repo_name: measurement-kit/debian-packaging


text:
---
title:  Identity Before Mission
date:  18/04/2020
---

#### inTro

Read This Week’s Passage: Acts 7:20–36

A pattern emerges in the creation account of Genesis 1: first God identifies what He is creating, and then He gives its purpose or mission. First He called out the light, which, divided from the darkness, was to demarcate the day from the night. The identity of what He was creating (i.e. the firmament) was established before He elucidated its purpose (i.e. to divide the waters from the waters).

Given the sequential manner in which God creates—the light before the plants, and the plants before the animals, for instance—it becomes apparent that He is intentional. God already knows the purpose of His creation and creates with that purpose in mind. The pattern of introducing the identity of the creation before its purpose is maintained throughout the chapter. We may deduce that God intended for the reader to recognize that identity precedes mission.

Before we are introduced to Adam and Eve’s mission to “be fruitful, and multiply; fill the earth and subdue it; have dominion...” (Gen. 1:28), we are introduced to their identity

(Gen. 1:27) as beings created in the image of God. This differentiates their mission to “be fruitful and multiply” from that given to the sea creatures and winged fowl (Gen. 1:22). Whereas the mission is limited to physical fruitfulness and multiplication for the fish and birds, it has intellectual and spiritual implications for humans who are created in the image of God.

Mission cannot be understood fully until identity is understood. By the same token, a misidentification will lead to a mischaracterization of the mission. Put differently, we do not know what we should be doing if we do not know who we are.

#### inScribe

Write out Acts 7:20–36 from the translation of your choice. If you’re pressed for time, write out Acts 7:35, 36. You may also rewrite the passage in your own words, outline, or mind map the chapter.

``

repository: Adventech/sabbath-school-lessons

branch_name: refs/heads/stage

repo_name: Adventech/sabbath-school-lessons


text:
---
title: A tale of Tempest rpm with Installers
author: chandankumar
tags: openstack,rdo,tempest,python-tempestconf
date: 2017-03-14 18:27:02 IST
---

[Tempest](https://docs.openstack.org/developer/tempest/overview.html) is a set of integration tests to run against OpenStack Cloud.
Delivering robust and working OpenStack cloud is always challenging. To make sure what we deliver in RDO is rock-solid, we use Tempest
to perform a set of API and scenario tests against a running cloud using different installers like [puppet-openstack-integration](http://git.openstack.org/cgit/openstack/puppet-openstack-integration/),
[packstack](http://git.openstack.org/cgit/openstack/packstack), and [tripleo-quickstart](http://git.openstack.org/cgit/openstack/tripleo-quickstart).
And, it is the story of how we integrated RDO Tempest RPM package with installers so it can be consumed by various CI rather than using raw upstream sources.

And the story begins from here:

In RDO, we deliver Tempest as an rpm to be consumed by anyone to test their cloud. Till Newton release,
we maintained a fork of [Tempest](https://github.com/redhat-openstack/tempest) which contains the config_tempest.py script to auto generate tempest.conf
for your cloud and a set of helper scripts to run Tempest tests as well as with some backports for each release. From Ocata, we have changed the source of Tempest rpm from forked Tempest to upstream Tempest by keeping
the old source till Newton in RDO through [rdoinfo](https://review.rdoproject.org/r/#/q/topic:switch-upstream-tempest). We are using rdo-patches branch
to maintain patches backports starting from Ocata release.

With this change, we have moved the config_tempest.py script from the forked Tempest repository to a separate project [python-tempestconf](https://github.com/redhat-openstack/python-tempestconf)
so that it can be used with vanilla Tempest to generate Tempest config automatically.

What have we done to make a happy integration between Tempest rpm and the installers?

Currently, puppet-openstack-integration, packstack, and tripleo-quickstart heavily use RDO packages. So using Tempest rpm with these installers will be the best match.
Before starting the integration, we need to make the initial ground ready. Till Newton release, all these installers are using Tempest from source in their respective CI.
We have started the match making of Tempest rpm with installers.
puppet-openstack-integration and packstack consume puppet-modules. So in order to consume Tempest rpm, first I need to fix the [puppet-tempest](http://git.openstack.org/cgit/openstack/puppet-tempest).

## [puppet-tempest](http://git.openstack.org/cgit/openstack/puppet-tempest)

It is a puppet-module to install and configure Tempest and openstack-services Tempest plugins based on the services available from source as well as packages.
So we have fixed puppet-tempest to install Tempest rpm from the package and created a Tempest workspace. In order to use that feature through puppet-tempest module [https://review.openstack.org/#/c/425085/].
you need to add *install_from_source => 'false'* and *tempest_workspace => 'path to tempest workspace'* to tempest.pp and it will do the job for you.
Now we are using the same feature in puppet-openstack-integration and packstack.

## [puppet-openstack-integration](http://git.openstack.org/cgit/openstack/puppet-openstack-integration/)

It is a collection of scripts and manifests for puppet module testing (which powers the openstack-puppet CI).
From Ocata release, we have added a flag TEMPEST_FROM_SOURCE flag in [run_tests.sh script](http://git.openstack.org/cgit/openstack/puppet-openstack-integration/tree/run_tests.sh).
Just change TEMPEST_FROM_SOURCE to false in the [run_test.sh](https://review.openstack.org/#/c/427578/), Tempest is then installed and configured from packages using puppet-tempest.

## [packstack](http://git.openstack.org/cgit/openstack/packstack)

It is a utility to install OpenStack on CentOS, Red Hat Enterprise Linux or other derivatives in proof of concept (PoC) environments. Till Newton, Tempest is installed and ran by packstack from the upstream source and behind the scenes, puppet-tempest does the job for us. From Ocata, we have replaced this feature by using [Tempest RDO package](https://review.openstack.org/#/c/428102/). You can use this feature by running the following command:

	$ sudo packstack --allinone --config-provision-tempest=y --run-tempest=y

It will perform packstack all in one installation and after that, it will install and configure Tempest and run smoke tests on deployed cloud.
We are using the same in RDO CI.

## [tripleo-quickstart](https://docs.openstack.org/developer/tripleo-quickstart/)

It is an ansible based project for setting up TripleO virtual environments.
It uses [triple-quickstart-extras](http://git.openstack.org/cgit/openstack/tripleo-quickstart-extras/tree/roles/validate-tempest) where validate-tempest roles exist which is used to install, configure and run Tempest on a tripleo deployment after installation. We have improved the validate-tempest role to use Tempest rpm package for all releases (supported by OpenStack upstream) by keeping the old workflow and as well as using Ocata Tempest rpm and using ostestr for running Tempest tests for all releases and using python-tempestconf to generate tempest.conf through [this patch](https://review.openstack.org/#/c/431916/).

To see in action, Run the following command:

	$ wget https://raw.githubusercontent.com/openstack/tripleo-quickstart/master/quickstart.sh
	$ bash quickstart.sh --install-deps
	$ bash quickstart.sh -R master --tags all $VIRTHOST

So finally the integration of Tempest rpm with installers is finally done and they are happily consumed in different CI and this will help to test and produce more robust OpenStack cloud in RDO as well as catch issues of Tempest with Tempest plugins early.

Thanks to apevec, jpena, amoralej, Haikel, dmsimard, dmellado, tosky, mkopec, arxcruz, sshnaidm, mwhahaha, EmilienM
and many more on #rdo channel for getting this work done in last 2 and half months. It was a great learning experience.

repository: sulaimanothman/website

repo_name: sulaimanothman/website


text:
# @angular-package/reactive

[![npm version](https://badge.fury.io/js/%40angular-package%2Freactive.svg)](https://badge.fury.io/js/%40angular-package%2Freactive)
[![Known Vulnerabilities](https://snyk.io/test/npm/@angular-package/reactive/badge.svg)](https://snyk.io/test/npm/@angular-package/reactive)
[![GitHub license](https://img.shields.io/github/license/angular-package/angular-package.svg)](https://github.com/angular-package/angular-package/blob/master/LICENSE)

Automatize process of creating some **[rxjs](http://reactivex.io/rxjs/)** features.

* **Treeshake** bundle with **[Rollup](https://rollupjs.org/#introduction)** - module bundler for JavaScript.
* **AOT** (Ahead Of Time Compilation) package: *faster rendering*, *fewer asynchronous requests*, *smaller Angular framework download size*, *detect template errors earlier*, *better security*.
* **MIT** License: it can be used commercially.

---

### Packages

```typescript
import '@angular-package/reactive/subject';
import '@angular-package/reactive/unsubscribe';
```

| Packages         | Description                                    | Status      | Readme       |
|------------------|------------------------------------------------|-------------|--------------|
| subject | Automatize process of creating observable properties in component or service.   | **Ready**  | [Readme][0] |
| unsubscribe | Automatize process of unsubscribe subscriptions in component. | **Ready**  | [Readme][1] |

#### Subject

```typescript
import { ApSubject } '@angular-package/reactive/subject';
import { ApSubjectAsync } '@angular-package/reactive/subject/async';
import { ApSubjectBehavior } '@angular-package/reactive/subject/behavior';
import { ApSubjectReplay } '@angular-package/reactive/subject/replay';
```

| Package  | Module            | Description                                          | Status     | Readme      |
|----------|-------------------|------------------------------------------------------|------------|-------------|
|          | ApSubject         | Decorator to automatize process of creating `Subject` observable on indicated properties in component or service.         | **Ready**  | [Readme][2] |
| async    | ApSubjectAsync    | Decorator to automatize process of transform indicated properties in component or service to `AsyncSubject` observables.    | **Ready**  | [Readme][3] |
| behavior | ApSubjectBehavior | Decorator to automatize process of creating `BehaviorSubject` observable on indicated properties in component or service. | **Ready**  | [Readme][4] |
| replay   | ApSubjectReplay   | Decorator to automatize process of creating `ReplaySubject` observable on indicated properties in component or service.   | **Ready**  | [Readme][5] |

#### Unsubscribe

```typescript
import { ApUnsubscribe } '@angular-package/reactive/unsubscribe';
```

| Module   | Description                                          | Status     | Readme      |
|----------|------------------------------------------------------|------------|-------------|
| ApUnsubscribe | Decorator to automatize process of unsubscribe subscriptions in component. | **Ready**  | [Readme][6] |

[0]: https://github.com/angular-package/angular-package/tree/master/packages/reactive/packages/subject#readme
[1]: https://github.com/angular-package/angular-package/tree/master/packages/reactive/packages/unsubscribe#readme
[2]: https://github.com/angular-package/angular-package/tree/master/packages/reactive/packages/subject/#readme
[3]: https://github.com/angular-package/angular-package/tree/master/packages/reactive/packages/subject/async#readme
[4]: https://github.com/angular-package/angular-package/tree/master/packages/reactive/packages/subject/behavior#readme
[5]: https://github.com/angular-package/angular-package/tree/master/packages/reactive/packages/subject/replay#readme
[6]: https://github.com/angular-package/angular-package/tree/master/packages/reactive/packages/unsubscribe#readme

repository: amitic/angular-package

repo_name: amitic/angular-package


text:
---
title: How to mark offline payment as received
---

# How to mark offline payment as received?

**Offline payments** are payments made via cheque, bank transfer or on-site. When a ticket is orderd using one of the offline payment options, that ticket will be labeled as `placed` in organizer's dashboard.

When an offline payment is received, the organizer needs to mark it as received by completing the steps as below.

**Step 1:** Log in to your account on [eventyay](https://eventyay.com/login) then click on `Manage Events` from the drop-down menu under your profile.

![How-to-mark-offline-payment-as-received](../images/How-to-mark-offline-payment-as-received-0.png)

**Step 2:** Go to the event you want to update the payment and click on `Event Dashboard`.

![How-to-mark-offline-payment-as-received](../images/How-to-mark-offline-payment-as-received-1.png)

**Step 3:** Click on `Tickets` inside event management dashboard.

![How-to-mark-offline-payment-as-received](../images/How-to-mark-offline-payment-as-received-2.png)

You will be directed to a page with an overview of all your orders.

![How-to-mark-offline-payment-as-received](../images/How-to-mark-offline-payment-as-received-3.png)

**Step 4:** Click on `Orders`, then click to view `Placed` orders. You will see a list of the orders (offline payment) that have been placed.

![How-to-mark-offline-payment-as-received](../images/How-to-mark-offline-payment-as-received-4.png)

**Step 5:** After you have received payment for an order, click `Mark Completed` to update its status.

![How-to-mark-offline-payment-as-received](../images/How-to-mark-offline-payment-as-received-6.png)

**Step 6:** You will be asked to reconfirm your action. Click `Yes` to proceed.

![How-to-mark-offline-payment-as-received](../images/How-to-mark-offline-payment-as-received-7.png)

gha_language: HTML


text:
# Bookshop Addon HTML

This addon for Bookshop adds a tab that displays some import code for each
story. It is forked from [whitespace-se/storybook-addon-html](https://github.com/whitespace-se/storybook-addon-html)

![Animated preview](https://raw.githubusercontent.com/whitespace-se/storybook-addon-html/master/image.gif)

## Getting Started

With NPM:

```sh
npm i --save-dev bookshop-addon-import-tab
```

With Yarn:

```sh
yarn add -D bookshop-addon-import-tab
```

### Register addon

```js
// .storybook/main.js

module.exports = {
  // ...
  addons: [
    'bookshop-addon-import-tab',
    // ...
  ],
};
```

repository: ryaninvents/storybook-addon-import

repo_name: ryaninvents/storybook-addon-import


text:
* There should be one primary macro for defining language forms,
  which would also define a destructuring macro for that form.
  (And maybe it could make flimsy_syntax.rs simpler or nonexistent.)
* This may overlap with the purpose of the previous,
  but there should be something like `Ast`, except with binding and quotation omitted.
  It would represent syntax "as written"
  and be nice for making, e.g., syntax-aware `diff`-like tools.
* Names for "parts" would appear as barewords, not strings, in macros. Maybe. Not sure about this.
* There are so many variations on maps and reduces in mbe.rs,
  and pretty much all of them are used once.
  I think something visitor-pattern-like might be able to unify them?
* I think `FormPat` is more like a language than I realized.
  It seems to have positive and negative forms, mediated by `Scope` and `Named`.
  There might need to be more structure, to enforce what can go where,
  as well as, uh, possibly some scoped way to define names *internal* to the grammar.
  Also, `FormPat` is a bad name.
* The walk_mode.rs/ast_walk.rs distinction isn't great; I never know what's where.
* It would probably have been simpler to add a few more cases (or one `Any` case) to `Value`
    and build some primitive operations on them
   than it was to build all those reification macros.
* In examples and tests, `Int` and `Nat` are frequently used,
  and the user is supposed to assume that neither is a subtype of the other.
  That's unintuitive!

* Forms ought to be all given names (at the Rust level, I mean);
   `find_core_form()` is unpleasant and should be removed.

  Former mistakes:
  * There used to be a `Ty` type that was just a wrapper around `Ast` (in the
    distant past, it had had additional functionality). (Issue #30)

repository: paulstansifer/unseemly

gha_language: Rust

repo_name: paulstansifer/unseemly


text:
---
title: "Moving horizon demand and state estimation for model predictive perimeter control of large-scale urban networks"
author: "I.I. Sirmatel, N. Geroliminis"
where: "2019 European Control Conference (ECC)"
tags:
date: '2019-06-25'
layout: single
category: publications
author_profile: true
excerpt:
comments: true
sidebar:
  nav: "publications"
---
full text (pdf)

Abstract: Perimeter control schemes proposed to alleviate congestion in large-scale urban networks usually assume perfect knowledge of the accumulation state and inflow demands, both requiring information about the origins and destinations of drivers. Such assumptions are problematic for practice due to measurement noise and difficulty of obtaining OD-based information. We address these by a nonlinear moving horizon estimation (MHE) scheme for the combined demand and state estimation for a two region large-scale urban road network with dynamics described via macroscopic fundamental diagram. We consider various measurement configurations likely to be encountered in practice, such as measurements on regional accumulations and transfer flows without OD information, and provide results of their observability tests. A model predictive perimeter control scheme is combined with the MHE to present an application case. Simulation studies demonstrate operation of the proposed scheme.

license: Unlicense

gha_license_id: Unlicense


text:
# Timeline

**A project for scraping data from different website using python scrapy webframework,
manage dependency via pipenv virtual environment.**

>python version: 3.7

repository: cchangr/Timeline

repo_name: cchangr/Timeline


text:
# Fittings and Fitting
The character fittings resource allows an application to both read and write to the saved fitting service. This does not have anything to do with actually fitting a ship, just the saved fits.

One of the really nice things about the CREST fitting service is that when a fit is added or deleted a notification is sent to any connected clients. This means if a character has their fitting window open and a fit is added through CREST the fitting window should be updated almost immediately.

## Fittings
### Route
``/characters/<characterID:characterIdType>/fittings/``

### GET
* Cache: 15 minutes
* Scope: `characterFittingsRead`

It is important to remember that adding or deleting a fit will not invalidate this cache. It is recommended that so long as you get the proper response code from CREST when you POST a new fit that you update any local cache at least temporarily.

```json
{
  "totalCount_str": "1",
  "items": [
    {
      "description": "THIS IS A TEST FIT DESCRIPTION!",
      "fittingID_str": "258",
      "items": [
        {
          "flag": 11,
          "quantity_str": "1",
          "type": {
            "id_str": "518",
            "href": "https://crest-tq.eveonline.com/inventory/types/518/",
            "id": 518,
            "name": "Basic Gyrostabilizer"
          },
          "flag_str": "11",
          "quantity": 1
        }
      ],
      "fittingID": 258,
      "href": "https://crest-tq.eveonline.com/characters/90000001/fittings/258/",
      "ship": {
        "id_str": "587",
        "href": "https://crest-tq.eveonline.com/inventory/types/587/",
        "id": 587,
        "name": "Rifter"
      },
      "name": "THIS IS A TEST FIT NAME!"

}
```

### DELETE
No content required for this request. Expect it to delete whatever resource
it is sent to.

## Errors
Each of these errors should be presented to the user so they can take the required action.

### FittingsStopSpamming
* Message: "Spamming the fitting service."
* Note: The fitting service is rate limited outside of CREST. This applies to all applications trying to access it, including the client. Stop for 15 seconds and wait.

### OwnerMaxFittings
* Message: "Maximum fittings of {} reached."

### FittingNameTooLong
* Message: "Maximum fitting name length is {}."

### FittingDescriptionTooLong
* Message: "Maximum fitting description length is {}"


text:
# foxes example: _timelines_

Shows dynamic wake development for timeseries states input.

## Check options
Check options by
```
python3 run.py -h
```

## Run command
```
python3 run.py
```

repository: FraunhoferIWES/foxes

repo_name: FraunhoferIWES/foxes


text:
# binary_dot_com_trading_bot
working trading bot using  javascript and 99 lines of codes.

# you can read comprehensive details from here
[https://blogs.ceylon.app/how-to-create-artificial-intelligence-enabled-trading-bot-part-1/](https://blogs.ceylon.app/how-to-create-artificial-intelligence-enabled-trading-bot-part-1/)

Installation guide

```sh

npm install
npm start

```

Also you need to replace your app id and token keys in file

Licence
Free For All, Do anything as you wish


text:
---
title: When
page_title: When | JustMock Documentation
description: When
previous_url: /basic-usage-mock-when.html
slug: justmock/basic-usage/mock/when
tags: when
published: True
position: 10
---

# When

Applied, the __When__ clause enables the arrangement only if certain conditions are satisfied. It specifies what must be true (along with any argument [matcher]({%slug justmock/basic-usage/matchers%}), or [IgnoreInstance()]({%slug justmock/advanced-usage/future-mocking%}) or IgnoreArguments() clauses used on the arrangement) for that arrangement to be executed and its expectations updated.
To understand how to use the __When__ method, check the next examples:

## How It Works
Let's assume we have the following `interface`:

  #### __[C#]__

  {{region When#InterfaceUnderTest}}
    public interface IFoo
    {
        bool IsCalled();
        string Prop { get; set; }
    }
  {{endregion}}

  #### __[VB]__

  {{region When#InterfaceUnderTest}}
    Public Interface IFoo
        Function IsCalled() As Boolean

        Property Prop() As String
    End Interface
  {{endregion}}

Using JustMock, we can set a certain arrangement to be used only if another expectations are met. The below test method is a demonstration of this. The `IsCalled` function is arranged to return `true` only if `Prop` is equal to "test".

  #### __[C#]__

  {{region When#FirstExample}}
    [TestMethod]
    public void IsCalled_ShouldReturnTrue_WithMockedDependencies()
    {
        // Arrange
        var foo = Mock.Create<IFoo>();

        Mock.Arrange(() => foo.Prop).Returns("test");
        Mock.Arrange(() => foo.IsCalled()).When(() => foo.Prop == "test").Returns(true);

        // Assert
        Assert.IsTrue(foo.IsCalled());
    }
  {{endregion}}

  #### __[VB]__

  {{region When#FirstExample}}
    <TestMethod> _
    Public Sub IsCalled_ShouldReturnTrue_WithMockedDependencies()
        ' Arrange
        Dim foo = Mock.Create(Of IFoo)()

        Mock.Arrange(Function() foo.Prop).Returns("test")
        Mock.Arrange(Function() foo.IsCalled()).When(Function() foo.Prop = "test").Returns(True)

        ' Assert
        Assert.IsTrue(foo.IsCalled())
    End Sub
  {{endregion}}

## How It Helps

There are situations where you need to make an arrangement that will only work when a certain condition is true. If the condition is related to that member's input arguments, you can use [Matchers]({%slug justmock/basic-usage/matchers%}). However, if the condition is not related to them, you can achieve the desired behavior by using the __When__ method.

Look at the following `interface`:

  #### __[C#]__

  {{region When#SecondInterfaceUnderTest}}
    public interface IRequest
    {
        string Method { get; set; }
        string GetResponse();
    }
  {{endregion}}

  #### __[VB]__

  {{region When#SecondInterfaceUnderTest}}
    Public Interface IRequest
        Property Method() As String
        Function GetResponse() As String
    End Interface
  {{endregion}}

In the test, we will check if `GetResponse()` has been called once when `Method` == "GET" and once more when `Method` == "POST". Note that, the `Method` property is unrelated to the `GetResponse()` method.

  #### __[C#]__

  {{region When#ThirdExample}}
    [TestMethod]
    public void ShouldAssertThatSUTCallsGetResponseWithBothGetAndPostMethods()
    {
        // Arrange
        var mock = Mock.Create<IRequest>();

        Mock.Arrange(() => mock.GetResponse()).When(() => mock.Method == "GET").OccursOnce();
        Mock.Arrange(() => mock.GetResponse()).When(() => mock.Method == "POST").OccursOnce();

        // Act
        mock.Method = "GET";
        mock.GetResponse();

        mock.Method = "POST";
        mock.GetResponse();

        // Assert
        Mock.Assert(mock);
    }
  {{endregion}}

  #### __[VB]__

  {{region When#ThirdExample}}
    <TestMethod> _
    Public Sub ShouldAssertThatSUTCallsGetResponseWithBothGetAndPostMethods()
        ' Arrange
        Dim requestMock = Mock.Create(Of IRequest)()

        Mock.Arrange(Function() requestMock.GetResponse()).When(Function() requestMock.Method = "GET").OccursOnce()
        Mock.Arrange(Function() requestMock.GetResponse()).When(Function() requestMock.Method = "POST").OccursOnce()

        ' Act
        requestMock.Method = "GET"
        requestMock.GetResponse()

        requestMock.Method = "POST"
        requestMock.GetResponse()

        ' Assert
        Mock.Assert(requestMock)
    End Sub
  {{endregion}}

## See Also

 * [Mock]({%slug justmock/basic-usage/mock%})

 * [Matchers]({%slug justmock/basic-usage/matchers%})

 * [Returns]({%slug justmock/basic-usage/mock/returns%})

 * [Do Nothing]({%slug justmock/basic-usage/mock/do-nothing%})

 * [Asserting Occurrence]({%slug justmock/basic-usage/asserting-occurrence%})

repository: Prophasi/justmock-docs

repo_name: Prophasi/justmock-docs


text:
> [Go to French version](/fr/Règlements/Décrets,%20ordonnances%20et%20règlements%20statutaires/2001/366.md)

# Ancillary Activities (Insurance Companies, Canadian Societies and Insurance Holding Companies) Regulations

**SOR/2001-366**

Enabling authorities:
- [INSURANCE COMPANIES ACT](/en/Acts/Statutes%20of%20Canada/1991/c.%2047.md)

Date registered: 4 October 2001

----------

Her Excellency the Governor General in Council, on the recommendation of the Minister of Finance, pursuant to section 1021[a] of the [Insurance Companies Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2047.md)[b], hereby makes the annexed Ancillary Activities (Insurance Companies, Canadian Societies and Insurance Holding Companies) Regulations.

a: S.C. 2001, c. 9, s. 465

b: S.C. 1991, c. 47

## Interpretation

**Definition**

**1** In these Regulations, ***Act*** means the [Insurance Companies Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2047.md).

## Life Companies

**Prescribed activities**

**2**

- **(1)** For the purpose of paragraph 495(2)(f) of the Act, the following activities are prescribed in relation to an entity and a life company that acquires control of, or acquires or increases a substantial investment in, the entity:
	- **(a)** the provision of safety and risk prevention services and services respecting risk management and claims adjustment;
	- **(b)** the operation of rehabilitation and training and development centres;
	- **(c)** the provision of computer systems to independent insurance brokers and agents;
	- **(d)** the provision of support to independent insurance brokers and agents;
	- **(e)** the operation of repair and appraisal centres; and
	- **(f)** any other activities that are reasonably ancillary to the business of insurance carried on by the life company.

**Prescribed term or condition**

- **(2)** For the purpose of paragraph 495(2)(f) of the Act, a prescribed term or condition is that the activities referred to in paragraphs (1)(a) to (e) must be reasonably ancillary to the business of insurance carried on by the life company.

## Property and Casualty Companies and Marine Companies
> [SOR/2009-296, s. 24]

**Prescribed activities**

**3**

- **(1)** For the purpose of paragraph 495(4)(f) of the Act, the following activities are prescribed in relation to an entity and a property and casualty company or marine company that acquires control of, or acquires or increases a substantial investment in, the entity:
	- **(a)** the provision of safety and risk prevention services and services respecting risk management and claims adjustment;
	- **(b)** the operation of rehabilitation and training and development centres;
	- **(c)** the provision of computer systems to independent insurance brokers and agents;
	- **(d)** the provision of support to independent insurance brokers and agents;
	- **(e)** the operation of repair and appraisal centres; and
	- **(f)** any other activities that are reasonably ancillary to the business of insurance carried on by the company.

**Prescribed term or condition**

- **(2)** For the purpose of paragraph 495(4)(f) of the Act, a prescribed term or condition is that the activities referred to in paragraphs (1)(a) to (e) must be reasonably ancillary to the business of insurance carried on by the property and casualty company or the marine company.
> SOR/2009-296, s. 25.

## Societies

**Prescribed activities**

**4** For the purpose of paragraph 554(2)(f) of the Act in relation to an entity and a society that acquires control of, or acquires or increases a substantial investment in, the entity, prescribed activities are activities that are reasonably ancillary to the society’s insurance business.

## Insurance Holding Companies

**Prescribed activities**

**5**

- **(1)** For the purpose of paragraph 971(2)(f) of the Act, the following activities are prescribed in relation to an entity and an insurance holding company that acquires control of, or acquires or increases a substantial investment in, the entity:
	- **(a)** the provision of safety and risk prevention services and services respecting risk management and claims adjustment;
	- **(b)** the operation of rehabilitation and training and development centres;
	- **(c)** the provision of computer systems to independent insurance brokers and agents;
	- **(d)** the provision of support to independent insurance brokers and agents;
	- **(e)** the operation of repair and appraisal centres; and
	- **(f)** any other activities that are reasonably ancillary to the business of insurance carried on by a company controlled by the insurance holding company.

**Prescribed term or condition**

- **(2)** For the purpose of paragraph 971(2)(f) of the Act, a prescribed term or condition is that the activities referred to in paragraphs (1)(a) to (e) must be reasonably ancillary to the business of insurance carried on by a company controlled by the insurance holding company.

## Coming into Force

**Coming into force**

[*]**6** These Regulations come into force on the day on which section 495 of the [Insurance Companies Act](/en/Acts/Statutes%20of%20Canada/1991/c.%2047.md), as enacted by section 426 of the [Financial Consumer Agency of Canada Act](/en/Acts/Statutes%20of%20Canada/2001/c.%209.md), chapter 9 of the Statutes of Canada, 2001, comes into force.

*: [Note: Regulations in force October 24, 2001, *see* SI/2001-102.]

repository: TravisMadill/CanadianLaws

path: /en/Regulations/Statutory Orders and Regulations/2001/366.md

repo_name: TravisMadill/CanadianLaws


text:
# My dotfiles

This is a collection of dotfiles I use daily.

They are managed with [GNU Stow](https://www.gnu.org/software/stow/).

## Usage

* Install Stow

On SUSE-like systems:

```console
zypper install stow
```

(or with [1-click](https://software.opensuse.org/package/stow) install)

* Checkout this repo in your $HOME

```console
git clone https://github.com/dmacvicar/dotfiles.git
```
* Symlink modules

For example, if you want to use my emacs dotfiles:

```console
cd dotfiles
stow emacs
```

And that is all. Stow will take care of symlinking the files to your $HOME.

# Author

* Duncan Mac-Vicar P<EMAIL_ADDRESS>

repository: dmacvicar/dotfiles

repo_name: dmacvicar/dotfiles


text:
# PN5_60822

<PageHeader />

## Description

jQL: MV associations not correctly processing input/output conversions

### Previous Release Behavior

Prior to this patch, in a controlling/dependent relationship, a dependent dictionary using a group extract or a Date conversion in dict<8> did not correctly process any multi-value past the first one.

Back to [5.7.2 Release Notes](./../jbase-<IP_ADDRESS>-release-notes/README.md)

<PageFooter />

repository: josepheshaw/docs

repo_name: josepheshaw/docs


text:
**Return Statement**

When calling a function, you'll often want it to give you a value back. In order to do that, you must `return` it. The reason for this is because functions have their own scope. Any values defined within the function body are inaccessible outside of that function.

*For more information about scope, see `!tags scope`*

Consider the following function:
```py
def square(n):
    return n*n
```
If we wanted to store 5 squared in a variable called `x`, we could do that like so:
`x = square(5)`. `x` would now equal `25`.

**Common Mistakes**
```py
>>> def square(n):
...     n*n  # calculates then throws away, returns None
...
>>> x = square(5)
>>> print(x)
None
>>> def square(n):
...     print(n*n)  # calculates and prints, then throws away and returns None
...
>>> x = square(5)
25
>>> print(x)
None
```
**Things to note**
• `print()` and `return` do **not** accomplish the same thing. `print()` will only print the value, it will not be accessible outside of the function afterwards.
• A function will return `None` if it ends without reaching an explicit `return` statement.
• When you want to print a value calculated in a function, instead of printing inside the function, it is often better to return the value and print the *function call* instead.
• [Official documentation for `return`](https://docs.python.org/3/reference/simple_stmts.html#the-return-statement)

repository: pormes/bot

repo_name: pormes/bot


text:
> To save HTTP requests, it may be convenient to send related documents along with the request.
>
> — [JSON API specification for Ember Data][cite].

# Writable nested serializers

Although flat data structures serve to properly delineate between the individual entities in your service, there are cases where it may be more appropriate or convenient to use nested data structures.

Nested data structures are easy enough to work with if they're read-only - simply nest your serializer classes and you're good to go.  However, there are a few more subtleties to using writable nested serializers, due to the dependencies between the various model instances, and the need to save or delete multiple instances in a single action.

## One-to-many data structures

*Example of a **read-only** nested serializer.  Nothing complex to worry about here.*

    class ToDoItemSerializer(serializers.ModelSerializer):
        class Meta:
            model = ToDoItem
            fields = ['text', 'is_completed']

    class ToDoListSerializer(serializers.ModelSerializer):
        items = ToDoItemSerializer(many=True, read_only=True)

        class Meta:
            model = ToDoList
            fields = ['title', 'items']

Some example output from our serializer.

    {
        'title': 'Leaving party preparations',
        'items': [
            {'text': 'Compile playlist', 'is_completed': True},
            {'text': 'Send invites', 'is_completed': False},
            {'text': 'Clean house', 'is_completed': False}
        ]
    }

Let's take a look at updating our nested one-to-many data structure.

### Validation errors

### Adding and removing items

### Making PATCH requests

[cite]: http://jsonapi.org/format/#url-based-json-api


text:
## Class: stream.PassThrough

##

This is a trivial implementation of a \[Transform\]\[\] stream that simply
passes the input bytes across to the output. Its purpose is mainly
for examples and testing, but there are occasionally use cases where
it can come in handy as a building block for novel sorts of streams.


text:
RabbitMQ-Autoclsuter Consul example
--
Dynamic RabbitMQ cluster using:

1. [Docker compose](https://docs.docker.com/compose/)

2. [Consul](https://www.consul.io)

3. [HA proxy](https://github.com/docker/dockercloud-haproxy)

Execute
--
```
cd  examples/compose_consul_haproxy
docker-compose up
docker-compose scale rabbit=3
```

Check
--

- Consul Management: http://localhost:8500/ui/
- RabbitMQ Management: http://localhost:15672/#/

repository: noxdafox/rabbitmq-autocluster

repo_name: noxdafox/rabbitmq-autocluster


text:
---
layout: post
title: Week 6
---

What did you do the past week?
This past week was just a regular class week only there was no project due in the immediate future. Consequently, we have an exam this upcoming Thursday. Professor Downing explained to us how generators and list comprehensions are made and the pros and cons of both of these tools. Unfortunately I didn’t do so hot on quizzes this week in class as I was always guessing the wrong answer when I had it pinned down to two answers. The other answer, that I obviously didn’t pick, was always the correct answer. You know what they say though, you win some you lose some…. just wish I could win at least as often as I lost…

What's in your way?
Preparing for the four interviews and two exams I have the next week has been taking up all of my time. Considering Austin City Limits music festival is this weekend and that it takes up 3 days, I am going to be intelligent about how I utilize my time. I am currently writing this blog post at one ‘o clock AM after ACL.

What will you do next week?
Next week I will be extensively studying for my exams. I will also be going to my four interviews. Needless to say, next week will be quite hectic for me.

Tip of the week: (Highpoint of the goddamn post) Getting interview practice is all about repetition and real life experience. Studying always helps but sometimes going to an actual interview is the practice you need. Try setting up mock interviews with friends for a low-pressure but great way to improve your interviewing skills!


text:
---
layout: post
title:  "Detection of carcinogenic weeds in aerial images using supervised learning"
date:   2019-06-09 22:21:59 +00:00
image: /images/plantbefore-h.png
hoverimage: /images/plantafter.png
categories: research
author: "Dennis Hadjivelichkov"
authors: "Denis Hadjivelichkov"
venue: "Bachelor Thesis"
---
Created a dataset containing carcinogenic weeds (Heliotropium Europaeum) in aerial imagery of farm fields. Applied and developed machine learning models for binary image classification. Developed an image processing algorithm for localization of weeds within the images. Dealt with a limited data and achieved a high recall rate.

extension: markdown


text:
Olympus-Scholar
===============

A Google Scholar module for Olympus.
This module is based on [scholar.py](https://github.com/ckreibich/scholar.py) by [ckreibich](https://github.com/ckreibich), which is released under the [BSD license](http://opensource.org/licenses/BSD-2-Clause).

repository: HAN-Olympus/Olympus-Scholar

repo_name: HAN-Olympus/Olympus-Scholar


text:
# Changelog

## Unversioned

- Minor: Disable checking for updates on unsupported platforms (#1874)
- Bugfix: Fix bug preventing users from setting the highlight color of the second entry in the "User" highlights tab (#1898)
- Bugfix: Fix bug where the "check user follow state" event could trigger a network request requesting the user to follow or unfollow a user. By itself its quite harmless as it just repeats to Twitch the same follow state we had, so no follows should have been lost by this but it meant there was a rogue network request that was fired that could cause a crash (#1906)
- Bugfix: /usercard command will now respect the "Automatically close user popup" setting (#1918)
- Bugfix: Handle symlinks properly when saving commands & settings (#1856, #1908)
- Bugfix: Starting Chatterino in a minimized state after an update will no longer cause a crash

## 2.2.0

- Major: We now support image thumbnails coming from the link resolver. This feature is off by default and can be enabled in the settings with the "Show link thumbnail" setting. This feature also requires the "Show link info when hovering" setting to be enabled (#1664)
- Major: Added image upload functionality to i.nuuls.com with an ability to change upload destination. This works by dragging and dropping an image into a split, or pasting an image into the text edit field. (#1332, #1741)
- Major: Added option to display tabs vertically. (#1815)
- Major: Support the highlighted messages redeemed with channel points on twitch.tv.
- Major: Added emote completion with `:`
- Minor: Added a "Streamer Mode" that hides user generated images while obs is open.
- Minor: Added extension support for Brave browser and Microsoft Edge. (#1862)
- Minor: Add a switcher widget, similar to Discord. It can be opened by pressing Ctrl+K. (#1588)
- Minor: Clicking on `Open in browser` in a whisper split will now open your whispers on twitch. (#1828)
- Minor: Clicking on @mentions will open the User Popup. (#1674)
- Minor: You can now open the Twitch User Card by middle-mouse clicking a username. (#1669)
- Minor: User Popup now also includes recent user messages (#1729)
- Minor: BetterTTV / FrankerFaceZ emote tooltips now also have emote authors' name (#1721)
- Minor: Emotes in the emote popup are now sorted in the same order as the tab completion (#1549)
- Minor: Removed "Online Logs" functionality as services are shut down (#1640)
- Minor: CTRL+F now selects the Find text input field in the Settings Dialog (#1806 #1811)
- Minor: CTRL+F now selects the search text input field in the Search Popup (#1812)
- Minor: Modify our word boundary logic in highlight phrase searching to accomodate non-regex phrases with "word-boundary-creating" characters like ! (#1885, #1890)
- Bugfix: Fixed not being able to open links in incognito with Microsoft Edge (Chromium) (#1875)
- Bugfix: Fix the incorrect `Open stream in browser` labelling in the whisper split (#1860)
- Bugfix: Fix preview on hover not working when Animated emotes options was disabled (#1546)
- Bugfix: FFZ custom mod badges no longer scale with the emote scale options (#1602)
- Bugfix: MacOS updater looked for non-existing fields, causing it to always fail the update check (#1642)
- Bugfix: Fixed message menu crashing if the message you right-clicked goes out of scope before you select an action (#1783) (#1787)
- Bugfix: Fixed alternate messages flickering in UserInfoPopup when clicking Refresh if there was an odd number of messages in there (#1789 #1810)
- Settings open faster
- Dev: Fully remove Twitch Chatroom support
- Dev: Handle conversion of historical CLEARCHAT messages to NOTICE messages in Chatterino instead of relying on the Recent Messages API to handle it for us. (#1804)


text:
---
title: Course Schedule
date: "2020-05-29"
type: problem-solving
description: Course Schedule
tags: csharp
---

Note: This problem was taken from LeetCode - [Course Schedule](https://leetcode.com/problems/course-schedule/)

### Using DFS

```csharp
public bool CanFinish(int numCourses, int[][] prerequisites)
{
	Dictionary<int, List<int>> map = new Dictionary<int, List<int>>();

	// Initialising the adjacency list
	for (int i = 0; i < numCourses; i++)
	{
		map[i] = new List<int>();
	}

	// Adding all the courses and it's prerequisites to the dictionary
	foreach (int[] item in prerequisites)
	{
		map[item[0]].Add(item[1]);
	}

	HashSet<int> track = new HashSet<int>();

	foreach (var item in map)
	{
		bool flag = this.DFS(map, track, item.Key);

		if (flag == false)
		{
			return false;
		}
	}

	return true;
}

public bool DFS(Dictionary<int, List<int>> map, HashSet<int> track, int courseId)
{
	// If the course id already exists then return false, since there is a circular dependency of courses
	if (track.Contains(courseId))
	{
		return false;
	}

	track.Add(courseId);

	// Recursively call the DFS function on all prerequisites of course.
	foreach (int item in map[courseId])
	{
		bool flag = this.DFS(map, track, item);

		if (flag == false)
		{
			return false;
		}
	}

	// Remove te course id from the HaseSet to backtrack
	track.Remove(courseId);

	return true;
}
```

### Using Topological Sort (BFS) - O(V + E) time complexity

```csharp
public bool CanFinish(int numCourses, int[][] prerequisites) {
	HashSet<int>[] graph = new HashSet<int>[numCourses];
	int[] inDegree = new int[numCourses];

	for(int i = 0; i < numCourses; i++){
		graph[i] = new HashSet<int>();
	}

	// Build Graph
	foreach(int[] edge in prerequisites){
		int to = edge[0];
		int from = edge[1];

		graph[from].Add(to);
		inDegree[to]++;
	}

	Queue<int> bfsQueue = new Queue<int>();
	int count = 0;

	// Add all the nodes with zero indegrees since those are courses which donot have any dependency
	for(int i = 0; i < numCourses; i++){
		if(inDegree[i] == 0){
			bfsQueue.Enqueue(i);
		}
	}

	// Perform BFS and reduce the indegree as and when the node is visited. If at a point indegree of a node reduces to zero then add it to the queue.
	while(bfsQueue.Count > 0){
		int tempNode = bfsQueue.Dequeue();

		count++;
		foreach(int subNode in graph[tempNode]){
			inDegree[subNode]--;
			if(inDegree[subNode] == 0){
				bfsQueue.Enqueue(subNode);
			}
		}
	}

	return count == numCourses;
}
```

repository: melwinalm/my-gatsby-blog

repo_name: melwinalm/my-gatsby-blog


text:
# Migration `20200626094556-auth-id-and-stripe-customer-are-required`

This migration has been generated by Terris Kremer at 6/26/2020, 9:45:56 AM.
You can check out the [state of the schema](./schema.prisma) after the migration.

## Database Steps

```sql
ALTER TABLE "public"."User" ALTER COLUMN "authId" SET NOT NULL,
ALTER COLUMN "stripeCustomer" SET NOT NULL;
```

## Changes

```diff
diff --git schema.prisma schema.prisma
migration<PHONE_NUMBER>3148-add-stripe-customer-to-users..20200626094556-auth-id-and-stripe-customer-are-required
--- datamodel.dml
+++ datamodel.dml
@@ -1,7 +1,7 @@
 datasource DS {
   provider = "postgresql"
-  url = "***"
+  url = "***"
 }
 generator client {
   provider      = "prisma-client-js"
@@ -12,7 +12,7 @@
 model User {
   id    Int     @id @default(autoincrement())
   email String  @unique
-  authId String?
-  stripeCustomer String?
+  authId String
+  stripeCustomer String
 }
```

repository: MarkDuLJ/redwood-stripe-example

repo_name: MarkDuLJ/redwood-stripe-example


text:
# glugger

[![Build Status](https://api.travis-ci.org/zxsecurity/glugger.svg?branch=master)](https://travis-ci.org/zxsecurity/glugger)

A really faster DNS bruteforcer.
It lacks features.

## thanks
Thanks to [subbrute](https://github.com/TheRook/subbrute) for the wordlist

## todo
* investigate benifit of having multiple resolvers rather than relying on the system resolver
* investigate whether to lookup against domain nameservers directly

## performance
Quick benchmarking shows the following difference in resolvers as at commit 8534b8728c7dcf02c5003945f84d613392785da5, with a 2000 thread test:
*go*:
```
ss23@crisp ~/glugger $ time GODEBUG=netdns=go ./main -domain [*] -threads 2000
real    0m48.919s
user    0m5.793s
sys     0m2.927s
```

*cgo*:
```
ss23@crisp ~/glugger $ time GODEBUG=netdns=cgo ./main -domain [*] -threads 2000

real    2m27.202s
user    0m3.627s
sys     0m4.527s
```

repository: Furze/glugger

repo_name: Furze/glugger


text:
## _Trojan Yeti_

#### _Legend says:_
> Do you know that you can use shapeshifters as a time-bomb?

#### _Goals:_
+ _Defeat the ogres_

#### _Topics:_
+ **Strings**
+ **Variables**
+ **Return Statements**
+ **Array Length**
+ **Accessing Properties**
+ **Vectors**

#### _Solutions:_
+ **[JavaScript](trojanYeti.js)**
+ **[Python](trojan_yeti.py)**

#### _Rewards:_
+ 283 xp
+ 121 gems

#### _Victory words:_
+ _THE NEFARIOUS YETIS OF TROY._

___

### _HINTS_

Some of our peasants are wereyeti and they will transform soon.

Process the messy list of names from the sergeant and send shapeshifters into the ogre camp.

___

Usually text data isn't **clean** and it must be processed before it can be used. For example, in this level, names in the list are separated by commas and have excess whitespace. To get **clean** names, we need to split the list by commas and then `trim()` leading and trailing whitespaces for each word.

```javascript
var someList = "   words   , split   ,weird,   way";
var words = someList.split(",");
var secondWord = words[1];
console.log(secondWord);  // " split   " -> excess whitespace.
var cleanedSecondWord = secondWord.trim();
console.log(cleanedSecondWord);  // "split" -> it's better.
```

___

repository: ripssr/Code-Combat

repo_name: ripssr/Code-Combat


text:
Speed Typer
====

Introduction
------------

This is a GUI only game made using Unity, based on the Finger Frenzy flash game. Type as fast and accurate as you can to complete each challenge.

Old script still attached but disabled. Styling is toggled.

Version 0.1.1

Purpose
-------

GUI only remake of the Finger Frenzy flash game.

To-do list
==========

☑ Levels

- ☑ Menu

- ☑ Game

- ☑ Options

☐ Extras

- ☑ High scores

- ☐ Styled graphics

- ☐ Resizing menus

- ☑ Survival

- ☑ Custom game

- ☑ Other challenges

- ☑ Description of challenges

- ☑ High score for challenges

Map

☑ = finished

☐ = in progress

repository: IanEarnest/Speed-Typer

repo_name: IanEarnest/Speed-Typer


text:
# Build System Playground
This is a playground to try out different build systems.

***

## Notes
These might be good to put into a Makefile or something else in order for other people to know how to use this build system.

### To build
If ./build doesn't exist than 'meson build' will need to be ran

Once ./build exists than you will need to to do the following 'ninja-build -C build'

### To run tests
You can run the test by using  'ninja-build -C build test'.

You can run the Google test executable yourself while in the ./build directory

You can run mesontest from the root directory.

The ninja-build and mesontest option will log the output the results from the test to a file in ./build/seson-logs/testlog.[txt json]

gha_language: CMake