text:
---
seo:
  title: Why are the Pro plans recommended above all others?
  description: Why are the Pro plans recommended above all others?
  keywords:
title: Why are the Pro plans recommended above all others?
weight: 0
layout: page
zendesk_id: 205441048
navigation:
  show: true
---

The Pro plans come with all the features we offer. Free and Essential plans are designed to fulfill specific use cases, and as a result can lack some features you might need.

One of the best reasons to go Pro is getting a dedicated IP address. Sending from a dedicated IP address allows you better control over your deliverability and sending reputation.

For more info on what plans come with what features, check out our [Pricing page](https://sendgrid.com/pricing)!

repository: jstvz/docs

branch_name: refs/heads/develop

gha_language: HTML

repo_name: jstvz/docs


text:
---
templateKey: home-page
excerpt: >-
  Alistair Mork-Chadwick is a Counselling psychologist based in Howick. He
  offers personal counselling, career guidance, psychological assessments and
  mindfulness training.
slider:
  - heading1: Inspiring Leaders
    heading2: Alistair Mork-Chadwick
    image:
      alt: Leadership Development
      image: /img/leadership-development.jpg
    subheading: Counselling Psychologist
sliderLinks:
  - name: Leadership Development
    link: "#leadership-development"
    image:
      alt: Leadership Development to advance your career
      image: "/img/leadership-development-slider-icon.jpg"
  - name: Employee Wellness Support
    link: "#employee-wellness-support"
    image:
      alt: Employee Wellness Support
      image: "/img/employee-wellness-support-slider-icon.jpg"
ldArea:
  blurb:
    paragraphs:
      - paragraph: >-

I offer businesses, and other organisations, a variety of services to support Leadership Development. These include short training programmes and seminars that are primarily designed to strengthen work engagement, Emotional Intelligence (EQ) in the workplace, stress management, and interpersonal communication amongst other key leadership skills and competencies.

  heading: Leadership Development
  services:
    - service: Training Programmes
    - service: Seminars
ewsArea:
  blurb:
    paragraphs:
      - paragraph: >-

I offer a variety of Employee Wellness Support services. These include a range of talks and workshops that have been developed to assist employees in achieving and maintaining optimal health, high levels of work engagement and superior job performance. Many organisations choose to demonstrate care and support for their employees by investing in Employee Wellness Support services.

      - paragraph: >-

Individual counselling is also offered to organisations for those individuals who require crisis intervention and/or personal assistance with the management of some aspect of their life.

      - paragraph: >-

Mindfulness Training is offered to organizations and individuals in the form of a six-week programme that focuses on building mindfulness skills to help individuals address many of the difficult challenges associated with living and working in a fast-paced, stressful world.  The programme provides the tools and skills to improve stress management skills, workplace effectiveness, and happiness.

  heading: Employee Wellness Support
  services:
    - service: Talks & Workshops
    - service: Counselling for Individuals
    - service: Mindfulness Training
aboutMeArea:
  blurb:
    paragraphs:
      - paragraph: >-
          "Each person is unique. Our ability to manage stress, our dietary and movement habits, and our relationships, amongst other factors, all affect our mental health, including our emotional and intellectual functioning. In other words, there are multiple factors that play a role in determining whether an individual is able to sustain high levels of work engagement, happiness and productivity in the workplace."
  heading: Alistair Mork-Chadwick
  personPicture:
    alt: Alistair Mork-Chadwick
    image: /img/alistair-mork-chadwick-2.jpg
coursesArea:
  blurb: ""
  heading: Leaderships Development - Upcoming Courses
articlesArea:
  blurb: >-
    I read widely to keep abreast of the latest clinical research and the top
    thinkers in my field.  Here I share articles which you might find useful or
    inspiring.
  heading: Recent Articles
testimonialsArea:
  testimonials:
    - author: "Mindfulness Course participant – March 2017"
      quote: >-
        …I’m much more aware of what is going on around me and how I am feeling… I take stock of what is happening and, when flustered, use the techniques to keep me grounded and less emotional…
---

I offer businesses, and other organisations, a variety of services to support Leadership Development. These include short training programmes and seminars that are primarily designed to strengthen work engagement, Emotional Intelligence (EQ) in the workplace, stress management, and interpersonal communication amongst other key leadership skills and competencies.

I offer a variety of Employee Wellness Support services. These include a range of talks and workshops that have been developed to assist employees in achieving and maintaining optimal health, high levels of work engagement and superior job performance. Many organisations choose to demonstrate care and support for their employees by investing in Employee Wellness Support services.

Individual counselling is also offered to organisations for those individuals who require crisis intervention and/or personal assistance with the management of some aspect of their life.

Mindfulness Training is offered to organizations and individuals in the form of a six-week programme that focuses on building mindfulness skills to help individuals address many of the difficult challenges associated with living and working in a fast-paced, stressful world. The programme provides the tools and skills to improve stress management skills, workplace effectiveness, and happiness.

license: MIT

repository: homearanya/inspiring-leaders

branch_name: refs/heads/master

extension: md

gha_language: CSS

gha_license_id: MIT

license_type: permissive

repo_name: homearanya/inspiring-leaders


text:
# nc (netcat)

Listen for or launch TCP/UDP connections.

Busybox includes `awk`, thus Alpine Linux does.

## Port scan

Check if localhost port 80 is open:

	nc -vz <IP_ADDRESS> 80

Nothing will be shown without verbose output (`-v`).

## Simple TCP connection

In one terminal, start a server on port 1337:

	nc -l 1337

In another terminal, connect to the server:

	nc <IP_ADDRESS> 1337

Typing in either terminal and pressing Enter will show the message in the other terminal.
This can be terminated by EOF (^D) or Ctrl+C (^C).

## Links

- [netcat @ Wikipedia](https://en.m.wikipedia.org/wiki/Netcat)

repository: MattMS/shelp

gha_language: JavaScript

repo_name: MattMS/shelp


text:
# splunk-vagrant-ansible-collections

This repository is a personal collection of configuration files and scripts that make an heavy use of Vagrant and Ansible to create on the fly full Splunk environments for testing and development purposes.

These repositories will use:

- Virtualbox as the virtualization layer (but you could use other provider), See:https://www.virtualbox.org
- Vagrant, an incredibly powerful tool, See: https://www.vagrantup.com

Running these virtual environments will require a modern enough computer with physical memory, and fast storage.

Following items are available:

## [create_monosite_cluster](https://github.com/guilhemmarchand/splunk-vagrant-ansible-collections/tree/master/create_monosite_cluster)

This scenario uses Vagrant and Ansible to create on a fly a mono-site Splunk cluster with Nmon Performance app deployment.

Instructions are available in the [README](https://github.com/guilhemmarchand/splunk-vagrant-ansible-collections/tree/master/create_monosite_cluster) of the repository

## [create_multisite_cluster](https://github.com/guilhemmarchand/splunk-vagrant-ansible-collections/tree/master/create_multisite_cluster)

This scenario uses Vagrant and Ansible to create on a fly a mutli-site Splunk cluster with Nmon Performance app deployment.

Instructions are available in the [README](https://github.com/guilhemmarchand/splunk-vagrant-ansible-collections/tree/master/create_multisite_cluster) of the repository

## [create_standalone_multiple_indexes](https://github.com/guilhemmarchand/splunk-vagrant-ansible-collections/tree/master/create_standalone_multiple_indexes)

This scenario uses Vagrant and Ansible to create on a fly a Splunk server with Nmon Performance app deployment. (multi-indexes deployment)

Instructions are available in the [README](https://github.com/guilhemmarchand/splunk-vagrant-ansible-collections/tree/master/create_standalone_multiple_indexes) of the repository


text:
# Transformerizer

A parallel transformation library with a producer-consumer design

[![Build Status](https://ci.appveyor.com/api/projects/status/j356vaaec24g009q?svg=true)](https://ci.appveyor.com/project/bungeemonkee/transformerizer) [![Coverage Status](https://coveralls.io/repos/github/bungeemonkee/Transformerizer/badge.svg?branch=master)](https://coveralls.io/github/bungeemonkee/Transformerizer?branch=master)

## Description

Transformerizer is a simple transformation library that allows you to run multi-step trasnformations in parallel. Each step can run in parallel with each other using a producer/consumer design and with itself by setting a differnet number of threads to process each step.

## Installation

The easiest way to install this is using nuget: [https://www.nuget.org/packages/Transformerizer](https://www.nuget.org/packages/Transformerizer)

## Usage

Usage is simple: any enumerable can begin a transformation by calling the `BeginTransform(..)` extension method. Then call `ThenTransform(...)` as necessary followed by `EndTransform(...)`.

```csharp

var enumerable = new int[] { 1, 2, 3, 4, 5, };

var result = enumerable
    .BeginTransform(x => x * 5, 1)
    .ThenTransform(x => x / 3, 2)
	.EndTransform();
```

## Bugs And Feature Requests

Any TODO items, feature requests, bugs, etc. will be tracked as GitHub isues here:
[https://github.com/bungeemonkee/Transformerizer/issues](https://github.com/bungeemonkee/Transformerizer/issues)

repository: bungeemonkee/Transformerizer

repo_name: bungeemonkee/Transformerizer


text:
# cypress-ts-ancient

Cypress TS Project with Report Pages for Ancient

### Setup

```
git clone https://github.com/lamkovod/cypress-ts-ancient.git
cd cypress-ts-ancient
npm i
```

### Tech

* [Cypress](https://github.com/cypress-io/cypress)
* [Mocha](https://github.com/mochajs/mocha)
* [Mochawesome](https://github.com/adamgruber/mochawesome)
* [Allure](https://github.com/allure-framework)
* [TypeScript](https://github.com/microsoft/TypeScript)

Published report: https://lamkovod.github.io/cypress-ts-ancient/

repository: lamkovod/cypress-ts-ancient

branch_name: refs/heads/main

repo_name: lamkovod/cypress-ts-ancient


text:
---
layout: default
---

# 1993-03-03 - Just came back.. (fwd)

## Header Data

From<EMAIL_ADDRESS>(John Coryell.)

To<EMAIL_ADDRESS>Message Hash: cb38d9377d00792137d136540455bdc489c9a504b4bfcc8d4dff135dcd979c9d

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-03-03 15:47:20 UTC

Raw Date: Wed, 3 Mar 93 07:47:20 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(John Coryell.)
Date: Wed, 3 Mar 93 07:47:20 PST
To<EMAIL_ADDRESS>Subject: Just came back.. (fwd)
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Newsgroups: alt.cyberspace
From<EMAIL_ADDRESS>(Richard A Ciordia -- Personal Account)
Subject: Just came back..
Message-ID<EMAIL_ADDRESS>Organization: CONCERT-CONNECT -- Public Access UNIX
Date: Wed, 24 Feb 1993 04:21:17 GMT
Lines: 6

Just came back from a VR Lecture, hosted by one of the Directors at Autodesk.
There are some new VR releases comming out that is Wicked.. Lower cost too.
Anyhow... It was way cool.. 3d-Studio, for those who havent used, grab a copy
it's a blast.. Easy to make, rend, animate.. Hasta..
Andy

{% endraw %}
```

## Thread

+ Return to [March 1993](/archive/1993/03)

+ Return to<EMAIL_ADDRESS>(John Coryell.)](/authors/jcoryell_at_nwu_edu_john_coryell_)"

+ 1993-03-03 (Wed, 3 Mar 93 07:47:20 PST) - Just came back.. (fwd) -<EMAIL_ADDRESS>(John Coryell.)_


text:
# Week 3. Python for Everybody

## Authorship

+ Name: Santiago Botero S.
+ E-mail<EMAIL_ADDRESS>+ Date: 19/01/2020
+ Encoding: UTF-8

## Writing paragraphs of code

+ Python scripts
  - Interactive mode
  - Scripts (`*.py`)

+ Program flow
  - Sequential steps
  - Conditional steps
  - Repetitive steps

## Hello word assignment

repository: sboteros/ProgrammingForEverybody

repo_name: sboteros/ProgrammingForEverybody


text:
# dlfree-downloader
Automatically Download from dl.free.fr

# Install
Make sure your environment have composer installed.
1. Clone this repository or download the source zip
2. Install all dependency with `composer install`

# Usage
`php dlfree.php <url> [proxy]`

repository: argonvx/dlfree-downloader

gha_language: PHP

repo_name: argonvx/dlfree-downloader


text:
# thincloud-test-rails [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/newleaders/thincloud-test-rails)

## Description

Opinionated testing framework dependencies and configuration for Rails applications, built on [`thincloud-test`](http://newleaders.github.com/thincloud-test).

[New Leaders](https://newleaders.com) uses this gem to manage the following dependencies:

* [capybara](https://github.com/jnicklas/capybara)
* [database_cleaner](https://github.com/bmabey/database_cleaner)
* [factory_girl_rails](https://github.com/thoughtbot/factory_girl_rails)
* [minitest-rails](https://github.com/blowmage/minitest-rails)
* [minitest-rails-capybara](https://github.com/blowmage/minitest-rails-capybara)
* [minitest-rails-shoulda](https://github.com/bousquet/minitest-rails-shoulda)
* [shoulda-matchers](https://github.com/thoughtbot/shoulda-matchers)

## Requirements

### Ruby

This gem has been tested against the following Ruby versions:

* 1.9.3

### Rails

This gem requires Rails 3.2.11+ and has been tested on the following versions:

* 3.2

## Installation

Add this line to your application's Gemfile:

``` ruby
gem "thincloud-test-rails"
```

And then execute:

```
$ bundle
```

Or install it yourself as:

```
$ gem install thincloud-test-rails
```

## Usage

The gem manages the test framework dependencies for you and provides a generator (`thincloud:test`) to bootstrap a test environment for your Rails application.

To configure your application in one easy step, run the following:

```
$ rails g thincloud:test
```

This generator will do the following:

* Remove any existing `Test::Unit`-generated content
* Run the `mini_test:install` generator for `minitest-rails`
* Add `test/support/*` files which match New Leaders conventions
* Inject a line into `config/application.rb` to require the `thincloud/test/rails/railtie` file

Once this is complete, you will have a complete test setup. Run `rake` and enjoy! :tada: :balloon:

## Contributing

1. [Fork it](https://github.com/newleaders/thincloud-test-rails/fork_select)
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Added some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. [Create a Pull Request](https://github.com/newleaders/thincloud-test-rails/pull/new)

## License

* Freely distributable and licensed under the [MIT license](http://newleaders.mit-license.org/2013/license.html).
* Copyright (c) 2013 New Leaders ([opensource@newleaders.com](opensource@newleaders.com))
* [https://newleaders.com](https://newleaders.com)

repository: dreamr/thincloud-test-rails

repo_name: dreamr/thincloud-test-rails


text:
# Fourth exercise

What we will do:

* Configure and start Sauce To Go
* Run a few tests
* Check results in Sauce Labs

### Start [Sauce To Go](https://opensource.saucelabs.com/sauce-togo/)

1. If not done before, create a Sauce Labs account (free trial) at https://saucelabs.com/sign-up
2. If using GitPod or Linux:
    * Under the `exercise-4` directory, create the `assets` directory: `mkdir assets`
    * Change the permissions of the directory: `sudo chown 1200:1201 assets`
3. If using GitPod or Linux, on the `exercise-4` directory:
    * In the `config.toml` file, replace `url` with the result of `hostname -I` and port `2375`.
    * E.g. `url = "http://<IP_ADDRESS>:2375"`
4.  Head to your machine/instance url, and check the port `4444`

### Explore the Grid

1. While being on the Grid site, explore the different Nodes, available browsers, and tabs.

### Run a few tests

1. Explore the tests located under the `exercise-4/tests-exercise-4`, specifically the `SauceToGoTest` class.
2. If you do not have your Sauce user and accessKey as environment variables, then:
    * Replace `System.getenv("SAUCE_USERNAME")` with your Sauce username.
    * Replace `System.getenv("SAUCE_ACCESS_KEY")` with your Sauce accessKey.
    * You can always get your username and accessKey at https://app.saucelabs.com/user-settings.
3. Open a new terminal, and under the `exercise-4/tests-exercise-4`, run `mvn clean test`.
4. Head to the Grid UI, and see how tests get executed.
5. When you are done, under the `exercise-4` directory, type `Ctrl+C` to stop the Sauce To Go
6. Head to https://accounts.saucelabs.com/ to check the results.


text:
---
title: throttleWithTimeout -
---
//[Extensions for Jetpack Lifecycle](../../index.md)/[it.czerwinski.android.lifecycle.livedata](index.md)/[throttleWithTimeout](throttle-with-timeout.md)

# throttleWithTimeout
[androidJvm]
Content
fun <[T](throttle-with-timeout.md)> [LiveData](https://developer.android.com/reference/kotlin/androidx/lifecycle/LiveData.html)<[T](throttle-with-timeout.md)>.[throttleWithTimeout](throttle-with-timeout.md)(timeInMillis: [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html), context: [CoroutineContext](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines/-coroutine-context/index.html) = EmptyCoroutineContext): [LiveData](https://developer.android.com/reference/kotlin/androidx/lifecycle/LiveData.html)<[T](throttle-with-timeout.md)>
More info

Returns a [LiveData](https://developer.android.com/reference/kotlin/androidx/lifecycle/LiveData.html) emitting values from this LiveData, after dropping values followed by newer values before [timeInMillis](throttle-with-timeout.md) expires.

Delay will be applied on a thread determined by the given [context](throttle-with-timeout.md).

**Example:**

val isLoadingLiveData: LiveData<Boolean> = ...
val isLoadingThrottledLiveData: LiveData<Boolean> = isLoadingLiveData.throttleWithTimeout(
    timeInMillis = 1000L,
    context = viewModelScope.coroutineContext
)

gha_language: SCSS


text:
# csc648 Repository

## Please when ready add your teams application URL or IP to the repository description. This will help with grading. Teams are expected to keep this value up to date.

## Please do the following steps before completing Milestone 0.
1. Change the name of the repository. All that needs to change is the NN to your respective team number. Team numbers whose value is less than 10, please pad with a 0. Ex team 1 is Team01 team 11 is Team11. Please make sure to also remove the username from the repository as well. Teams with incorrectly name repository will have points deducted from their milestone 0 grades.
      - Please follow the naming convention assigned by your instructor.

1. PLEASE REMOVE THE USERNAME FROM THE REPOSITORY NAME!!!

2.  For it to count, they must ACCEPT the invite.

3. Fill out the table below

| Student Name       | Student Email              | GitHub Username         |
|    :----------:    |     :----------------:     |     :-------------:     |
| Naweeda Qeyam      |<EMAIL_ADDRESS>      | Naweeda                 |
| Joshua Hansen      |<EMAIL_ADDRESS>   | Joshlha                 |
| Manual Hernandez   |<EMAIL_ADDRESS>| mhernandez29            |
| Marvin Thai        |<EMAIL_ADDRESS>     | mathai1                 |
| Austin Bernard     |<EMAIL_ADDRESS>| Austinbernard21         |
| Dang Anh Tu Nguyen |<EMAIL_ADDRESS>   | margonguyen             |

## NO code needs to be stored in the root of your repository. You may rename the application folder if you like to your team's application name. But all source code related to your team's application should be stored inside the application folder.

## Group Weekly Zoom Meeting Link:
https://sfsu.zoom.us/j/93672565671?pwd=MmpONDlvdXJMVUZiR3pmUlo4dHlQdz09

repository: Naweeda/Software-Development-Project

repo_name: Naweeda/Software-Development-Project


text:
# COVID19-India-Data-API

COVID19India API provides you with the details of the Country Cases and the State Cases as per the data updated in the MyGOV website. [Source](https://www.mygov.in/corona-data/covid19-statewise-status) ▶

**API Homepage:** [COVID19 India API](https://lnkd.in/fkUdbur) ⚡

[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/iSumitBanik/COVID19-India-Data-API/graphs/commit-activity) [![GitHub stars](https://img.shields.io/github/stars/iSumitBanik/COVID19-India-Data-API.svg?style=flat&label=☆Star&maxAge=2592000)](https://github.com/iSumitBanik/COVID19-India-Data-API/stargazers) [![GitHub forks](https://img.shields.io/github/forks/iSumitBanik/COVID19-India-Data-API.svg?style=flat&label=Fork&maxAge=2592000)](https://github.com/iSumitBanik/COVID19-India-Data-API/network/)

## API Response - JSON 📨

**Country Data** 👨🏻⚕

```
      {
      active_cases: 2650,
      death_cases: 68,
      last_updated: "04 April 2020, 09:00 GMT+5:30",
      migrated_cases: 1,
      passengers_screened: "15,24,266",
      recovered_cases: 183
      }
```
**State Data** 😷
```
      {
      Confirmed: "161",
      Cured: "1",
      Death: "1 ",
      State: "AndhraPradesh"
      },
      {
      Confirmed: "10",
      Cured: "0",
      Death: "0 ",
      State: "AndamanNicobar"
      },
```
**ICMR Lab Details** 🔬
```
      {
      government_labs: [
      {
      address: " ICMR-Regional Medical Research Centre, Post Bag 13, Dollygunj, Port Blair, Andaman and Nicobar Islands 744103",
      name: " ICMR-Regional Medical Research Centre, Port Blair"
      }
      ],
            state_or_UT: "Andaman & Nicobar Island"
      },
      {
      collection_sites: [
      {
      address: "National Highway 52A, Old Assembly Complex, Naharlagun, Arunachal Pradesh 791110",
      name: "Tomo Riba Institute of Health & Medical Sciences, Naharlagun"
      }
      ],
            state_or_UT: "Arunachal Pradesh"
      },
```
**Helpline Numbers** 📞
```
      contact_details: [
      {
            helpline_number: "0866-2410978",
            state_or_UT: "Andhra Pradesh"
      },
      {
            helpline_number: "9436055743",
            state_or_UT: "Arunachal Pradesh"
      },
```
___________________________________________________________________________________________________________

## Built With

* [Flask](https://g.co/kgs/bDNDHj) - The web framework used

<!-- ## Contributing

Please read for details on our code of conduct, and the process for submitting pull requests to us. -->

## Authors

* **Sumit Banik** - [Sumit Banik](https://github.com/iSumitBanik)
* **Gaurav Sahadev** - [Gaurav Sahadev](https://github.com/Gauravsahadev)

## License

This project is licensed under the MIT License - see the [LICENSE](https://github.com/iSumitBanik/COVID19-India-Data-API/blob/master/LICENSE) file for details

### Feel free to contribute

Submit a Pull Request or drop an issue.


text:
# Social Network - Coriander
Coriander - Social Network school project. Was made for learning purpose only.

## Tech Stack

HTML / JSX, CSS, JavaScript, Node.js with Express.js, React, Redux, React Hooks, AWS3, axios, multer, Oauth, Socket.io, Postgres SQL, csurf, Cookie session package, Jest.

## Visuals
*

*

## Usage

```bash
npm install
node .
node bundle-server.js
```

## Features

* Login
* Register
* Make a friend request
* Cancel friend request
* Edit profile bio, profile picture
* Chat between each other
* Getting message notifications
* Ability to see how many users online currently
* Ability to see all your firends and friends request

## License

MIT License


text:
[![Contentstack](https://www.contentstack.com/docs/static/images/contentstack.png)](https://www.contentstack.com/)
# Contentstack dotnet

.NET SDK for Contentstack's Content Delivery API

## Getting Started

This guide will help you get started with our .NET SDK to build apps powered by Contentstack.

## SDK Installation and Setup

To use the .NET SDK, download it from here

Open the terminal and install the contentstack module via ‘Package Manager’ command

``` console
PM> Install-Package contentstack.csharp
```
And via ‘.Net CLI’
``` console
dotnet add package contentstack.csharp
```
To use the module in your application, you need to first Add Namespace to your class

``` cs
using Contentstack.Core; // ContentstackClient
using Contentstack.Core.Models; // Stack, Query, Entry, Asset, ContentType, ContentstackCollection
using Contentstack.Core.Configuration; // ContentstackOptions
```

## Initialize SDK

You will need to specify the API key, Access token, and Environment Name of your stack to initialize the SDK:

``` cs
ContentstackClient stack = new ContentstackClient("api_key", "delivery_token", "enviroment_name");
```
or:

``` cs
var options = new ContentstackOptions()
{
    ApiKey = "<api_key>",
    DeliveryToken = "<delivery_token>"
    Environment = "<environment>"
}
ContentstackClient stack = new ContentstackClient(options);
```

Once you have initialized the SDK, you can start getting content in your app.

## Basic Queries

### Get a Single Entry

To retrieve a single entry from a content type, use the code snippet given below:
``` cs
Entry entry = client.ContentType("product").Entry("blta464e9fbd048668c");
entry.Fetch<Product>().ContinueWith((t) => {
    if (!t.IsFaulted) {
        Console.WriteLine("entry:" + t.Result);
    }
});
```

### Get Multiple Entries

To retrieve multiple entries of a particular content type, use the code snippet given below:

``` cs
Query query = client.ContentType("product").Query();
query.Where("title", "welcome");
query.IncludeSchema();
query.IncludeCount();
query.ToJSON();
query.Find<Product>().ContinueWith((t) => {
    if (!t.IsFaulted) {
         ContentstackCollection<Product> result = t.Result;
         Console.WriteLine("result" + result.items);
    }
});
```
These were example of some of the basic queries of the SDK. For advanced queries, refer to our API reference documentation by visiting the link given below.

 > ***Note***: Currently, the .NET SDK does not support multiple content types referencing in a single query. For more information on how to query entries and assets, refer the [Queries](https://www.contentstack.com/docs/developers/apis/content-delivery-api/#queries) section of our Content Delivery API documentation.

### Paginating Responses
In a single instance, the [Get Multiple Entries](https://www.contentstack.com/docs/developers/dot-net/get-started-with-dot-net-sdk/#get-multiple-entries) query will retrieve only the first 100 items of the specified content type. You can paginate and retrieve the rest of the items in batches using the [skip](https://www.contentstack.com/docs/platforms/dot-net/api-reference/api/Contentstack.Core.Models.Query.html#Contentstack_Core_Models_Query_Skip_System_Int32_) and [limit](https://www.contentstack.com/docs/platforms/dot-net/api-reference/api/Contentstack.Core.Models.Query.html#Contentstack_Core_Models_Query_Limit_System_Int32_) parameters in subsequent requests.

``` cs
Query query = client.ContentType("product").Query();
query.Skip(20);
query.Limit(20);
query.Find<Product>().ContinueWith((t) => {
    if (!t.IsFaulted) {
         ContentstackCollection<Product> result = t.Result;
         Console.WriteLine("result" + result);
    }
});
```
## API Reference
Go through our .NET SDK API Reference guide to know about the methods that can be used to query your content in Contentstack.

[Read .NET API Reference Guide](https://www.contentstack.com/docs/platforms/dot-net/api-reference/api/index.html)

## Example
To help you get started, we have created a sample application that is powered by Contentstack .NET SDK. Click on the link below to read the tutorial of the app.

[.NET News Console App](https://www.contentstack.com/docs/example-apps/build-a-news-app-using-contentstack-dot-net-sdk)

### Helpful Links

- [Contentstack Website](https://www.contentstack.com)
- [Official Documentation](https://contentstack.com/docs)
- [Content Delivery API Docs](https://contentstack.com/docs/apis/content-delivery-api/)

repository: contentstack/contentstack-dotnet

gha_language: C#

repo_name: contentstack/contentstack-dotnet


text:
---
name: I have a question
about: I have a question
title: ''
labels: ''
assignees: AllenFang

---

**Question**
A clear and concise description of you question. In addition, please search issues before you open a question to make sure there's no any duplicated questions.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**codesandbox**
Please give a simple and minimal example on https://codesandbox.io so that we can reproduce it easily.


text:
# VSProjTypeExtractor

Visual Studio project type GUID extractor

## What is it all about?

**_VSProjTypeExtractor_** can be used in **[FASTBuild](http://fastbuild.org/docs/home.html)** together with the new
_VSProjectExternal_ function to automatically determine the `ProjectTypeGuid` from the actual external visual studio
project:
```
VSProjectExternal( 'SomeExternal-vsproj' )
{
    .ExternalProjectPath = 'path_to\ExternalProject.csproj'
}
```

## How does it work?

**_VSProjTypeExtractor_** consists of 2 DLLs, `VSProjTypeExtractorManaged.dll` which is written in C# and is responsible
of the actual work, by automating Visual Studio in the background for loading the project file just to be able to query
the type GUID, and the `VSProjTypeExtractor.dll` **C** wrapper which can be used in any native apllication to call this
functionality.

## Requirements, Usage

**_VSProjTypeExtractor_** targets .NET Framework v4.7.2, so the 2 DLLs which you can download from the
[Releases](https://github.com/lucianm/VSProjTypeExtractor/releases) section will need this version of the .NET framework
to be installed on your system. Just place them somewhere in the 'PATH' or along with FBuild.exe (a build supporting
_VSProjectExternal_, post-v0.99 in any case) in the same directory.

The module has a configuration file [VsProjTypeExtractorManaged.xml](https://github.com/lucianm/VSProjTypeExtractor/blob/master/VSProjTypeExtractorManaged/VsProjTypeExtractorManaged.xml),
please have a look in the comments there if logging should be enabled (it is default off) or Visual Studio automation timing needs to be tuned.

## Developer information on integrating in applications

Integrating **_VSProjTypeExtractor_** in your application is quite easy, you can do it eitehr by linking against
_VSProjTypeExtractor.lib_, which will make your application runtime dependent on **_VSProjTypeExtractor.dll_**, or even
simpler, by including [VSProjTypeExtractor.h](https://github.com/lucianm/VSProjTypeExtractor/blob/master/VSProjTypeExtractor/VSProjTypeExtractor.h)
after a `#define VSPROJTYPEEXTRACTOR_DYNLOAD` statement, which will benefit you of only requiring **_VSProjTypeExtractor.dll_**
at runtime if the _VSProjectExternal_ functionality is used without providing a `ProjectTypeGuid` in the BFF declaration.

### Static integration by linking against _VSProjTypeExtractor.lib_

- You will need the latest VSProjTypeExtractorSdk-x.x.x.x.zip from the [Releases](https://github.com/lucianm/VSProjTypeExtractor/releases) section.
- Make sure to link against _VSProjTypeExtractor.lib_;
- the most important API call is `Vspte_GetProjData`, on the first call it will start a hidden Visual Studio instance and create
a volatile solution, this will take few seconds on the first call, but subsequent calls (for reading several more project Guids from other files)
will be very quick;
- before any subsequent call, please make sure to call `Vspte_DeallocateProjDataCfgArray` on the already used ExtractedProjData object;
- optionally, at the end `Vspte_CleanUp()` can be called, but at application exit this will be called anyway on destruction of objects and garbage collection;
- sample code:
```
#include <VSProjTypeExtractor.h>

ExtractedProjData projData;;
bool bSuccess = Vspte_GetProjData(
    pathToYourExternalProject,
    projData);
if (bSuccess) {
    // projData will contain the project type Guid and config/platform pairs found in the project
}

// if Vspte_GetProjData needs to be called again subsequently, projData should be deallocated:
Vspte_DeallocateProjDataCfgArray(projData);

// optionally, when really no longer needed
Vspte_CleanUp();

```

### Dynamic (less invasive) integration

- Write a header, or [grab the one contained in the test application, *VSProjLoaderInterface.h*](https://github.com/lucianm/VSProjTypeExtractor/blob/master/VSProjTypeExtractorTest/VSProjLoaderInterface.h)
in which you should make sure to use exact copies of the #defines for VSPROJ_TYPEEXTRACT_MAXGUID_LENGTH and VSPROJ_MAXSTRING_LENGTH, and also of the structs ExtractedCfgPlatform and ExtractedProjData,
for the rest of the implementation you are of course free to modify the code as you like, but if it were a copy it should look like this sample:
```
/*
    Implements loading / unloading VSProjTypeExtractor.dll dynamically, in order to avoid linking against the .lib
*/

#include <Windows.h>

//
// still need to define these ourselves, as an exact copy of the  respective #defines and structs from VSProjTypeExtractor.h:
//
#define VSPROJ_TYPEEXTRACT_MAXGUID_LENGTH     39
#define VSPROJ_MAXSTRING_LENGTH              120

// configuration / platform pair
typedef struct
{
    char _config[VSPROJ_MAXSTRING_LENGTH];
    char _platform[VSPROJ_MAXSTRING_LENGTH];
} ExtractedCfgPlatform;

// extracted project data containing type GUID and array of found configuration / platform pairs
typedef struct
{
    char _TypeGuid[VSPROJ_TYPEEXTRACT_MAXGUID_LENGTH];
    ExtractedCfgPlatform* _pConfigsPlatforms;
    unsigned int _numCfgPlatforms;
} ExtractedProjData;

// prototypes of exported functions
typedef bool  (__stdcall *Type_GetProjData)(const char* projPath, ExtractedProjData* pProjData);
typedef void* (__stdcall *Type_CleanUp)(void);
typedef void* (__stdcall *Type_DeallocateProjDataCfgArray)(ExtractedProjData* pProjData);

//
// wrapper around the external VSProjTypeExtractor.dll functionality
class VspteModuleWrapper
{
private:
    VspteModuleWrapper()
    {}
    ~VspteModuleWrapper()
    {
        if (_hVSProjTypeExtractor)
        {
            Vspte_CleanUp();
            ::FreeLibrary(_hVSProjTypeExtractor);
            //
            _hVSProjTypeExtractor = NULL;
            _Vspte_GetProjData = nullptr;
            _Vspte_CleanUp = nullptr;
            _Vspte_DeallocateProjDataCfgArray = nullptr;
        }
    }
    Type_GetProjData _Vspte_GetProjData = nullptr;
    Type_CleanUp _Vspte_CleanUp = nullptr;
    Type_DeallocateProjDataCfgArray _Vspte_DeallocateProjDataCfgArray = nullptr;
    HMODULE _hVSProjTypeExtractor = NULL;

public:
    /** @brief  Access to singleton

    */
    static VspteModuleWrapper* Instance()
    {
        static VspteModuleWrapper s_Instance;
        return &s_Instance;
    }

    /** @brief  Loads VSProjTypeExtractor.dll if possible

        Needs to be called once before attempting to call @Vspte_GetProjData, @Vspte_DeallocateProjDataCfgArray or @Vspte_CleanUp
    */
    void Load()
    {
        try {
            if (!_hVSProjTypeExtractor)
            {
                _hVSProjTypeExtractor = ::LoadLibrary("VSProjTypeExtractor");
                if (_hVSProjTypeExtractor)
                {
                    _Vspte_GetProjData = reinterpret_cast<Type_GetProjData>(::GetProcAddress(_hVSProjTypeExtractor, "Vspte_GetProjData"));
                    _Vspte_CleanUp = reinterpret_cast<Type_CleanUp>(::GetProcAddress(_hVSProjTypeExtractor, "Vspte_CleanUp"));
                    _Vspte_DeallocateProjDataCfgArray = reinterpret_cast<Type_DeallocateProjDataCfgArray>(::GetProcAddress(_hVSProjTypeExtractor, "Vspte_DeallocateProjDataCfgArray"));
                }
            }
        }
        catch (...)
        {
        }
    }

    /** @brief  Queries if VSProjTypeExtractor.dll was successfully loaded

        Helpful for avoiding to call @Vspte_GetProjData, @Vspte_DeallocateProjDataCfgArray or @Vspte_CleanUp without effect
    */
    bool IsLoaded()
    {
        return _hVSProjTypeExtractor != NULL && _Vspte_GetProjData != nullptr && _Vspte_CleanUp != nullptr && _Vspte_DeallocateProjDataCfgArray != nullptr;
    }

    /** @brief  Retrieves basic project data from an existing project

        The project data is extracted by silently automating the loading of the project in a volatile solution of a new,
        hidden Visual Studio instance.

        @param[in] projPath path to visual studio project file
        @param[in,out] pProjData for receiving the project type GUID and existing configurations
    */
    bool Vspte_GetProjData(const char* projPath, ExtractedProjData* pProjData)
    {
        if (_Vspte_GetProjData)
        {
            return _Vspte_GetProjData(projPath, pProjData);
        }
        else
        {
            return false;
        }
    }

    /** @brief  Deallocates the configurations / platforms array of an ExtractedProjData instance already used in a call to @Vspte_GetProjData

        After a call to @Vspte_GetProjData and copying the data you're interested in from the ExtractedProjData object, you should call this
        in order to deallocate the configurations / platforms array with the correct runtime
    */
    void Vspte_DeallocateProjDataCfgArray(ExtractedProjData* pProjData)
    {
        if (_Vspte_DeallocateProjDataCfgArray)
        {
            _Vspte_DeallocateProjDataCfgArray(pProjData);
        }
    }

    /** @brief  Optionally closes the volatile solution and quits the Visual Studio instance

        After a call to @Vspte_GetProjData, the Visual Studio instance is kept up and running with the volatile solution loaded,
        in order to save time in subsequent calls to @Vspte_GetProjData. Cleanup is done anyway on application exit, so calling it
        explicitely is not necessary, it's provided more for testing purposes
    */
    void Vspte_CleanUp()
    {
        if (_Vspte_CleanUp)
        {
            _Vspte_CleanUp();
        }
    }
};
```

- As opposed to the static integration, a little bit more API calls and caution are needed, but for your convenience, a singleton `VspteModuleWrapper`
taking care of dynamically loading the DLL, mapping the function pointers and cleaning up is given in this sample header.
- Calling `VspteModuleWrapper::Instance()->Vspte_GetProjData`, the first time will start a hidden Visual Studio instance and create
a volatile solution, this will take few seconds on the first call, but subsequent calls (for reading several more project Guids and config/platform pairs from other files)
will be very quick;
- optionally, `VspteModuleWrapper::Instance()->Vspte_CleanUp()` can be called, but at application exit this will be called anyway on destruction of
objects and garbage collection
- for actually using the interface code, include this new header in your code and write something like:
```
#include "VSProjLoaderInterface.h"

if (!VspteModuleWrapper::Instance()->IsLoaded()) {
    // load the module if not already loaded
    VspteModuleWrapper::Instance()->Load();
}

// anytime before retrieving project guids, make sure to check if loading succeeded:
if (VspteModuleWrapper::Instance()->IsLoaded()) {
    ExtractedProjData projData;
    bool bSuccess = VspteModuleWrapper::Instance()->Vspte_GetProjData(
        pathToYourExternalProject,
        projData);
    if (bSuccess) {
        // projData will contain the project type Guid and config/platform pairs found in the project
    }

    // if Vspte_GetProjData needs to be called again subsequently, projData should be deallocated:
    VspteModuleWrapper::Instance()->Vspte_DeallocateProjDataCfgArray(projData);

    // call Vspte_GetProjData again...
    ...
}

...

// optionally, when really no longer needed
if (VspteModuleWrapper::Instance()->IsLoaded()) {
    VspteModuleWrapper::Instance()->Vspte_CleanUp();
}

```

© 2022 Lucian Muresan

repository: lucianm/VSProjTypeExtractor

repo_name: lucianm/VSProjTypeExtractor


text:
# Minicurl

Minicurl is a **very simple and limited** header-only C++ wrapper around libcurl, intended to make easier the use of HTTP GET, HTTP POST, file upload, and file download. All methods were implemented as static member functions and they can be used anywhere in your code without the need to manually initialize or instantiate anything. Be aware that the first call to any of them will also call the function *curl_global_init*, which is not thread-safe. The results are always returned as std::string. Check *test.cpp* for examples.

> This library depends on libcurl. To install the latter in your system, open the terminal and type:

	sudo apt-get install -y -f --install-suggests curl libcurl4-openssl-dev

> To compile the test, open the terminal and enter the command below (GCC 8 or later is required):

	g++ test.cpp -std=c++17 -lcurl -o test.out

*Copyright 2019 Jean Diogo (aka [Jango](mailto:jeandiogo@gmail.com))*


text:
# State Scripts & Secrets

This demonstrates a simple project for using [State Tool Scripts & Secrets]
on Google Cloud Build.

## Usage

Before you can run this example you'll need to set up a project
on the [ActiveState Platform], to do this reference the [Creating Custom Projects]
documentation. Ensure that you create project that uses a Linux 64bit platform.

Once you have created your project update the Dockerfile and the
activestate.yaml to use the namespace for your project rather than the
placeholder value.

This example uses secrets, read the *Private Projects and State Secrets*
in the [main readme] on how to set up cloud build to use State Secrets.

## Executing Your New Builder

Once configured you should be able to simply run

```
gcloud builds submit --config=cloudbuild.yaml
```

   [State Tool Scripts & Secrets]: https://docs.activestate.com/platform/state/start.html
   [ActiveState Platform]: https://www.activestate.com/products/platform/
   [Creating Custom Projects]: https://docs.activestate.com/platform/projects/custom-builds/
   [main readme]: ../../README.md

gha_language: Go


text:
# 2. chart library

Date: 2021-01-13

## Status

2021-01-13 proposed

2021-01-26 deprecated

2021-03-12 done

## Context

We need a simple chart library by split.

## Decision

[Plotters](https://github.com/38/plotters) - A rust drawing library for high quality data plotting for both WASM and native, statically and realtimely.

## Consequences

Consequences here...

repository: chalme/coco

gha_language: Rust

repo_name: chalme/coco


text:
# You are here!

![cartridge-you-are-here.png](doc/images/cartridge-you-are-here.png)

With this cartridge you can develope your own cartridge in a model driven way.

It provides Stereotypes, Transformations and CodeGenerators that make it very easy
to build a cartridge from scratch. This cartridge itself is developed with the
use of this metacartridge.

For example: Here is a screenshot of the (more complex) rest-cartridge model:
![cartridge-model.png](doc/images/cartridge-model.png)

gha_language: Java


text:
[![CircleCI](https://circleci.com/gh/X-DataInitiative/SCALPEL-Extraction.svg?style=shield&circle-token=6dd3a84c5ec9b9d3acac9e1ed156077eeadf9780)](https://circleci.com/gh/X-DataInitiative/SCALPEL-Extraction)
[![codecov](https://codecov.io/gh/X-DataInitiative/SCALPEL-Extraction/branch/master/graph/badge.svg?token=4a0h501t8P)](https://codecov.io/gh/X-DataInitiative/SCALPEL-Extraction)
[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
![Version](https://img.shields.io/github/v/release/X-DataInitiative/SCALPEL-Extraction?include_prereleases)

# SCALPEL-Extraction

SCALPEL-Extraction is a library part of the SCALPEL3 framework,
 resulting from a research Partnership between [École Polytechnique](https://www.polytechnique.edu/en) &
 [Caisse Nationale d'Assurance Maladie](https://assurance-maladie.ameli.fr/qui-sommes-nous/fonctionnement/organisation/cnam-tete-reseau)
 started in 2015 by [Emmanuel Bacry](http://www.cmap.polytechnique.fr/~bacry/) and [Stéphane Gaïffas](https://stephanegaiffas.github.io/).
 Since then, many research engineers and PhD students developped and used this framework to do
 research on SNDS data, the full list of contributors is available in [CONTRIBUTORS.md](CONTRIBUTORS.md).
 It provides concept extractors meant to fetch meaningful Medical Events & Patients from [Système National des Données de Santé (SNDS)](https://www.snds.gouv.fr/SNDS/Accueil) data.
 This library is based on [Apache Spark](https://spark.apache.org/). It reads flat data resulting from executing
 [SCALPEL-Flattening](https://github.com/X-DataInitiative/SCALPEL-Flattening) on raw SNDS data,
 and then extracts `Patients` and `Events` in three steps:

1) Reading the flat data from the files generated by the flattening step;
2) Extracting "raw" events (such as Drug Dispensations, Diagnoses, Medical Acts, etc.)
 and convert them to [Events](https://github.com/X-DataInitiative/SCALPEL-Extraction/blob/master/src/main/scala/fr/polytechnique/cmap/cnam/etl/events/Event.scala);
3) Transforming the "raw" events into "processed" events (such as follow-up periods,
 molecule exposures, outcomes, etc.) and convert them to
 [Events](https://github.com/X-DataInitiative/SCALPEL-Extraction/blob/master/src/main/scala/fr/polytechnique/cmap/cnam/etl/events/Event.scala);

Extracted data can be easily be used to perform interactive data analysis using
 [SCALPEL-Analysis](https://github.com/X-DataInitiative/SCALPEL-Analysis).

 > **Important remark** : This software is currently in alpha stage. It should be fairly stable,
 > but the API might still change and the documentation is partial. We are currently doing our best
 > to improve documentation coverage as quickly as possible.

## Usage

### Build
To build a JAR from this repository, you need SBT v. 0.13.15 (Scala Build Tool) & the SBT assembly plugin.
 You just need to run the following commands:

```shell script
git clone git@github.com:X-DataInitiative/SCALPEL-Extraction.git
cd SCALPEL-Extraction
sbt assembly
```

###Input and Output

SCALPEL-Extraction reads flat data resulting from executing SCALPEL-Flattening, which is saved in Parquet or ORC.
 It should select the correct format in the configuration([example](src/main/resources/config/fall/template.conf)).
 `read_file_format` is used to set the format to read flat data.

Once a job is finished, the results are saved in the file system (local file system or HDFS)
 in Parquet format or ORC format.
 `write_file_format` is used to set the format to save the results.
if the ORC format is set in the configuration files,
 it should add a special configuration in the spark-submit command `spark.sql.orc.impl=native`

### Configuration

Right now, configurations are tied to "studies". As study can be seen as a sub-package, eventually containing custom
 extractors, a main class orchestrating the extraction, and a default configuration.
For each study, a template configuration file containing the default values is defined.
When running the study main class, if a parameter needs change, one just needs to copy this template
 file, edit it by uncommenting and modifying the appropriate lines, and passing it to spark-submit
 using the `conf` argument.

For example, the template configuration file for a study on elderly falls and several drug groups association
 is defined  [here](src/main/resources/config/fall/template.conf). So, if one wants to
 override `min_purchases`, `purchases_window` and `cancer_definition`, they just need to create a
 copy of this file on the master server and uncomment these lines changing the appropriate values:

```hocon
# Previous line stay commented...

# exposures.purchases_window: 0 months // 0+ (Usually 0 or 6) Represents the window size in months. Ignored when min_purchases=1.
# exposures.end_threshold_gc: 90 days  // If periodStrategy="limited", represents the period without purchases for an exposure to be considered "finished".
# exposures.end_threshold_ngc: 30 days // If periodStrategy="limited", represents the period without purchases for an exposure to be considered "finished".
exposures.end_delay: 30 days         // Length of period to add to the exposure end to delay it (lag).

# drugs.level: "Therapeutic"           // Options are Therapeutic, Pharmacological, MoleculeCombination
drugs.families: ["Antihypertenseurs", "Antidepresseurs", "Neuroleptiques", "Hypnotiques"]

# Next lines stay commented...
```

This file should then be stored with the results, to keep a trace of which configuration was used
to generate a dataset. The commit number of the code used to extract events is included in
SCALPEL-Extraction results (metadata file). As a result, the configuration file and the metadata should be enough to reproduce a dataset extraction.

### Execution

The entry points for executing the extraction are study-specific, therefore within the `study`
 package. To steps to run the extraction for a given study are the following:

To start an extraction job, run the `spark-submit` command containing:
   - `--total-executor-cores` and `--executor-memory` arguments;
   - `--class` argument pointing to the study's main class;
   - the path to the jar file created by `sbt assembly`;
   - The name of the environment (i.e. the set default parameters of the study) to be used;
   - Eventually, a `--conf` parameter to override the environment parameters.

One can create an alias or script to make things easier. For example, for the
Pioglitazone study, one could run the following shell script:

```bash
#!/bin/sh
spark-submit \
  --driver-memory 40G \
  --executor-memory 110G \
  --total-executor-cores 150 \
  --conf spark.task.maxFailures=20 \
  --class fr.polytechnique.cmap.cnam.study.pioglitazone.PioglitazoneMain \
  SCALPEL-Extraction-assembly-2.0.jar conf=./overrides.conf env=cmap
```

## The Bulk Main
The Bulk Main is a special study that transforms all the SNDS data into our normalized format based on the Event class. It
is intended to simplify the complexity of the SNDS and ease the statistical analysis. The extractors available in the Bulk are listed here.

The steps to use the Bulk Main are:

   - Add a file under the directory `src/main/resources/config/bulk/paths`, for
   example, `my_env.conf`.
   - In `my_env.conf`, add the links to your flattened SNDS data. See `cmap.env` for an example.
   - In the file `src/main/resources/config/bulk/default.conf`, add the following
   ```
    my_env = ${root} {
    include "paths/my_env.conf"
    }
   ```
   - Build you JAR.
   - Using shell, execute the following script
   ```bash
   spark-submit \
     --total-executor-cores 160 \
     --executor-memory 18G \
     SCALPEL-Extraction-assembly-2.0.jar env=my_env
   ```
   - Use the resulting `metadata.json` to load and analyse your data using [SCALPEL-Analysis](https://github.com/X-DataInitiative/SCALPEL-Analysis).

## Implemented classes for data extraction

### Extractors
Our package offers ready-to-use Extractors intending to extract events from raw, flat SNDS
data and to output them into a simpler, normalized data format.
For more details, please read the companion paper.

| Extractor        | SNDS data Source           | Description  |
|-------------|-------------|-----|
| Act      | MCO | Extracts CCAM acts available PMSI-MCO (Public hospitalization)|
| Act      | DCIR     |  Extracts CCAM acts available DCIR (One day & liberal acts)|
| Act      | MCO-ACE     |  Extracts CCAM acts available MCO-ACE|
| Main Diagnosis | MCO     |    Extracts the main diagnosis coded in available PMSI-MCO in CIM-10 format|
| Linked Diagnosis | MCO     |    Extracts the linked diagnosis coded in available PMSI-MCO in CIM-10 format|
| Associated Diagnosis | MCO     |    Extracts the associated diagnosis coded in available PMSI-MCO in CIM-10 format|
| Long Term Diseases      | IMB     |  Extracts Long term diseases ('ALD' in French) diagnosis available IMB |
| Hospital stay | MCO     |    Extracts hospital stays|
| Main Diagnosis | MCO     |    Extracts the main diagnosis coded in available PMSI-MCO in CIM-10 format|
| Drug Purchases | DCIR     |    Extracts drug purchases available in DCIR. Can be adjusted to any the desired level: CIP13, molecule, Pharma class & Thera class.|
| Patients      | Mainly IR-BEN-R     |  Extracts available patients with their gender, birth date, and eventual death date|

### Transformers
Transformers combine multiple events produced by the extractors to produce higher-level, more complex Events.
 Although they are often study-specific, the transformers code can be configured up to some point.
 If they are not flexible enough for your use-case, they can be used as a good starting point for
 your custom implementations.

| Transformer        | Combines           | Description  |
|-------------|-------------|-----|
| FollowUp        | Multiple           | Combines multiple events to define a follow-up period per patient. |
| Exposures      | Drug Purchases & Followup | Combines drugs purchases events to create Exposures. Offer multiple strategies such as Limited & Unlimited exposure duration.|
| Outcome | Acts & Diagnosis | Creates complex outcomes based on Acts & Diagnosis data. Our list includes Fractures, Heart Failure, Infarctus, Bladder cancer. |

## Citation

If you use a library part of _SCALPEL3_ in a scientific publication, we would appreciate citations. You can use the following bibtex entry:

    @article{bacry2020scalpel3,
      title={SCALPEL3: a scalable open-source library for healthcare claims databases},
      author={Bacry, Emmanuel and Gaiffas, St{\'e}phane and Leroy, Fanny and Morel, Maryan and Nguyen, Dinh-Phong and Sebiat, Youcef and Sun, Dian},
      journal={International Journal of Medical Informatics},
      pages={104203},
      year={2020},
      publisher={Elsevier}
    }

## Contributing

### Coding guidelines

SCALPEL-Extraction is implemented in Scala 2.11.12 with Spark 2.3 and HDFS (Hadoop 2.7.3).

The code should follow the [Databricks Scala Style Guide](https://github.com/databricks/scala-style-guide),
 (which relies on [Scala Style Guide](http://docs.scala-lang.org/style/)). You can use linters in your IDE (for instance scalastyle, shipped by default with IntelliJ) to help you comply with these stylesheets.

Also we should follow, as much as possible, clean code best practices (for instance, or the Clean Code).
Among them :
   - Meaningful variable name
   - Methods should be small and only do one thing
   - Avoid useless complexity

### Imports
Our imports are based on the style suggested at the following
**[link](https://github.com/databricks/scala-style-guide#imports)**, with a few modifications.

Therefore, every contributor should update their IDE accordingly. On IntelliJ:
 (`Settings > Editor > Code Style > Scala > Imports`), we use the following importing order:

    java
    javax
    scala
    all other imports
    org.apache.spark
    fr.polytechnique

repository: harshblue/SCALPEL-Extraction

repo_name: harshblue/SCALPEL-Extraction


text:
## Running Client Codebase
Appsmith's client (UI/frontend) uses the ReactJS library and Typescript. The application also uses libraries like react-redux and redux-saga for workflows. We use VS Code Editor as our primary editor

### Pre-requisites:

On your development machine, please ensure that:

1. You have `docker` installed in your system. If not, please visit: [https://docs.docker.com/get-docker/](https://docs.docker.com/get-docker/)
2. You have `mkcert` installed. Please visit: [https://github.com/FiloSottile/mkcert#installation](https://github.com/FiloSottile/mkcert#installation) for details. For `mkcert` to work with Firefox you may require the `nss` utility to be installed. Details are in the link above.
3. You have `envsubst` installed. use `brew install gettext` on macOS. Linux machines usually have this installed.
4. You have cloned the repo in your local machine.

### Create local HTTPS certificates:

1. Run the following command from the project root.

```bash
cd app/client/docker && mkcert -install && mkcert "*.appsmith.com" && cd ../../..
```

This command will create 2 files in the `docker/` directory:

- `_wildcard.appsmith.com-key.pem`
- `_wildcard.appsmith.com.pem`

2. Add the domain `dev.appsmith.com` to `/etc/hosts`.
```bash
echo "<IP_ADDRESS>	dev.appsmith.com" | sudo tee -a /etc/hosts
```

3. Run the script `start-https.sh` in order to start the nginx container that will proxy the frontend code on your local system.
```bash
cd app/client
./start-https.sh
```

#### WSL (Windows Subsystem for Linux)

- Because Docker Desktop for Windows does not support `host` network mode (https://docs.docker.com/network/host/), to run `start-https.sh` in WSL, in `start-https.sh`, remove the `--network host` option from the call to the `docker` command, then in `app/client/docker/templates/nginx-linux.conf.template`, replace all occurrences of `http://localhost:3000` with  `http://host.docker.internal:3000`.
- If you are accessing `dev.appsmith.com` from a browser in Windows, you will need to add `dev.appsmith.com` to Windows' `C:\Windows\System32\drivers\etc\hosts` instead of `/etc/hosts`. Alternately, you can install a desktop environment in WSL to open `dev.appsmith` from a browser in WSL.
```
<IP_ADDRESS>	dev.appsmith.com
```

### Steps to build & run the code:
1. Run `yarn`
2. Run `yarn start`

🎉 Your Appsmith client is now running on https://dev.appsmith.com.

    This URL must be opened with https and not have the port 3000 in it

Your client is pointing to the cloud staging server https://release-api.appsmith.com

#### If yarn start throws mismatch node version error
This error occurs because the node version is not compatible with the app environment. In this case Node version manager can be used which allows multiple
node versions to be used in different projects. Check below for installation and usage details:
1. Install a node version manager. For eg: check [nvm](https://github.com/nvm-sh/nvm) or [fnm](https://github.com/Schniz/fnm).
2. In the root of the project, run `nvm use 10.16.3` or `fnm use 10.16.3`.

#### If you would like to hit a different Appsmith server:
- Change the API endpoint in the Nginx configuration files (`app/client/docker/templates/nginx-linux.conf.template` or `app/client/docker/templates/nginx-mac.conf.template`).
- Run `start-https.sh` script again.
- Run
```bash
REACT_APP_ENVIRONMENT=DEVELOPMENT HOST=dev.appsmith.com craco start
```

#### If you are unable to run docker:

1. Make the values in `nginx-mac.conf.template` empty. None of those properties are required.
2. `proxy_pass` value must be changed from `http://host.docker.internal:3000` to `http://localhost:3000`
3. Generate the certificates manually via `mkcert`. Check the command in `start-https-server.sh` file.
4. Change the value of the certificate location for keys `ssl_certificate` & `ssl_certificate_key` to the place where these certificates were generated.
5. If you ran `./start-https`, but containers failed to start (you have to check with `docker ps` since it fails silently). Some Linux distros (`Ubuntu` for example) have installed and running `apache2` webserver on port `80`. This can result in `Address already in use` error (you can check with `docker logs wildcard-nginx`). Simple solution for this is simply turning it off temporarily with `sudo systemctl stop apache2`. After that just run `./start-https` again.

repository: A-Scratchy/appsmith

branch_name: refs/heads/release

gha_language: TypeScript

repo_name: A-Scratchy/appsmith


text:
# DomainValidationCore
Domain validation project made by [Eduardo Pires](https://mvp.microsoft.com/pt-br/PublicProfile/5000577?fullName=Eduardo%20%20Pires), which I tried to convert to .net core.

Domain validation is a library that helps to validates complex business rules with specification pattern.

[Eduardo Pires .Net Framework version on Nuget](https://www.nuget.org/packages/DomainValidation/)

[This .Net Core version](https://www.nuget.org/packages/DomainValidationCore)

repository: Rickedb/DomainValidationCore

repo_name: Rickedb/DomainValidationCore


text:
# CacheCow

CacheCow allows ActiveRecord models to `acts_as_cached``

## Install

In your Gemfile

    gem "cache_cow"

Or via command line

    gem install cache_cow

## Overview

CacheCow provides an api for caching results of methods and associations on ActiveRecord models.

To use in a model, declare `acts_as_cached`

``` ruby
class Post
  acts_as_cached
end
```

Instances of a cache_cow model can read, write, fetch, and expire their own cache keys. Cache keys
are namespaced and versioned by convention as <class_name>:<version>:<id>:<cache_suffix>. An instances
id is the cache suffix be default.

``` ruby
# Post.cache_cow_version = 1

post = Post.find(123)

post.fetch_cache { "great post" }     # fetches from cache key 'Post:1:123', store 'great post' on cache miss

post.write_cache("foo", "bar")        # writes 'bar to cache key 'Post:1:123:foo'

post.read_cache("foo")                # returns 'bar' from cache key 'Post:1:123:foo'
````


text:
# SelfServiceRecoveryLink

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**ExpiresAt** | Pointer to **time.Time** | Recovery Link Expires At  The timestamp when the recovery link expires. | [optional]
**RecoveryLink** | **string** | Recovery Link  This link can be used to recover the account. |

## Methods

### NewSelfServiceRecoveryLink

`func NewSelfServiceRecoveryLink(recoveryLink string, ) *SelfServiceRecoveryLink`

NewSelfServiceRecoveryLink instantiates a new SelfServiceRecoveryLink object
This constructor will assign default values to properties that have it defined,
and makes sure properties required by API are set, but the set of arguments
will change when the set of required properties is changed

### NewSelfServiceRecoveryLinkWithDefaults

`func NewSelfServiceRecoveryLinkWithDefaults() *SelfServiceRecoveryLink`

NewSelfServiceRecoveryLinkWithDefaults instantiates a new SelfServiceRecoveryLink object
This constructor will only assign default values to properties that have it defined,
but it doesn't guarantee that properties required by API are set

### GetExpiresAt

`func (o *SelfServiceRecoveryLink) GetExpiresAt() time.Time`

GetExpiresAt returns the ExpiresAt field if non-nil, zero value otherwise.

### GetExpiresAtOk

`func (o *SelfServiceRecoveryLink) GetExpiresAtOk() (*time.Time, bool)`

GetExpiresAtOk returns a tuple with the ExpiresAt field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetExpiresAt

`func (o *SelfServiceRecoveryLink) SetExpiresAt(v time.Time)`

SetExpiresAt sets ExpiresAt field to given value.

### HasExpiresAt

`func (o *SelfServiceRecoveryLink) HasExpiresAt() bool`

HasExpiresAt returns a boolean if a field has been set.

### GetRecoveryLink

`func (o *SelfServiceRecoveryLink) GetRecoveryLink() string`

GetRecoveryLink returns the RecoveryLink field if non-nil, zero value otherwise.

### GetRecoveryLinkOk

`func (o *SelfServiceRecoveryLink) GetRecoveryLinkOk() (*string, bool)`

GetRecoveryLinkOk returns a tuple with the RecoveryLink field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetRecoveryLink

`func (o *SelfServiceRecoveryLink) SetRecoveryLink(v string)`

SetRecoveryLink sets RecoveryLink field to given value.

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)


text:
Pattern: Missing Python version for Azure App Service application

Issue: -

## Description

Azure App Service web applications developed with the Python should use the latest available version of Python to ensure the latest security fixes are in use.

**Resolution**: ensure latest Python version is being used.

## Examples

Example of **incorrect** code:

```terraform
resource "azurerm_app_service" "good_example" {
	name                = "example-app-service"
	location            = azurerm_resource_group.example.location
	resource_group_name = azurerm_resource_group.example.name
	app_service_plan_id = azurerm_app_service_plan.example.id
	site_config {
	  python_version = "2.7"
	}
  }
```

Example of **correct** code:

```terraform
resource "azurerm_app_service" "good_example" {
  name                = "example-app-service"
  location            = azurerm_resource_group.example.location
  resource_group_name = azurerm_resource_group.example.name
  app_service_plan_id = azurerm_app_service_plan.example.id
  site_config {
    python_version = "3.4"
  }
}
```

repository: Adroiti/docs-for-code-review-tools

repo_name: Adroiti/docs-for-code-review-tools


text:
# Blackjack Multiplayer Game - Backend

![BlackJack](/shuffle-cards.svg)

Multiplayer game based on the blackjack casino game. You can play with 2 different profiles: Bank or Normal Player.

### Installing

```bash
# Install
$ npm install

# Run
$ npm run
```

Then you have to create the .env file with the following:

```bash
# .env
# URL of a mongodb database service
mongoURI=
# Secret Token use for auth
jwtSecret=token
# Token Expiration
jwtExpiration=1d
# API for Deck Cards
cardApi=https://deckofcardsapi.com/api/deck
```

## Built With

- [Framework NestJS - Node.js](https://github.com/nestjs/nest)
- [TypeScript](https://www.typescriptlang.org/)
- [Socket.IO](https://socket.io/)
- [Deck of Cards an API](https://deckofcardsapi.com/)

## Authors

- Carlos Santander - Full Stack Developer.

## License

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

repository: ewenlaz/blackjack-back

repo_name: ewenlaz/blackjack-back


text:
# burgerRT
# ORM Project
![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
## Description

A full stack application using node.js, express, MySQL, express handlebars and custom built ORM for some light database manipulation.

Active Link :  https://burgerart2020.herokuapp.com/

![GitHub Logo](/media/Burger1.PNG)

## Table of Contents

* [Description](#description)
* [Installation](#installation)
* [Usage](#usage)
* [License](#license)
* [Contributing](#contributing)
* [Contact](#contact)

## Installation

The app is deployed on Heroku

## Usage

In this assignment, you'll create a burger logger with MySQL, Node, Express, Handlebars and a homemade ORM (yum!). Be sure to follow the MVC design pattern; use Node and MySQL to query and route data in your app, and Handlebars to generate your HTML.

## License

The application is released under the MIT license.

## Contact

GitHub [gitHub profile](https://github.com/Arati15).
Username : Arati15


text:
Vintageous
==========

Overview
--------

**Vintageous** is a vi editing package for Sublime Text 3.

Vintageous is a rewrite of [Vintage](http://www.sublimetext.com/docs/2/vintage.html) with the aim to make
it more similar to Vim. The new design is heavily inspired by previous work done by [dlo](https://github.com/dlo).

Download
--------

The [current build](https://bitbucket.org/guillermooo/vintageous/downloads/Vintageous.sublime-package) of Vintageous is updated frequently.

Install
-------

To install a package in Sublime Text 3, put the *.sublime-package* file inside
the *Installed Packages* folder, located under the data directory.

Vintage must be disabled (or *ignored*, in Sublime Text parlance) to avoid conflicts with Vintageous.

Development Version
-------------------

To use this development version, you should:

1. ensure the built-in Vintage package is in the ``ignored_packages`` list, as it is by default
2. zip the content of this repository and add the extension *.sublime-package* to the archive
3. copy the *.sublime-package* file to the *Installed Packages* folder, located under Sublime Text's data directory

Documentation
-------------

Refer to the [wiki](https://github.com/guillermooo/Vintageous/wiki).

**The following documentation applies only in part to Vintageous.**

* [Vintage Mode Overview](http://www.sublimetext.com/docs/3/vintage.html)
* [API Reference](http://www.sublimetext.com/docs/3/api_reference.html)
* [Key Bindings](http://docs.sublimetext.info/en/latest/customization/key_bindings.html)

Settings
--------

See [Vintageous/Preferences.sublime-settings](https://github.com/guillermooo/Vintageous/blob/master/Preferences.sublime-settings) for a comprehensive list of settings.

repository: bahtou/sublConfig

repo_name: bahtou/sublConfig


text:
---
type: playlist
label: editing-tips
date: 2020-01-29
title: Editing Tips & Tricks
technologies: [.net]
topics: [completion, editing, inspections]
author: maartenba
subtitle: Know everything there is to know about editing code.
thumbnail: ./thumbnail.png
cardThumbnail: './card.png'
playlistItems:
    - /tips/move-code/
    - /tips/create-variable/

---

Editing code is a core activity in the IDE. ReSharper and Rider can help
write clean code faster, and more efficiently.

In this playlist we're going to have a look at the many editing and
code completion features in ReSharper and Rider, and how to effectively
use them.


text:
---
description: Vignette files can be replaced or deleted while the server is live by using the req=release command just before the file is overwritten.
solution: Experience Manager
title: Deleting or replacing source data files
feature: Dynamic Media Classic,SDK/API
role: Developer,Admin,User
exl-id: 9daf8534-a844-4f4a-8e99-8dc751acd550
---
# Deleting or replacing source data files{#deleting-or-replacing-source-data-files}

Vignette files can be replaced or deleted while the server is live by using the req=release command just before the file is overwritten.

>[!NOTE]
>
>A data file must not be replaced or deleted while the Render Server is accessing it.

Keep in mind that deleting or replacing a source data file only causes the Render Server to close the file until the next request that accesses that vignette. Several retries may be necessary if a file is heavily used.

The Render Server must be stopped to replace other data files.

[!DNL Platform Server] cache entries are automatically invalidated when material files or vignettes are replaced. Replacing ICC profile files does not invalidate caches.

To avoid the complications of replacing files, it is recommended to give a replacement file a new name and update the corresponding catalog entries. This allows replacing any data file while the server is live and causes server cache entries to become stale automatically with no additional intervention. This approach can be used for all data files managed by image catalogs.


text:
# FLAN: a functional language

FLAN is a toy functional language realised as a series of evaluators
written in C. It supports higher-order functions, simple types,
user-defined algebraic datatypes, and strict and lazy
evaluation. There is also a simpler first-order strict
evaluator. There is no type inference or parametric polymorphism.

It was intended to be a vehicle for assignments for first year
students at CSE, UNSW circa 2008. [John
Shepherd](http://www.cse.unsw.edu.au/~jas/) commissioned this project
and [Peter Gammie](http://peteg.org/) executed it. It owes some
inspiration to C/Java compiler first-year assignments dating back to
1996. [Andrew Taylor](http://www.cse.unsw.edu.au/~andrewt/) was
responsible for some of these.

FLAN comes with FLANGE - the FLAN graphics engine, which is based on
the functional geometry ideas originated by Peter Henderson. The
system renders potentially infinite (co-recursive) pictures as SVG
files.

Additionally there are many small tests that contain some classical
functional programming techniques. These were scraped from the
[GHC](http://www.haskell.org/ghc/) test suite, Prolog folklore,
textbooks (Bird/Wadler, Thompson, ...)  and functional
pearls. Provenance and authorship should be clear for non-trivial
examples; if it is not, please tell me.

## Building

Dependencies:

* A modern C compiler supporting at least C99. FLAN was developed
  using gcc-4.2 under Mac OS X 10.6 (and earlier), and some archaisms
  remain. It has been tested using gcc-4.8.3 and clang-3.3 under
  Debian.

* perl, to generate the header file for the lexer.

* flex, to generate the lexer itself.

* H.-J. Boehm's garbage collector (optional)

Building it should simply be a matter of typing "make". Investigate
the Makefile if it is not.

The code was intended to be warning-free (modulo the output of flex),
and is with GCC but not clang.

## Execution

The command-line arguments for the flan executable should be
self-explanatory:

$ flan --help

## Examples

Suffix "-fail" means the test should be flagged as an error.

* 0 - basic syntax
* 1 - simple functions over Int, tuples
* 2 - simple functions over lists
* 3 - types, type errors
* 4 - higher-order functions (that work with strict eval)
* 5 - scoping (turn the type checker off)
* 6 - serious list algorithms
* 7 - graphs
* 8 - long programs (that work with strict eval)
* 9 - laziness, user-defined types, ...

## Ideas for further development

### FLAN

* Accurate garbage collection
* REPL
* Types: parametric polymorphism
* More built-in functions
* Nested comments
* Allow primes in identifiers
* Add input and output (caveat: laziness)

### FLANGE

* Compile FLANGE images to SVG and JavaScript, allowing zooming of
  (co-)recursive images and animations (= lazy list of FLANGE images).
* Colours.
* Text.

### Examples

* Dijkstra et al shortest paths
* Kruskal / Prim spanning-trees
* Continuations, such as backtracking ala Hutton et al
* Logic programming
* enumerate the digits of e
* Minimax ala Bird/Hughes
* "Seemingly impossible" functional programs ala Escardo
* DLPP (etc) SAT algorithm
* [Rosetta Code programming tasks](http://rosettacode.org/wiki/Category:Programming_Tasks)
* [Bernie](http://www.berniepope.id.au/): interpreter for an imperative language
* Functional arrays / priority queues ala Okasaki/Paulson

## Bugs and infelicities

Possibly quite stale.

* Parser: verify we've hit EOF when parsing is finished.

* Scope within a 'let' block is a bit strange:
 * constants can use earlier definitions in the same block.
 * functions can use any definition in the same block.

* Fix the scoping up in the higher-order strict evaluator.
 * decide on let or letrec and make it stick.
 * Ensure that the same variable is not given several definitions in
   the same scope.

* Reduce duplication between e_expr and e_binary_op

* Write a test that establishes that updating closures is not correct
  (eval-hol:236).
 * I think one can do this by using a HOF twice.
 * Check very carefully about updating values of all kinds.

* Type checker should take evaluator scope into account.
 * e.g. constants are not in-scope in their own definitions in strict
   evaluators.

* ./flan -lflange/920-turtle

repository: peteg/flan

repo_name: peteg/flan


text:
---
title: 'filter'
---

Type: <Type children='<string>'/>

A comma-separated list of data fields to pick from the response payload over the target [url](/docs/api/parameters/url).

<MultiCodeEditor languages={mqlCode('https://news.ycombinator.com', { filter: 'url,title' })} />

<Figcaption children='You can use dot notation to reference a nested data field of the response payload.' />

Then the data payload is going to just get these data fields.

```json
{
  "status": "success",
  "data": {
    "url": "https://news.ycombinator.com/",
    "title": "Hacker News"
  }
}
```

This parameter has been designed to make API payload tiny as possible, improving response bandwidth timing.

repository: microlinkhq/www

repo_name: microlinkhq/www


text:
# Compass-for-astronomers
Elaboration of a compass with information necessary for the alignment and leveling of telescopes and assemblies.

It is a compass designed to help astronomers and astrophotographers in aligning their equipment, especially in places without Internet access.
It was built using an Arduino Nano and a compass module with accelerometer.
The firmware was developed on the Arduino IDE.
The parts of the box have been 3D printed.
Future changes are planned, including:
1- Exchange the Arduino Nano for the Esp32;
2- Include information from a GPS;
3- Change the LCD screen for an OLED;
4- Add to the Menu the Local Sidereal Time, the local coordinates, the local time, the local height, the local temperature and humidity data and the geographic coordinates;
5- Provide a small database of astronomical object coordinates;
6- Send commands to GOTO via Bluetooth using LX200 protocol.
Here you will find more information: https://www.instructables.com/Compass-for-Astronomers/

Contributions are welcome.

repository: allafs/Compass-for-astronomers

repo_name: allafs/Compass-for-astronomers


text:
# Multiteleirc

A simple [Telegram](https://telegram.org/) ↔ IRC gateway for direct messages

Largerly inspired by [FruitieX/Teleirc](https://github.com/FruitieX/teleirc).

Quick start
-----------

Make sure you've installed Node.js.

1. Clone this project
2. Copy the multiteleirc.config.js file into ~/.multiteleirc/config.js and edit as will
3. Set up bots with [BotFather](https://telegram.me/botfather) (one bot per IRC user)
4. Run the multi-bot with `node .`
5. Telegram users have to initiate the conversation

Known issues
------------

* No bot authentification (subject to MITM attack)
* Does not support Telegram media files, edits, etc.


text:
# Contributing Guide

We welcome every sort of contribution, from bug reports to improvements of the code or new features. If you are not yet
familiar with contributions to open source projects, don't worry. It's not that difficult and most important steps are
explained below.

There are mainly two ways of contribution:

1. If you find a bug or have an idea for a good new feature, just add an **issue** in the GitHub web interface.
2. If you already know how to implement a solution, follow the guide to contribute code below using a **pull-request**.
   In case you are not sure about the implementation, raise an issue first to discuss ideas with others.

Please note also our [Code of Conduct](CODE_OF_CONDUCT.md)

## How can I contribute code?

Here is a quick summary how contributions work on GitHub:

1. Fork the repository to your local GitHub account
2. Clone the repository to your local computer using `git clone https://github.com/your-github-username/repository-name.git`
3. Create a new branch where you will later add your changes using `git switch -c branch-name`
4. Update the files to fix the issue or add new features. Please add your copyright notice in a new line if you made significant changes to the file.
5. Use `git add your-changed-files` to add the file contents of the changed files to the so-called staging area (means
   they are prepared to be committed)
6. Run `git commit -m "Short message to describe the changes"` to add the staged files to the respository
7. Upload the changes to the remote repository on GitHub using `git push origin branch-name`
8. Submit a pull request via the GitHub web interface and wait for the response of the maintainers.

 Tell *what* was changed and not that *something* was changed.
  "ADC measurements: Improved performance of temperature sensor reading" is much better than "Updates". You can also
  reference an issue with its numer (e.g. #123) in the commit message
- Use the [Libre Solar coding style](https://libre.solar/docs/coding_style/)

## License

All contributions must be licensed under the [Apache License 2.0](LICENSE) as the rest of the repository.

repository: luizvilla/charge-controller-firmware

repo_name: luizvilla/charge-controller-firmware


text:
# What are the disadvantages of using classic decision tree algorithm for a large dataset?

### The computational efficiency perspective

It's a combinatorial search problem: at each split, we want to find the features that give us "the best bang for the buck" (maximizing information gain). If we choose a"brute" force approach, our computational complexity is O(m^2), where m is the number of features in our training set, and O(n^2) for the number of n training cases (I think it can be O(n log(n) if you are lucky).

Let's take a look at a simple dataset, Iris (150 flowers, 3 classes, 4 continuous features). At each split, we have to re-evaluate all 4 features, and for each feature we have to find the optimal value to split on, e.g,. sepal length <3.4 cm (this is for a binary split). Computational complexity is one of the reasons why people implement *binary* decision trees most of the time.

### The predictive performance perspective

An unpruned model is much more likely to overfit as a consequence of the curse of dimensionality. However, instead of pruning a single decision tree, it often a better idea to use ensemble methods. We could

- combine decision tree stumps that learn from each other by focusing on samples that are hard to classify (AdaBoost)
- create an ensemble of unpruned decision trees; draw bootstrap samples, and do random feature selection (random forests)
- forget about bagging and use all training samples as input for your unpruned trees; choose both the splitting feature and splitting value at random (= Extremely randomized trees)

(Related topic: [How does the random forest model work? How is it different from bagging and boosting in ensemble models?](../bagging-boosting-rf.md))

repository: peterjpxie/python-machine-learning-book

repo_name: peterjpxie/python-machine-learning-book


text:
---
title: HTML Element
book: userguide
chapter: form-components
slug: html-element-component
weight: 48
---
An HTML Element component may be added to a form to display a single HTML element. This is useful if you wish to quickly insert and configure some HTML in your form. All unsafe HTML is stripped before rendering to prevent cross-site scripting exploits. This includes tags like `<script>`, `<embed>`, and `<style>`, and attributes like `onmouseover` or `onload`.

If you wish to insert more complicated HTML in your form, see the [Content component](#content-component)

![](/assets/img/html-element-display.png){: .img-fluid .img-thumbnail }

#### HTML Tag

The name of the HTML tag to display.

#### CSS Class

The CSS class to add to the HTML element. You may specify multiple classes by separating them with single spaces.

#### Attributes

Attributes and their values to add to the HTML element. This is commonly used to add `href` attributes to `<a>` tags, or `src` attributes to `<img>` tags.

#### Content

The text content of the HTML element. While adding more child HTML tags here will properly display them, it is recommended you use the [Content component](#content-component) to easily write and preview more complex HTML.


text:
# docker-oracle-11g-client

A Docker image for Oracle 11g client.

This image includes odbc.ini and tnsnames.ora files. For a realistic scenario,
these files will need deployment-specific changes.

## License

[MIT](http://opensource.org/licenses/MIT)


text:
# Building Lighthouse

Lighthouse is built into browser-friendly bundles for two clients:

* Chrome DevTools Audits Panel
* Lightrider, the backend of PageSpeed Insights

Additionally, there are build processes for:

* [The Lighthouse report viewer](../lighthouse-viewer/)
* The chrome extension (as of Nov 2019 is a thin-client that defers to the viewer)

## Building for DevTools

To build the devtools files and roll them into a local checkout of Chromium:

```sh
yarn devtools
```

`yarn build-devtools` creates these files:

```
dist
├── dt-report-resources
│   ├── report-generator.js
│   ├── report.css
│   ├── report.js
│   ├── template.html
│   └── templates.html
└── lighthouse-dt-bundle.js
```

1. the big `lighthouse-dt-bundle.js` bundle
1. the much smaller `report-generator.js` bundle (just two modules). This is exported as ReportGenerator
1. copies all the `report.{js,css}` / `template(s).html` files (these are not transformed in any way). We call these the report assets.

### How the Audits Panel uses the Lighthouse assets

`AuditsService` uses `self.runLighthouseInWorker`, the main export of the big bundle.

`AuditsPanel` uses `new Audits.ReportRenderer(dom)`, which overrides `self.ReportRenderer`, which is [exported](https://github.com/GoogleChrome/lighthouse/blob/ee3a9dfd665135b9dc03c18c9758b27464df07e0/lighthouse-core/report/html/renderer/report-renderer.js#L255) by `report.js`. This renderer takes a Lighthouse result, `templates.html`, and a target DOM element - it then renders the report to the target element.

`AuditsPanel` also registers `report.css`.

`report-generator.js` takes a Lighthouse result and creates an HTML file - it concats all of the report assets to create a singular HTML document. See: https://github.com/GoogleChrome/lighthouse/blob/ee3a9dfd665135b9dc03c18c9758b27464df07e0/lighthouse-core/report/report-generator.js#L35

A Lighthouse report (including what is shown within the Audits panel) can also Export as HTML. Normally the report just uses `documentElement.outerHTML`, but from DevTools we get quine-y and use `Lighthouse.ReportGenerator`. I only mention this because this is why the report assets are seperate files - there is a dual purpose.

1. Create the report within the Audits Panel DOM. `report.js` exports the renderer, and `report.css` and `templates.html` are pulled from `.cachedResources`.

2. Export the report as HTML. We can't just scrape the outerHTML like we normally do, because we render some thing a bit
special for DevTools, and we're not the only thing in that DOM (we would get _all_ of DevTools). So we use `Lighthouse.ReportGenerator` (important: this is only used here!) to create this HTML export. It requires all of the report assets, so to prevent double-bundling we [shim](https://github.com/GoogleChrome/lighthouse/blob/https://github.com/GoogleChrome/lighthouse/blob/ee3a9dfd665135b9dc03c18c9758b27464df07e0/lighthouse-core/report/report-generator.js#L35/clients/devtools-report-assets.js) its report assets module to just read from the `.cacheResources`.

repository: meehawk/lighthouse

repo_name: meehawk/lighthouse


text:
---
layout: page
title: Projects by Monster Brain
---

<p class="message">
   Lists the projects in progress, completed which includes websites, games, tools etc.
</p>

### Web Projects
* Angular 7 http fetching tutorial on [Github](https://github.com/monsterbrain/angularhttptutorial)
* Tool to Quickly Create Keyboard shortcut images. [Keyboard Shortcut Generator](https://github.com/monsterbrain/keyboard-shortcut-image-generator)

Thanks for reading!
```[last updated May 2021]```

gha_license_id: NOASSERTION


text:
# Medical Image Processing

There are 3 MATLAB Live Scripts which deals with different aspects of image segmentation. The data set is from the medical domain (cell images) but the workflow is fairly general and can be used in other fields also.

1. Ex\_1\_Cell\_segmentation\_part1.mlx deals with image segmentation based on colour information.
2. Ex\_2\_Cell\_segmentation\_part2.mlx deals with image segmentation based on *texture*.
3. Ex\_3\_Using\_simple\_parallel\_computing.mlx makes use of simple parallel computing commands to increase execution speed and also guides the user on how to use a compute cluster to off-load the code.

[![View Medical-Image-Segmentation on File Exchange](https://www.mathworks.com/matlabcentral/images/matlab-file-exchange.svg)](https://www.mathworks.com/matlabcentral/fileexchange/88019-medical-image-segmentation)

The license is available in the License.txt file in this GitHub repository.

repository: mathworks/Medical-Image-Segmentation

repo_name: mathworks/Medical-Image-Segmentation


text:
# kubectl contexts and namespaces

`kubectl` supports multiple servers and/or users by a feature called **contexts**. When working with contexts
(and namespaces) leads to long names.

You can use `sku add-config` to build up your multi-context `.kube/config` file; and then use `sku context` for showing
and switching contexts.

`sku ns` can be used for displaying and switching namespaces.

## sku add-config

This command allows adding an external kubeconfig file to the default `~/.kube/config`;
so you can actually merge multiple Kubernetes configs together which you got from different sources.

*Example*:

```bash
sku add-config path-to-additional-kubeconfig-file
```

## sku context

*This command allows to switch between different configured Kubernetes clusters*.

**List all configured contexts**: `sku context`

**Switch the active context**: `sku context [context-name]`

## sku ns

**List all namespaces**: `sku ns`

**Switch the active namespace**: `sku ns [namespace-name]`

repository: sandstorm/sku

repo_name: sandstorm/sku


text:
---
title: "Week 10 Roundup: Proposal Submission"
layout: post
date: 2016-11-14
---

Last week I've submitted the formal project proposal [[pdf file][1]]. it went
pretty well since Ian wanted us to go over it a few days before deadline, which
meant I was ready in time. Now that this is done, I've planned what I want to
do in the next few weeks, before the holiday break. This was also a good way to
decide what could go in the feasibility demo planned for week 13:

 * Have another look at the overall systems architecture, and potentially start
   working on a software architecture for AHABus.

 * Start working on the frame/packet format designs.

 [1]: /static/files/proposal.pdf

repository: amyinorbit/hons

repo_name: amyinorbit/hons


text:
### [CVE-2023-33731](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-33731)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Reflected Cross Site Scripting (XSS) in the view dashboard detail feature in Microworld Technologies eScan management console 14.0.1400.2281 allows remote attacker to inject arbitrary code via the URL directly.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/nomi-sec/PoC-in-GitHub
- https://github.com/sahiloj/CVE-2023-33731

repository: trickest/cve

repo_name: trickest/cve


text:
# harvest-er: Harvest Automation Server

[![NPM version][npm-image]][npm-url]
[![Dependency Status][daviddm-image]][daviddm-url]
[![code-style][code-style-image]][code-style-url]
[![License][license-image]][license-url]
[![NPM downloads][npm-downloads-image]][npm-url]

## Getting Started

Harvester requires [Node.js](https://nodejs.org/) and [npm](https://www.npmjs.org/), which can both be installed by following the instructions on https://nodejs.org/. Installing Node.js also installs npm.

#### Installing with npm

`npm install harvest-er`

#### Installing from source

`git clone https://github.com/sbolel/harvest-er` - clone the source code

`npm install` - install node dependencies

`npm run debug` - start the application using Supervisor with debug messages enabled

## Usage

Start the application using Supervisor with `npm run debug`. The Harvest data will be downloaded and saved to Dropbox each time the server runs. To re-run this download, execute `rs` in Supervisor.

#### Setting up Harvest

2. Add the admin users email/password to your environment

    ```bash
    export HARVESTER_SUBDOMAIN="thinkcrazy"
    export<EMAIL_ADDRESS>    export HARVESTER_ADMIN_TOKEN="abc-def-123-456"
    ```

2. Set your Harvest subdomain in [`server/harvester.js`](server/harvester.js) and the email/password for the admin user:

    ```js
    var harvester = new Harvest({
        subdomain: process.env.HARVESTER_SUBDOMAIN,  // your harvest subdomain
        email: process.env.HARVESTER_ADMIN_EMAIL,
        password: process.env.HARVESTER_ADMIN_TOKEN
    }),
    ```

## Getting Today's Expense and Time Entries data from Harvest (see [`app.js`](server/app.js))

3. Require `harvest` and `harvester`

```js
const Harvest = require('harvest');
const Harvester = require('./harvester');
```

3. Initialize Harvester and download the data using a promise array

```js
function getTodaysData(){
  const harvest = new Harvest({
    subdomain: process.env.HARVESTER_SUBDOMAIN,
    email: process.env.HARVEST_ADMIN_EMAIL,
    password: process.env.HARVEST_ADMIN_TOKEN
  });
  const harvester = new Harvester(harvest);
  const tasks = [];
  harvester.loaded().then(function(teamData){
    tasks.push(harvester.getExpenses());
    tasks.push(harvester.getTimesheets());
    Q.all(tasks).then(function(results){
      debug(harvester.val());
    });
  });
}
```

## Future work

#### Setting up Dropbox

2. Create a new Dropbox app at https://www.dropbox.com/developers/apps/create

    - Go to the settings for your new Dropbox app
    - Take note of the _App key_ and _App secret_
    - Click "Generate" to get a _Generated access token_

2. Add the admin users email/password to your environment

    ```bash
    export HARVESTER_DROPBOX_KEY=2abcdef1234t53e
    export HARVESTER_DROPBOX_SECRET=vn5aaf3bb5dd3qt
    export HARVESTER_DROPBOX_TOKEN=rUY9dxaAABBCCDDeeXJctUSUA_c8SuvABfzNwDAdFmTACAa6mUrpAAmcc7Gg7Qch
    ```

2. Set your Dropbox credentials in [`server/dropboxer.js`](server/dropboxer.js):

```js
const client = new Dropbox.Client({
  key: process.env.HARVESTER_DROPBOX_KEY,
  secret: process.env.HARVESTER_DROPBOX_SECRET,
  token: process.env.HARVESTER_DROPBOX_TOKEN
});
```

[npm-image]: https://img.shields.io/npm/v/harvest-er.svg?style=flat-square
[npm-url]: https://npmjs.org/package/harvest-er
[npm-downloads-image]: https://img.shields.io/npm/dm/harvest-er.svg?style=flat-square
[travis-image]: https://img.shields.io/travis/sbolel/harvest-er/master.svg?style=flat-square
[travis-url]: https://travis-ci.org/sbolel/harvest-er
[daviddm-image]: https://img.shields.io/david/sbolel/harvest-er.svg?style=flat-square
[daviddm-url]: https://david-dm.org/sbolel/harvest-er
[climate-image]: https://img.shields.io/codeclimate/github/sbolel/harvest-er.svg?style=flat-square
[climate-url]: https://img.shields.io/codeclimate/github/sbolel/harvest-er.svg?style=flat-square
[coverage-image]: https://img.shields.io/codeclimate/coverage/github/sbolel/harvest-er.svg?style=flat-square
[coverage-url]: https://img.shields.io/codeclimate/coverage/github/sbolel/harvest-er.svg?style=flat-square
[license-image]: https://img.shields.io/npm/l/harvest-er.svg?style=flat-square
[license-url]: https://github.com/sbolel/harvest-er/blob/master/LICENSE
[code-style-image]: https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square
[code-style-url]: http://standardjs.com/

repository: sbolel/harvest-er

repo_name: sbolel/harvest-er


text:
# JFrog  Openshift Artifactory-Xray Chart Changelog
All changes to this chart will be documented in this file.

## [2.4.0] - April 14, 2020
* Updating to latest jfrog/artifactory-ha helm chart version 2.4.0 adding new requirements.yaml entry for xray helm charts to combine together into one umbrella chart

## [2.3.0] - April 13, 2020
* Updating to latest jfrog/artifactory-ha helm chart version 2.3.0

## [2.2.9] - April 11, 2020
* Fixed issues with master key

## [2.1.9] - March 17, 2020
* Updated Artifactory version to 7.3.2

## [2.0.35] - March 09, 2020
* Updated Artifactory version to 7.2.1


text:
# Exponential Quiz
Online quiz app with exponential scoring. Built for a CCS-TIET event.

![exponential-quiz](screenshots/abifog-exponential-quiz-4.png)

## Features

* Standard Quiz Features
* Exponential Scoring and negative marking
* Know your score after each answer submission
* User auth for both quiz makers and students
* Images/Code/Text in questions.
* Anti cheat

## Score System

* Questions will appear one by one.
* The participant will have the choice of either skipping the question or answering it.
* If they answer it corectly they'll get 2^1 points.
* If they answer another question correctly after that theyll get 2^2 points.
* And so on
* If they skip a question, next questions points will again start from 2^1.
* If they answer the question incorrectly 2 marks will be deducted.
* If they answer another question incorrectly 4 marks will be deducted and so on.

## Running Locally

Install the requirements:

In a python3virtualenv,
```bash
pip install -r requirements.txt
```

In exponential_quiz/settings.py commment out these two lines
```
import django_heroku
.
.
.
.
django_heroku.settings(locals())
```

Link to the database by setting the DATABASE_URL environment variable. Then run:

```bash
python manage.py migrate
```

Finally, run the development server:

```bash
python manage.py runserver
```
## Other Deployment Methods
I haven't built a dockerfile for this specific app but I think after connecting it to postgres you'll have to run the ```python manage.py migrate``` command once inside the container's shell. Same with heroku etc.

## Notes
* The contents of one option of a question should be 'Skip' if you want a question to be skippable.
* Basic html markup can be inserted into the questions for code, images, formatting, etc.

## Other Screenshots

![exponential-quiz](screenshots/abifog-exponential-quiz-1.png)
![exponential-quiz](screenshots/abifog-exponential-quiz-2.png)
![exponential-quiz](screenshots/abifog-exponential-quiz-3.png)

## Credits:
* [SIBTC](https://github.com/sibtc/django-multiple-user-types-example/) for the base quiz layout and mechanism.
* [StartBootstrap](https://startbootstrap.com/themes/sb-admin-2/) for the css template.

## License
The source code is released under the [MIT License](https://github.com/IceWreck/ExponentialQuizDjango/blob/master/LICENSE).

repository: MagnumDingusEdu/ExponentialQuizDjango

repo_name: MagnumDingusEdu/ExponentialQuizDjango