text:
# Filament LeafLet GeoSearch

[![Latest Version on Packagist](https://img.shields.io/packagist/v/heloufir/filament-leaflet-geosearch.svg?style=flat-square)](https://packagist.org/packages/heloufir/filament-leaflet-geosearch)
[![Total Downloads](https://img.shields.io/packagist/dt/heloufir/filament-leaflet-geosearch.svg?style=flat-square)](https://packagist.org/packages/heloufir/filament-leaflet-geosearch)

This package provides a Filament Form Field integration of the LeafLet GeoSearch package [https://github.com/smeijer/leaflet-geosearch](https://github.com/smeijer/leaflet-geosearch)

![Filament LeafLet GeoSearch](filament-leaflet-geosearch-demo.png)

## Installation

You can install the package via composer:

```bash
composer require heloufir/filament-leaflet-geosearch
```

You need to publish assets used by this package:
```bash
php artisan vendor:publish --tag=filament-leaflet-geosearch-assets
```

> **From the version 1.1.0, you need to register manually the assets (styles and scripts)**
>
> This decision was made to make the plugin standalone for users who want to use it without Filament administration (only with Filament forms)

- If you are using this package with `Filament administration`, add this lines to the `boot()` function of your `AppServiceProvider`
```bash
public function boot()
{
    // ...
    Filament::serving(function () {
        // ...
        Filament::registerStyles([
            asset('filament/assets/css/leaflet.css'),
            asset('filament/assets/css/geosearch.css'),
        ]);
        Filament::registerScripts([
            asset('filament/assets/js/leaflet.js'),
            asset('filament/assets/js/geosearch.umd.js'),
        ], true);
        // ...
    });
    // ...
}
```

**Important: Don't forget the `true` flag on the `registerScripts` to make the scripts loaded before Filament core scripts**

- If you are using this package without `Filament administration` (only with `Filament forms`), you can include the styles and scripts into your html layout.

## Usage
### Model configuration
In your model you need to add the location column cast:
```php
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class MyModel extends Model
{
    // ...

    protected $casts = [
        'location' => 'object'
    ];
}
```

**Important:** The `location` column must have the `longText` type in your migration (see the example below)
```php
// ...
Schema::create('my_models', function (Blueprint $table) {
    // ...
    $table->longText('location');
    // ...
});
// ...
```

### Field usage
Now that you have configured your model, you can use the `LeafletInput` into your Filament Resource form schema:

```php
use Heloufir\FilamentLeafLetGeoSearch\Forms\Components\LeafletInput;

public static function form(Form $form): Form
{
    return $form
        ->schema([
            // ...
            LeafletInput::make('location')
                ->setMapHeight(300) // Here you can specify a map height in pixels, by default the height is equal to 200
                ->setZoomControl(false) // Here you can enable/disable zoom control on the map (default: true)
                ->setScrollWheelZoom(false) // Here you can enable/disable zoom on wheel scroll (default: true)
                ->setZoomLevel(3) // Here you can change the default zoom level (when the map is loaded for the first time), default value is 10
                ->required()
            // ...
        ]);
}
```

### Good to know
The object stored into the `location` database column have the following format:

```
{
  x: Number, // lon,
  y: Number, // lat,
  label: String, // formatted address
  bounds: [
    [Number, Number], // s, w - lat, lon
    [Number, Number], // n, e - lat, lon
  ],
  raw: {}, // raw provider result
}
```

## Support

For fast support, please join the [**Filament** community](https://filamentphp.com/discord) discord and send me a message in this channel [#leaflet-geosearch](https://discord.com/channels/883083792112300104/1001049950983041044)

## Credits

- [heloufir](https://github.com/heloufir)
- [All Contributors](https://github.com/heloufir/filament-leaflet-geosearch/graphs/contributors)

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

repository: heloufir/filament-leaflet-geosearch

gha_language: Blade

repo_name: heloufir/filament-leaflet-geosearch


text:
## NextJS 🔗 Ant Design 🔗 Styled-Component ⚡ Starter Kit

This example shows how to use Next.js along with [Ant Design of React](https://ant.design) & [Styled Component](https://styled-components.com/) + Typescript. This is intended to show the integration of these UI toolkit with the Framework.

### Preview
Preview the example live on [StackBlitz](http://stackblitz.com/):

[![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](TODO)

### Deploy your own

Deploy the example using [Vercel](https://vercel.com?utm_source=github&utm_medium=readme&utm_campaign=next-example):

[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/git/external?repository-url=https://github.com/johnkingzy/nextjs-antd-styled-component-starter-kit&project-name=nextjs-antd-styled-component-starter-kit&repository-name=nextjs-antd-styled-component-starter-kit)

## How to use

Clone the repository
```bash
git clone https://github.com/johnkingzy/nextjs-antd-styled-component-starter-kit.git
```

Install dependencies & start development server
```bash
npm install && npm run dev
```

Deploy it to the cloud with [Vercel](https://vercel.com/new?utm_source=github&utm_medium=readme&utm_campaign=next-example) ([Documentation](https://nextjs.org/docs/deployment)).

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Vue Solid Plugin

[![Project Solid](https://img.shields.io/badge/project-Solid-7C4DFF.svg?style=flat-square)](https://github.com/solid/solid)
[![NPM Package](https://img.shields.io/npm/v/vue-solid-plugin.svg)](http://npmjs.com/package/vue-solid-plugin)

A set of Vue plugins/components for making [Solid](https://github.com/solid) app development easier.

* [Getting Started](#getting-started)
* [Solid Login component](#solidlogin)
* [Populating data in your component](#populating-data)
* [New **loggedIn** lifecycle hook](#loggedin-lifecycle-hook)
* [Accessing the solid-auth-client](#solid-auth-client)
* [Accessing the query-ldflex api](#query-ldflex)

# Getting Started

## Install

Install the npm package

```bash
npm install --save vue-solid-plugin
```

Add it to your vue app

```diff
// main.js
import Vue from 'vue';
import App from './App.vue';
+ import {Solid, SolidLogin} from 'vue-solid-plugin';

+ Vue.use(Solid);
+ Vue.component('SolidLogin', SolidLogin);

new Vue({
  render: h => h(App),
}).$mount('#app');

```

# Documentation

This plugin does a few different things to help write good Solid applications.

**Features**

* a [renderless component](https://adamwathan.me/renderless-components-in-vuejs/) for making logging in easy called `<SolidLogin>`
* pre-load user data (and other data with known subjects) new `solid` attribute when defining your component
* **loggedIn** lifecycle hook, to run code after the user logs in
* access to the [solid-auth-client] at `this.$solid.auth`
* access to the [query-ldflex] api at `this.$solid.data`

## SolidLogin

A [renderless component](https://adamwathan.me/renderless-components-in-vuejs/), providing an easy to use API for logging in/out of a Solid server. You provide the markup however you want to, using the data provided and calling the actions provided.

[view src](./solid-login.js)

**Example:**

```vue
<SolidLogin popupUri="/popup.html">
    <div slot-scope="{ initializing, login, logout, loggedIn, webId }">
        <button v-if="initializing">Loading...</button>
        <button v-else-if="loggedIn" @click="logout()" :title="webId">Log out</button>
        <button v-else @click="login()">Log In</button>
    </div>
</SolidLogin>
```

For more info about renderless components, check out this [excellent article](https://adamwathan.me/renderless-components-in-vuejs/).

### Props

You provide the properties on the component itself, passing in data to the SolidLogin component

* `popupUri` <small>required</small>: the uri to the popup html page for logging in. ([Generate](https://solid.github.io/solid-auth-client/#generating-a-popup-window) your own, or maybe grab [solid.community's](https://solid.community/common/popup.html) and serve it on your domain)

### Data

This info is given to you in the default slot scope. You can destructure the object, as in the example above.

* `initializing`: true if the `solid-auth-client` has not checked for any login status yet (i.e. it's still initializing). Provide a loading gif or something
* `loggedIn`: true if logged in, false otherwise
* `webId`: the webId of the logged in person, or an empty string

### Actions

These methods are given to you in the default slot scope. You can destructure the object, as in the example above.

* `login()`: call this method when you want to invoke the login process (i.e. the popupUri)
* `logout()`: call this method when you want to logout

## Populating Data

If your component needs data from solid you can specify it in the definition of your component and the plugin will populate it **asynchronously**, providing your template access to it as if it were in `data` or `computed`.

You define where the data comes from (the **subject**) and what data pieces you want about that subject (the **propeties**). An exception to this is the `user` - for this you only need to define what data you want about the user, no need to specify the subject.

The **properties** you specify can be either a _string_ or an _object.

* _String_ properties get resolved directly using the data available for the subject. They can be anything which [query-ldflex] understands: anything from their [context](https://github.com/solid/query-ldflex/blob/master/src/context.json), or any full url (e.g. `https://schema.org/description`)
* _Object_ properties let you populate data coming from the subject's [**Type Index**](https://github.com/solid/solid/blob/master/proposals/data-discovery.md). You must specify the _type_ you're looking for, and what _properties_ you care about on that type.

```diff
//your-component.vue
<template>
  <span class="user__name">{{ user.name }}</span>
  <span class="other__thing">{{ other.thing }}</span>
  <ul>
    <li v-for="bookmark in user.bookmarks">
      <a :href="bookmark.link">{{ bookmark.title }}</a>
    </li>
</template>
<script>
export default {
  name: 'YourComponent',
  data: ...,
+  solid: {
+    user: { //user is sepcial, no need to specify a 'subject', just specify the data
+      name: 'name',
+      title: 'foaf:title',
+      bookmarks: {
+        'type': 'http://www.w3.org/2002/01/bookmark#Bookmark',
+        properties: {
+          link: "http://www.w3.org/2002/01/bookmark#recalls",
+          title: "terms:title",
+        },
+      },
+    },
+    other: {
+      subject: 'http://some-other-url.to#a-thing',
+      properties: {
+        description: 'schema:description',
+        bookmarks: {
+          'type': 'http://www.w3.org/2002/01/bookmark#Bookmark',
+          properties: {
+            link: "http://www.w3.org/2002/01/bookmark#recalls",
+            title: "terms:title",
+          },
+        },
+      }
+    }
+  }
}
</script>
```

## `loggedIn` lifecycle hook

This new lifecycle hook will execute after the user logs in and the `solid` data defined above have been populated.

One good use for this is to load arbitrary data which requires the user to be logged in. You can use the [query-ldflex] api for this, which is available at `this.$solid.data`.

```vue
//your-component.vue
<template>
  <span class="more-data">{{ moreData }}</span>
</template>
<script>
export default {
  name: 'YourComponent',
  data: {
    moreData: null, //initial value, will populate when the user logs in
  },
  solid: {...},
  async loggedIn() {
    this.moreData = await this.$solid.data['some-rdf-url-with#more-data']['somepredicate']
  }
}
</script>
```

## Solid Auth Client

A reference to the `solid.auth` object from [solid-auth-client] is availabe at `this.$solid.auth`. This essentially saves you from doing `import auth from 'solid-auth-client'` in every component.

```js
this.$solid.auth.fetch('https://timbl.com/timbl/Public/friends.ttl')
  .then(console.log);
```

## Query LDFlex

A reference to the `data` object from [query-ldflex] is available at `this.$solid.data`. This essentially saves you from doing `import data from 'query-ldflex'` in every component.

```js
console.log(await this.$solid.data['https://ruben.verborgh.org/profile/#me'].friends.firstName);
```

[solid-auth-client]: https://github.com/solid/solid-auth-client 'Solid Auth Client'
[query-ldflex]: https://github.com/solid/query-ldflex 'Query LDFlex'

repository: JordanShurmer/vue-solid-plugin

gha_language: JavaScript

gha_license_id: MIT

repo_name: JordanShurmer/vue-solid-plugin


text:
# Notables

## Web
- https://developer.mozilla.org/en-US/docs/Learn
- https://docs.emmet.io/cheat-sheet/

### HTML
- https://developer.mozilla.org/en-US/docs/Web/HTML
- https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/HTML5
- https://www.wpkube.com/html5-cheat-sheet

# ticks

## Notes from [exceptionnotfound](https://exceptionnotfound.net)
>  Concepts have a longer shelf life than details, because details change. Languages are born and die, frameworks become unpopular overnight, companies go out of business, support will end. But the thoughts, the ideas, the best practices? They live forever.

> It doesn't matter what framework you like, what stack you use, what technology you're currently in love with. Just pick one, learn that, master that.

> Code is ephemeral, concepts are eternal. Code is static; it will die, fall apart, degrade. It may take a long time, years or decades, but it will happen. But the concepts which programming lives off of do not die; they live on.

- [ ] Read and follow exceptionnotfound
  - https://github.com/exceptionnotfound
  - https://exceptionnotfound.net/code-is-ephemeral-concepts-are-eternal/
  - https://exceptionnotfound.net/decimal-vs-double-and-other-tips-about-number-types-in-net/
    - https://projects.ncsu.edu/labwrite/Experimental%20Design/accuracyprecision.htm
- [ ] Markdown
- [ ] GFM
- [ ] https://projects.ncsu.edu/labwrite/Experimental%20Design/accuracyprecision.htm

- WebApi [HttpGet("[action]")]
- Linq OrderBy
- NPOI Excel Reading

```
$ - String interpolation
@ - String verbatim
{0} - Composite formatting
string message = $"I am {username}, {age} year{(age == 1 ? "" : "s")} old";

Should have any white space between the $ and the " that starts the string. Doing so causes a compile-time error.
The $ token must appear before the @ token in a verbatim interpolated string.
```

```
for(let code=0;code<256;code++)console.log(code, String.fromCharCode(code))
```

```
using Newtonsoft.Json.Converters;
[JsonConverter(typeof(DateFormatConverter), "yyyy-MM-dd")]
public DateTime MaturityDate { get; set; }

public class DateFormatConverter : IsoDateTimeConverter
{
    public DateFormatConverter(string format)
    {
        base.DateTimeFormat = format;
    }
}
```

```
table{
  table-layout: fixed;
  width: 100%;
  border-collapse: collapse;
}
td {
  overflow: hidden;
  white-space: nowrap;
  text-overflow: ellipsis;
  border: 1px dashed grey;
}
td:hover {
  text-overflow: clip;
  white-space: normal;
  word-break: break-all;
}
```


text:
  🌐

  Create Universal React App

  Configuration-free SSR for Create React App

**This is a fork of Create React App. For details on Create React App itself, see the [official repository](https://github.com/facebook/create-react-app/).**

## Getting Started

### For new projects

To create a new project with SSR, just use `npm init`:

```bash
npm init universal-react-app my-ssr-app
```

Alternatively, you can use plain old create-react-app with a `--react-scripts universal-react-scripts` option:

```bash
create-react-app my-ssr-app --scripts-version universal-react-scripts
```

Either way, you'll get the standard Create React App template with one extra file: `src/index.node.js` (which is where you'll handle server side rendering).

### For existing projects

In your package.json, just change the `react-scripts` dependency to `universal-react-scripts`. _You can leave the occurences of `react-scripts` in the `scripts` object as is._ Then, re-run `yarn install` or `npm install`, and add a `src/index.node.js` file:

```js
import fs from 'fs';
import React from 'react';
import { renderToString } from 'react-dom/server';
import './index.css';
import App from './App';

const renderer = async (request, response) => {
  // The index.html file is a template, which will have environment variables
  // and bundled scripts and stylesheets injected during the build step, and
  // placed at the location specified by `process.env.HTML_TEMPLATE_PATH`.
  //
  // To customize the rendered HTML, you can add other placeholder strings,
  // and replace them within this function -- just as %RENDERED_CONTENT% is
  // replaced. Note however that if you name the placeholder after an
  // environment variable available at build time, then it will be
  // automatically replaced by the build script.
  let template = fs.readFileSync(process.env.HTML_TEMPLATE_PATH, 'utf8');
  let [header, footer] = template.split('%RENDERED_CONTENT%');
  let body = renderToString(<App />);
  let html = header + body + footer;
  response.send(html);
};

export default renderer;
```

Your app will now call the function exported by `src/index.node.js` to render its HTML.

_Note: if you encounter any build errors after making this change, try deleting your `node_modules` and reinstalling them from scratch._

## Build output

Universal React Scripts outputs two versions of your app: a browser version, and a node version. The node version is just a common-js version of `index.node.js`, which you can import in your express app or serverless function to handle server side rendering.

## `serve` script

Universal React Scripts includes a `serve` script for testing your build output:

```bash
npm run serve

# or

yarn serve
```

This launches a server for the content in the `build` folder, and when a `index.node.js` file exists, it loads the Node bundle and server the app with server rendering.

## Server Rendering with Serverless / Cloud Functions

CURA can be used to do serverless SSR -- for example, using Firebase Functions. To get this working, you'll need to package up the files in `build/node` and then call them within your serverless function.

### With Firebase Functions

**[See the example repository with routes, react-helmet and styled-components »](https://github.com/jamesknelson/cura-firebase-example)**

You can create a package with your app's commonjs code by setting the `name`, `files` and `main` fields in your app's `package.json`. Once the package is configured correctly, you'll be able to use `npm pack` to create a `tgz` file that can be added as a dependency to your functions `package.json` -- which can be automated by adding a bash script as a `predeploy` step.

**Changes to `package.json`:**

```json
{
  "name": "app",
  "main": "build/node/index.js",
  "files": ["build/node/*.*"],
  "scripts": {
    "deploy": "firebase deploy",
    "predeploy": "sh ./scripts/pack.sh"
  }
}
```

**`scripts/pack.sh`:**

```bash
rm functions/renderer.tgz
npm run build
mv "$(npm pack)" functions/renderer.tgz
```

**`functions/package.json`:**

```json
{
  "optionalDependencies": {
    "app": "./renderer.tgz"
  }
}
```

The result of these three files is that each time you call `yarn deploy` or `npm run deploy`, a version of your app's `index.node.js` file will be built, packaged, and then made available to your firebase functions. You can then import it and use it as so:

```js
const admin = require('firebase-admin');
const functions = require('firebase-functions');

admin.initializeApp();

let renderer;
if (process.env.NODE_ENV === 'production') {
  // Load the renderer from the packaged version when deploying
  renderer = require('app').default;
} else {
  // Load the renderer directly from the build directory during development.
  // Note: the renderer is not used in development as CURA includes its own
  // renderer, but the functions emulator fails without this.
  renderer = require('../build/node').default;
}

exports.renderer = functions.https.onRequest(renderer);
```

Finally, if you're using Firebase Hosting, you'll need to configure it to route all non-static requests to the `renderer` function. Here's what the resulting `firebase.json` looks like:

```json
{
  "hosting": {
    "public": "build/web",
    "ignore": ["firebase.json", "**/.*", "**/node_modules/**"],
    "rewrites": [
      {
        "source": "**",
        "function": "renderer"
      }
    ]
  }
}
```

_You can see an example of this setup, along with async routing, styled components and react-helmet, at the [cura-firebase-example](https://github.com/jamesknelson/cura-firebase-example) repository._

## The rest is just Create React App

Learn more at the [Create React App](https://facebook.github.io/create-react-app/) website.

If you'd like to understand the changes this fork makes to standard Create React App, see the [Pull Request](https://github.com/facebook/create-react-app/pull/6747).

## License

Create React App is open source software [licensed as MIT](https://github.com/facebook/create-react-app/blob/master/LICENSE).

repository: savtym/create-universal-react-app

repo_name: savtym/create-universal-react-app


text:
---
home: true
heroImage: /images/home/hero_banner.png
heroText: Welcome to Apache Doris
tagline: A fast MPP database for all modern analytics on big data.
structure:
  text: Apache Doris Data Interaction
  subText:
  title:
  descriptions:
    - Apache Doris is a modern MPP analytical database product. It can provide sub second query delay and support real-time data analysis effectively. Its distributed architecture is very simple, easy to operate and maintain, and can support 10PB level data scale.
    - Apache Doris can meet your various data analysis needs, including fixed historical reports, real-time data analysis, interactive data analysis, and exploratory data analysis. Make your data analysis easier!
  image: /images/structure-fresh.png
  actionText: Learn More
  actionLink: /zh-CN/getting-started/basic-usage
features:
  text: Apache Doris Core Features
  subText:
  list:
    - title: Modern MPP architecture
      icon: /images/home/struct.png
    - title: Getting result of a query within one second
      icon: /images/home/clock.png
    - title: Support standard SQL language, compatible with MySQL protocol
      icon: /images/home/sql.png
    - title: Vectorized SQL executor
      icon: /images/home/program.png
    - title: Effective data model for aggregation
      icon: /images/home/aggr.png
    - title: Rollup，novel pre-computation mechanism
      icon: /images/home/rollup.png
    - title: High performance, high availability, high reliability
      icon: /images/home/cpu.png
    - title: easy for operation，Elastic data warehouse for big data
      icon: /images/home/dev.png
cases:
  text: Apache Doris Users
  subText:
  list:
    - logo: /images/home/logo-meituan.png
      alt: 美团
    - logo: /images/home/logo-xiaomi.png
      alt: 小米
    - logo: /images/home/logo-jd.png
      alt: 京东
    - logo: /images/home/logo-huawei.png
      alt: 华为
    - logo: /images/home/logo-baidu.png
      alt: 百度
    - logo: /images/home/logo-weibo.png
      alt: 新浪微博
    - logo: /images/home/logo-zuoyebang.png
      alt: 作业帮
    - logo: /images/home/logo-vipkid.png
      alt: Vipkid
    - logo: /images/home/logo-360.png
      alt: 360
    - logo: /images/home/logo-shopee.png
      alt: Shopee
    - logo: /images/home/logo-tantan.png
      alt: 探探
    - logo: /images/home/logo-kuaishou.png
      alt: 快手
    - logo: /images/home/logo-sohu.png
      alt: 搜狐
    - logo: /images/home/logo-yidian.png
      alt: 一点资讯
    - logo: /images/home/logo-dingdong.png
      alt: 叮咚买菜
actionText: Quick Start →
actionLink: /zh-CN/installing/compilation
---

repository: hffariel/test-docs

repo_name: hffariel/test-docs


text:
---
title: Phase 2 - Design
keywords: design, planning, checklists, research, stakeholder, governance, compliance, requirements,
sidebar: appdesign_tools_sidebar
toc: true
folder: app_design_tools
---
## Principles
The design phase involves the development of the high level and detailed level design of the mobile app.

The design must:
* Address the top level and detailed level requirements
* Refer to and comply with the NWIS design standards
* Include wireframes that follow the prescribed NWIS mobile app layout
* Use wireframes and documentation to demonstrate UX, using tools the stakeholder and development teams can understand, including how the UX meets a specific requirement or requirements
* Specify UI assets
* Specify each icon and attributes (size and colour), colour palette used for page, font and font size

### Generic Layout Showing Menu Item Locations

Menu items:
* 1 – used for general information provision, content, feeds, library, guides
* 2 – used for community and communication functions
* 3 – home button using NHS Wales icon: homepage must display most important app feature or summary of most important information
* 4 – notifications, alerts, watchlists
* 5 - Outputs specific to the app such as results reports, galleries

### Clinical App Design

## Checklist
Check that the team has completed the requirements specification and checklist before proceeding.

		 Work to requirements specification

		 Refer to design standards

		 Create wireframes and walkthroughs

		 Evidence ongoing engagement with stakeholders

		 Create one to three design options

		 Validate design options with stakeholders

		 Evidence engagement with technical developers

		 Check compliance with design standards

		 Complete supporting assurance documentation, including all documentation related to this stage, like exceptions and authority documentation

		 Sign off from problem owner and development team

repository: nwisbeta/mobile-app-design

repo_name: nwisbeta/mobile-app-design


text:
# Introduction

browscap-js-cache is a extraction of the cache class created for browscap.js

# Installation

Using npm run `npm install browscap-js-cache`

You can get npm from http://npmjs.org/

Alternatively you can clone the git repository

# Examples

There is a test.js file which demonstrates how to use browscap-js-cache.

To run:

```node
$ npm test
```


text:
## Go for Light Table

An unofficial Go language plugin for Light Table.

I'm not a Clojure expert so don't expect too much fanciness here, changes are welcome.

### Features

1. `go fmt` integration, via command and after each save.
2. Dummy eval `Ctrl+Enter` (check client/echo_server.go) instead of code evaluation. Needs integration with MarGo (like [GoSublime](https://github.com/DisposaBoy/GoSublime)).
3. `go build` integration, via command. Builds in current file directory
4. `go run` integration, via command.

### Credits

Thanks to Rafe Rosen and Mads:

https://groups.google.com/forum/#!topic/light-table-discussion/Dg0ldzLx4F4

https://groups.google.com/forum/#!topic/light-table-discussion/ow_vhto7uDY

### License

Copyright (C) 2014 Carlos Cobo<EMAIL_ADDRESS>
Distributed under the MIT license, see LICENSE.md for the full text.

repository: zhanghaojie/LightTable-Go

gha_language: Clojure

repo_name: zhanghaojie/LightTable-Go


text:
# psyplot

This package has been developed by **Philipp Sommer** ([Chilipp](https://github.com/Chilipp/)).

**psyplot** is an open source python project that mainly combines the plotting utilities
of matplotlib and the data management of the xarray package. The main purpose is to
have a framework that allows a fast, attractive, flexible, easily applicable, easily
reproducible and especially an interactive visualization of your data.

The ultimate goal is to help scientists and especially climate model developers in
their daily work by providing a flexible visualization tool that can be enhanced
by their own visualization scripts. psyplot can be used through the python command
line and through the psyplot-gui module which provides a graphical user interface
for an easier interactive usage.

The package is very new and there are many features that will be included in the future.
So we are very pleased for feedback! Please simply raise an issue on GitHub (see also
How to contribute in the docs).

You can see the full documentation and examples on [readthedocs.org](http://psyplot.readthedocs.io/en/latest/).

The examples cover the visualization of a [rectilinear](https://psyplot.readthedocs.io/projects/psy-maps/en/latest/examples/example_mapplotters.html#gallery-examples-example-mapplotters-ipynb), [circumpolar](https://psyplot.readthedocs.io/projects/psy-maps/en/latest/examples/example_circumpolar.html#gallery-examples-example-circumpolar-ipynb) and [ICON](https://psyplot.readthedocs.io/projects/psy-maps/en/latest/examples/example_ugrid.html#gallery-examples-example-ugrid-ipynb) data, both for scalar and for vector fiels on a map.

See also:

	https://github.com/Chilipp/psyplot

repository: KMFleischer/PyEarthScience

gha_language: Jupyter Notebook

repo_name: KMFleischer/PyEarthScience


text:
# oh-my-genee-theme
A theme for oh-my-bash based on builtin powerline theme,  with nerd font required. I tested in my macOS env.

> BTW, 相对于oh-my-zsh, oh-my-bash其实是个buggy货色, 不过习惯了bash..就不换了

## Screenshot
![screenshot](screenshot.png)

## Requirements
1. `bash`
2. `homebrew`

## How to Use it?
1. install latest bash to `/usr/local/bin/bash`.
```bash
brew install bash
```
2. make sure your default shell is bash 4+ instead of built-in one.
```bash
echo '/usr/local/bin/bash' | sudo tee -a /etc/shells
sudo chsh -s /usr/local/bin/bash $USER
```
3. install `oh-my-bash` from `https://ohmybash.github.io`.
```bash
sh -c "$(curl -fsSL https://raw.github.com/ohmybash/oh-my-bash/master/tools/install.sh)"
```
4. install this theme.
```bash
git clone https://github.com/iamfat/oh-my-genee-theme $HOME/.oh-my-bash/custom/themes/genee
```
4. install nerd font.
```bash
brew tap caskroom/fonts
brew cask install font-hack-nerd-font
```
5. update `.bashrc` to load genee theme.
```bash
sed -i 's/^OSH_THEME=.*$/OSH_THEME="genee"/' $HOME/.bashrc
```

repository: iamfat/oh-my-genee-theme

repo_name: iamfat/oh-my-genee-theme


text:
# CustomFontWidgets
Android library for setting custom fonts to UI Widgets. Works with 4.2+

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Supported Version](https://img.shields.io/badge/Android-4.2%2B-green)](https://github.com/gomods/athens)

Currently this library includes following UI Widgets.
* FontTextView
* FontEditText
* FontCheckBox
* FontRadioButton
* FontButton

### Demo

    <img src="/Screenshots/Screenshot_20200818-103901_CustomFontWidgetsSample.jpg" width="420px" height="800"

## Getting Started
1. Add Gradle dependency to your `build.gradle`:
```gradle
dependencies {
   implementation 'awesome.vrund.customfontwidgets:CustomFontWidgets:1.0.1@aar'
}
```
2. create `fonts` folder inside your `assets` folder. and move your fonts inside that folder

    <img src="/Screenshots/Screenshot 2020-08-18 at 11.04.08 AM.png" height="100px"

3. Add any of the available widegt in your XML file.

```xml
<awesome.vrund.customfontwidgets.FontTextView
    android:id="@+id/fontTextView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello,"
    android:textColor="@android:color/black"
    android:textSize="24sp"
    app:customFont="Spooky.ttf" />
```
Set custom font using
```xml
app:customFont="Spooky.ttf"
```

or Programmatically
```java
fontTextView.setCustomFont("Spooky.ttf");
```
BINGO!!!!!! you are good to go

## Developed By
* Vrund Purohit -<EMAIL_ADDRESS>
## Licence

```
Copyright 2020 Vrund Purohit

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

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

```

gha_language: Kotlin


text:
# Gobaker

Standard 3D modeling programs (e.g. Blender or 3DS Max) can do baking process of highpoly mesh to a lowpoly model, but they lack alpha checking.

When you want to bake 2 single faces with alpha texture on them, each program will write whatever is on the fartest triangle from the mesh, ignoring each triangle underneath. This program was made to solve this issue.

![Issue with expected result](https://i.imgur.com/SN0Ds6H.png)

Repository contains two programs, one written in Go which represent backed for baking operation and second one which is GUI app written is C#.

## Requirements
* Each texture has to be either in .png or .jpg format
* Each mesh has to be triangulated

**Currently Mask/ID map blue channel is multiplied by vertex alpha value and the Mask/ID map alpha channel is the depth map, it is not rendered from highpoly texture**

## Basic usage
This application needs following files:
* Lowpoly mesh in OBJ file format
* Highpoly mesh in OBJ file format (with metarial names, su you need to export OBJ with MTL)
* Highpoly mesh in PLY file format with saved vertex alpha color
* Textures for lowpoly mesh:
    * Albedo/Diffuse with Opacity in alpha channel
    * Mask/Id map

## Console application
For console application specifi flags are supported.
Keyboard controls are indicated below.

### Required flags
Description | Flag
--- | :---:
Render size of the output image | _-s_
Path to lowpoly mesh            | _-lp_
Path to highpoly mesh           | _-hp_
Path to PLY mesh                | _-ply_

### Optional flags
Description | Flag
--- | :---:
Use ID map (if false, you don't have to add PLY file path) | _-id_
Max ray front distance | _-frontD_
Max ray rear distance | _-rearD_
Rendered image output directory | _-o_
Use half of available CPU cores. Otherwise use all available CPU cores | _-useHalfCPU_

## GUI application
For GUI version of this app setting every flag from above (except optional flags) can be set using buttons. This version usees all available CPU cores.

![GUI applcation](https://i.imgur.com/YzWjlf6.png)

repository: rstolarski/gobaker

repo_name: rstolarski/gobaker


text:
# Case study – Contoso Bicycle

Contoso Bicycle is a fictitious company. The company is a small and fast-growing startup that provides online web services to its clientele in the west coast, North America. The web services were deployed to the cloud from the get-go. They have no on-premises data centers or legacy applications. Here's the brief cloud profile:

- Have several workloads running and operating in Azure.
- Use Azure Active Directory for identity management.
- Knowledgeable about containers and have considered them for application development.
- Aware of Kubernetes as a well-known container orchestration.
- Researched AKS as a possibility.

The IT teams need guidance about architectural recommendations for running their web services in an AKS cluster.

Based on the company's profile and business requirements, we've created a [reference architecture](https://aka.ms/architecture/aks-baseline) that serves as a baseline with focus on security. The architecture is accompanied with the implementation found in this repo. We recommend that you start with this implementation and add components based on your needs.

## Organization structure

Contoso Bicycle has a single IT Team with these sub teams.

![Contoso teams](contoso-teams.svg)

### Architecture team

Work with the line of business from idea through deployment into production. They understand all aspects of the Azure components: function, integration, controls, and monitoring capabilities. The team evaluates those aspects for functional, security, and compliance requirements. They coordinate and have representation from other teams. Their workflow aligns with Contoso's SDL process.

### Development team

Responsible for developing Contoso’s web services. They rely on the guidance from the architecture team about implementing cloud design patterns. They own and run the integration and deployment pipeline for the web services.

### Security team

Review Azure services and workloads from the lens of security. Incorporate Azure service best practices in configurations. They review choices for authentication, authorization, network connectivity, encryption, and key management and, or rotation. Also, they have monitoring requirements for any proposed service.

### Identity team

Responsible for identity and access management for the Azure environment. They work with the Security and Architecture teams for use of Azure Active Directory, role-based access controls, and segmentation. Also, monitoring service principles for service access and application level access.

### Networking team

Make sure that different architectural components can talk to each other in a secure manner. They manage the hub and spoke network topologies and IP space allocation.

### Operations team

Responsible for the infrastructure deployment and day-to-day operations of the Azure environment.

## Business requirements

Here are the requirements based on an initial [Well-Architected Framework review](https://docs.microsoft.com/assessments/?id=azure-architecture-review).

### Reliability

- Global presence: The customer base is focused on the West Coast of North America.
- Business continuity: The workloads need to be highly available at a minimum cost. They have a Recovery Time Objective (RTO) of 4 hours.
- On-premises connectivity: They don’t need to connect to on-premises data centers or legacy applications.

### Performance efficiency

The web service’s host should have these capabilities.

- Auto scaling: Automatically scale to handle the demands of expected traffic patterns. The web service is unlikely to experience a high-volume scale event. The scaling methods shouldn't drive up the cost.
- Right sizing: Select hardware size and features that are suited for the web service and are cost effective.
- Growth: Ability to expand the workload or add adjacent workloads as the product matures and gains market adoption.
- Monitoring: Emit telemetry metrics to get insights into the performance and scaling operations. Integration with Azure Monitor is preferred.
- Workload-based scaling: Allow granular scaling per workload and independent scaling between different partitions in the workload.

### Security

- Identity management: Contoso is an existing Microsoft 365 user. They rely heavily on Azure Active Directory as their control plane for identity.
- Certificate: They must expose all web services through SSL and aim for end-to-end encryption, as much as possible.
- Network: They have existing workloads running in Azure Virtual Networks. They would like to minimize direct exposure to Azure resources to the public internet. Their existing architecture runs with regional hub and spoke topologies. This way, the network can be expanded in the future and also provide workload isolation. All web applications require a web application firewall (WAF) service to help govern HTTP traffic flows.
- Secrets management: They would like to use a secure store for sensitive information.
- Container registry: Currently not using a registry and are looking for guidance.
- Container scanning: They know the importance of container scanning but are concerned about added cost. The information isn't sensitive, but would like the option to scan in the future.

### Operational excellence

- Logging, monitoring, metrics, alerting: They use Azure Monitor for their existing workloads. They would like to use it for AKS, if possible.
- Automated deployments: They understand the importance of automation. They build automated processes for all infrastructure so that environments and workloads
can easily be recreated consistently and at any time.

### Cost optimization

- Cost center: There’s only one line-of-business. So, all costs are billed to a single cost center.
- Budget and alerts: They have certain planned budgets. They want to be alerted when certain thresholds like 50%, 75%, and 90% of the plan has been reached.

## Design and technology choices

- Deploy the AKS cluster into an existing Azure Virtual Network spoke. Use the existing Azure Firewall in the regional hub for securing outgoing traffic
    from the cluster.
- Traffic from public facing website is required to be encrypted. This encryption is implemented with Azure Application Gateway with integrated web application firewall (WAF).
- Use Traefik as the Kubernetes ingress controller.
- The workload is stateless. No data will be persisted inside the cluster.
- Azure Network Policy will be enabled for use, even though there's a single workload in one line-of-business.
- Azure Container Registry will be used for the container image registry. The cluster will access the registry through Azure Private Link.
- To stay up to date with OS and security patches, have tools to help the restart of nodes when needed.
- AKS will be integrated with Azure Active Directory for role-based access control. This choice is aligned with the strategy of using identity as an operational control plane.
- Azure Monitor will be used for logging, metrics, monitoring, and alerting to use the existing knowledge of Log Analytics.
- Azure Key Vault will be used to store all secret information including SSL certificates. Key Vault data will be mounted by using Azure Key Vault with Secrets Store Container Storage Interface (CSI) driver.
- Two node pools will be used in AKS. The system node pool will be used for critical system pods. The second node pool will be used for the application workload.
- To make sure the workload is scaled properly, requests and limits will be enforced by assigning quotas for the Horizontal Pod Autoscaling (HPA). AKS cluster autoscaler  will be enabled so that additional nodes are automatically provisioned if pods can’t be scheduled.

branch_name: refs/heads/main


text:
to generate something like that.....

\begin{thebibliography}{100}[\RAbibAAname]
\small

% phdthesis
\bibitem[1]{anquetil:tel-01086785}\RAsc{N.~Anquetil},
\newblock {Supporting Software Evolution in the Organizations},
\newblock Accreditation to supervise research, {universite de Lille-1}, May
  2014,
\newblock \href {http://hal.inria.fr/tel-01086785} {\path{[hal:tel-01086785]
  }}.

Pay attention, we make sure that DOI and HALID are managed at the end (in case they were not specified).

\| bibset generator \|
bibset := CZBibParser parse: ('rmod.bib' asFileReference) contents.
bibset scope: CZSet standardDefinitions.
generator := CZBblGenerator new.
generator save: bibset to: 'rmod-Generated.bbl'.

repository: Ducasse/Citezen

gha_language: Smalltalk

repo_name: Ducasse/Citezen


text:
# Dobby

[![Build Status](https://travis-ci.org/DeepSwissVoice/Dobby.svg?branch=master)](https://travis-ci.org/DeepSwissVoice/Dobby)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/7e86942ab7974dcbb95869b01565c27e)](https://www.codacy.com/app/siku2/Dobby?utm_source=github.com&utm_medium=referral&utm_content=DeepSwissVoice/Dobby&utm_campaign=Badge_Grade)
[![codecov](https://codecov.io/gh/DeepSwissVoice/Dobby/branch/master/graph/badge.svg)](https://codecov.io/gh/DeepSwissVoice/Dobby)

> Dobby is by no means a finished product and the documentation is currently more than
lacking! You should *(probably)* not use it unless you know exactly what you're doing

Have you ever wished to have your personal slave? (I hope not!) <br>
Well, Dobby might be able to scratch that itch.
Dobby can do pretty much anything (as long as you code it yourself because I'm too lazy to
code boiler-plate slaves that SwissVoice doesn't need) you need done every now and then.

All you have to do is write a configuration file, start Dobby and you're good to go!
(If you ignore all the bugs)

## Installation
The recommended way of running Dobby is using the Docker image `siku2/Dobby`.
The following tags are available:

|    Tag    |        Description        |
| --------- | ------------------------- |
| `latest`  | stable build
| `dev`     | latest build based on the [development branch]
| `v-x`     | specify major release
| `v-x.y`   | specify the minor release too
| `v-x.y.z` | when you need to go all out...

Mount your config file to `/dobby/config.yml` and you're ready to go!

## Manual Usage
Start Dobby by running `dobby run <config file>`
where `<config file>` points to the location of your [config file](#configuration)...

If you for some reason desire to do a test run (runs through all tasks without waiting)
you can run `dobby test <config file>`

## Configuration
Read the [Documentation]

[Documentation]:        https://deepswissvoice.github.io/Dobby  "The totally finished *cough* documentation"
[development branch]:   /DeepSwissVoice/Dobby/tree/development  "The bleeding edge"

repository: DeepSwissVoice/Dobby

gha_language: Python

repo_name: DeepSwissVoice/Dobby


text:
# User Stories

As a user, I want the webpage to display 3 unique images that people can vote on.

As a user, I want the results of the voting to be displayed after voting on 25 items.

As a developer, I want an image that has been voted on to not appear again.

As a developer, I want to allow people to vote by clicking on the image and make the user aware of that.

path: /user _stories.md

filename: user _stories.md


text:
# position-tracker
Tracking the position of thing

## Data Attribution:
### External Data:
#### UK Postcode Data:
This data came from: https://www.freemaptools.com/download-uk-postcode-lat-lng.htm
The file can be found in: data/external-data/ukpostcodes.csv

repository: philipcarrington/position-tracker

repo_name: philipcarrington/position-tracker


text:
Overview
========

What is Kublai? Kublai is a [pomelo](https://github.com/NetEase/pomelo) plugin for the [Khan](http://khan-api.readthedocs.io/) service.

It allows easy integration with your gaming backend, thus enabling easy-to-use clan management operations.

## Features

* **Pomelo Plug-in** - Just point Kublai Plug-in in the direction of your Khan instance and you are good to go;
* **Additional Data** - Kublai builds on top of Khan to ensure that you make as least requests as possible to achieve what you want;
* **Up-To-Date** - Kublai is managed by the same team working on Khan, thus the parity with Khan's features is ensured.

## Who's Using it

Well, right now, only us at TFG Co, are using it, but it would be great to get a community around the project. Hope to hear from you guys soon!

## How To Contribute?

Just the usual: Fork, Hack, Pull Request. Rinse and Repeat. Also don't forget to include tests and docs (we are very fond of both).

repository: topfreegames/kublai

repo_name: topfreegames/kublai


text:
# NEWS
#### By **KAMAU DENNIS KIHIU**
## Description
This is a project where user search for their repository on github and also search for other users. It is basically a clone of github.
### The sources have been grouped in categories that is:
* general
* business
* science
* health
* entertainment
* technology
* sports
#### click on the following link to view the site:
 news-site
## Known Bugs
No bugs are present

## Technologies Used
The following languages were used:
* HTML
* Python
* CSS
* BOOTSTRAP
## Support and contact details
In case of any trouble comments or contributions, please email me<EMAIL_ADDRESS>### License
*MIT licence*
Copyright (c) 2018 **Kamau Dennis Kihiu**

repository: DK-denno/news

repo_name: DK-denno/news


text:
[![Build Status](https://travis-ci.org/t0rrant/cookbook-shifter.svg?branch=master)](https://travis-ci.org/t0rrant/cookbook-shifter)
[![Cookbook Version](https://img.shields.io/cookbook/v/shifter.svg)](https://supermarket.chef.io/cookbooks/shifter)

# shifter

Chef cookbook that installs Shifter - Linux Containers for HPC

## Requirements

Requires the following cookbooks:

 - 'tar', '~> 2'

This cookbook assumes a munge service is up and running and properly configured, if you are to run an image manager.
See `test/cookbooks/test/recipes/shifterimg_install.rb` for more info.

## Platforms

The following platforms are supported:

- Ubuntu (>= 14.04)
- Debian (>= 8.0)
- CentOS (>= 6)

## Chef

- Chef 14.0+

## TODO

- Add support for other options for udiRoot.conf config file

## Usage

To have the shifter resources available to your cookbook just include ```cookbook 'shifter', '~> 0'``` in your Berksfile.

## Resources

### shifter_compile

Compiles shifter components from [NERSC's git repo](https://github.com/NERSC/shifter/), by default.

### shifter_install

Compiles shifter components, if they haven't been compiled already, and creates appropriate symlinks and config files for Shifter Runtime.

### shifter_install_imagegw

Compiles shifter components, if they haven't been compiled already, and creates appropriate symlinks and config files for Shifter Image Gateway.

| Attribute Name                | Description                                   |
|---|---|
| `['shifter']['system']`       | Name of your system, e.g., edison or cori. This name must match a configured system in the imagegw. This is primarily used by shifterimg to self-identify which system it is representing. |
| `['shifter']['imagegw_fqdn']` | Space seperated URLs for your imagegw. Used by shifterimg and Slurm batch integration to communicate with the imagegw. |

## Authors

* Manuel Torrinha<EMAIL_ADDRESS>


text:
# Paddle Battle (Mango, C#/VB)

|Area|Submitted|Type|
|-|-|-|
Games: 2D Graphics, Games: Gameplay, Games: Graphics, User Experience|5/24/2011|Code Sample
||||

## Description

This sample shows a very basic game written on top of the new Silverlight/XNA application model.

## Sample Overview

One of the new features available to developers targeting Windows Phone OS 7.1 is the ability to mix Silverlight UI and XNA Framework rendering in the same application. This sample contains a very basic game written using the Silverlight application model, with XNA Framework rendering the main portion of the game and using Silverlight UI to render the scores at the top of the screen.

Note the gameplay of this sample is in landscape mode, so when using the emulator be sure to use the controls in the upper right to rotate the emulator into landscape mode.

> All content and source code downloaded from this page are bound to the Microsoft Permissive License (Ms-PL).

Download | Size | Description
---|---|---|
[PaddleBattle_4_0_Mango](https://github.com/simondarksidej/XNAGameStudio/tree/archive/Samples/PaddleBattle_4_0_Mango) | 0.22MB | Source code and assets for the Paddle Battle sample.
[PaddleBattle_4_0_Mango.zip](https://github.com/simondarksidej/XNAGameStudioZips/raw/zips/PaddleBattle_4_0_Mango.zip) | 0.22MB | Source code and assets for the Paddle Battle sample.
[PaddleBattle_4_0_Mango_VB](https://github.com/simondarksidej/XNAGameStudio/tree/archive/Samples/PaddleBattle_4_0_Mango_VB) | 0.21MB | Source code and assets for the Visual Basic version of the Paddle Battle sample.
[PaddleBattle_4_0_Mango_VB.zip](https://github.com/simondarksidej/XNAGameStudioZips/raw/zips/PaddleBattle_4_0_Mango_VB.zip) | 0.21MB | Source code and assets for the Visual Basic version of the Paddle Battle sample.
||||

license: MS-PL

path: /Articles/Paddle Battle (Mango, C#VB).md

filename: Paddle Battle (Mango, C#VB).md


text:
# CocoaPods Size Measurement

According to [this article](https://www.linkedin.com/pulse/top-12-reasons-why-users-frequently-uninstall-mobile-apps-fakhruddin/), the number one reason users uninstall apps is the size. Having a large app can significantly reduce adoption and retention (at the time of writing, apps over 150MB cannot be downloaded over a cellular network). As an SDK developer, it is even more critical to keep your library size in check, as app developers will refuse using your SDK if it adds too much bloat to their app.

This repository provides a set of tools which help with the measurement of the final binary size for the given set of CocoaPods.

## Usage examples

Measuring the size of the CocoaPod named AFNetworking using the latest released version:

```
./measure_cocoapod_size.py --cocoapods AFNetworking

// Output:
Size comes out to be 231568 bytes (measured at version 3.2.1)
```

Measuring the size of the AFNetworking CocoaPod at version 3.2.0:

```
./measure_cocoapod_size.py --cocoapods AFNetworking:3.2.0

// Output:
Size comes out to be 231544 bytes
```

Measuring the size of the FirebaseMessaging CocoaPod at version 3.0.2 with FirebaseAnalytics at version 5.0.0:

```
./measure_cocoapod_size.py --cocoapods FirebaseMessaging:3.0.2 FirebaseAnalytics:5.0.0

// Output:
Size comes to be 1800752 bytes. This is 298212 bytes less when measured together vs each measured individually due to shared dependencies.
```

Measuring the size of AFNetworking CocoaPod at version 3.2.0 present in your SPEC_REPO:

`./measure_cocoapod_size.py --cocoapods AFNetworking:3.2.0 --spec_repos SPEC_REPO`

Measuring the size of RxSwift CocoaPod which is a swift pod:

`./measure_cocoapod_size.py --cocoapods RxSwift --mode swift`

Finding the size between two Xcode projects:

`./xcode_project_diff.py --source_project=PROJECT1 --source_scheme=PROJECT1_SCHEME --target_project=PROJECT2 --target_scheme=PROJECT2_SCHEME`

### Measure pod size from local or bleeding edge version

Measuring the size of FirebaseDatabase CocoaPod from local:

```
./measure_cocoapod_size.py --cocoapods FirebaseDatabase --cocoapods_source_config "./source_config.json"
```
where the `source_config.json` is:
```
{
  "pods":[
    {
      "sdk":"FirebaseDatabase",
      "path":"~/Desktop/firebase-ios-sdk"
    }
  ]
}

```

Measuring the size of FirebaseDatabase CocoaPod from a branch of a remote repo:

```
./measure_cocoapod_size.py --cocoapods FirebaseDatabase --cocoapods_source_config "./source_config.json"
```
where the `source_config.json` is:
```
{
  "pods":[
    {
      "sdk":"FirebaseDatabase",
      "git":"https://github.com/firebase/firebase-ios-sdk",
      "branch":"master"
    }
  ]
}

```

## Available Tools

### measure_cocoapod_size.py

`./measure_cocoapod_size.py --cocoapods $POD_NAME:$POD_VERSION $POD_NAME1:$POD_VERSION1 -mode $POD_TYPE`

This tool provides the size measurement given a combination of CocoaPods. This tool internally uses the xcode_project_diff.py tool.
Please use `./measure_cocoapod_size.py -h` to get the full usage description and a complete list of the available flags.

### xcode_project_diff.py

`./xcode_project_diff.py --source_project=$SOURCE_PROJECT --source_scheme=$SOURCE_SCHEME --target_project=$TARGET_PROJECT --target_scheme=$TARGET_SCHEME`

This tool takes in two Xcode project targets and provides the size difference between the two Xcode project targets. Please use `./xcode_project_diff.py -h` to get the full usage description and a complete list of the available flags.

## Methodology

Our methodology involves doing the following:
- Archive a baseline app as ARM64 with no bitcode
- Add the SDKs we wanted to measure
- Archive a baseline app as ARM64 with no bitcode
- Compute the difference and report on it

For example, using this method for FirebaseAnalytics 5.0.1, we obtain the following number: **1,082,948** which estimates the install size.

iTunes Connect reports both download and install sizes for apps in TestFlight. We have used this to instrument a standalone app, and measured it before and after adding FirebaseAnalytics. The numbers we found here are close to our measurements.

For example, for iPhone 6S:
Download size: **925 KiB**
Install size: **1094 KiB**

The install size is within a range of 3% from our measurements.

repository: google/cocoapods-size

repo_name: google/cocoapods-size


text:
# DefMath
A module with a set of math functions for Defold

## Installation
You can use DefMath in your own project by adding this project as a [Defold library dependency](http://www.defold.com/manuals/libraries/). Open your game.project file and in the dependencies field under project add:

	https://github.com/subsoap/defmath/archive/master.zip

Once added, you must require the main Lua module via

```
local defmath = require("defmath.defmath")
```
Then you can use the DefMath functions for example via

```
print(defmath.round_decimal(0.12345678,3))
```

repository: subsoap/defmath

gha_language: Lua

repo_name: subsoap/defmath


text:
# aws-mock-metadata

The [ec2 instance metadata service](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)
runs on each ec2 instance and provide an api to retrieve information about the running instance as well as
getting credentials based on the IAM role.

I needed to run this service locally (in docker) in order to be able to troubleshoot issues with [kubernetes](https://github.com/kubernetes/kubernetes/)
with the aws provider. I found an existing python based [service](https://github.com/dump247/aws-mock-metadata) but
for some reasons I couldn't get it to work in docker with my temporary credentials. I also needed additional features
like being able to return an instance id, availability zone, etc. so after a few hours of fighting I decided to
create this one.

## Docker quick start

	docker run -it --rm -p 80:8080 -e AWS_ACCESS_KEY_ID=$(AWS_ACCESS_KEY_ID) \
    		-e AWS_SECRET_ACCESS_KEY=$(AWS_SECRET_ACCESS_KEY) jtblin/aws-mock-metadata \
    		--availability-zone=<az> --instance-id=<id> --hostname=<name> --role-name=<role> --role-arn=<arn>
    		--vpc-id=<vpc-id> --private-ip=<ip>

In your other docker image, install iptables and have a startup script that point <IP_ADDRESS> to the docker host
before starting your program:

	iptables -t nat -A OUTPUT -d <IP_ADDRESS> -j DNAT --to-destination ${HOST}

Or if you don't want to modify your docker image, on your docker host (e.g. the one created with docker-machine):

	iptables -t nat -A PREROUTING -d <IP_ADDRESS> -j DNAT --to-destination ${HOST}

## Development

### Configuration

Set the following environment variables or create a .env file with the following information:

* `AWS_ACCESS_KEY_ID`: aws access key
* `AWS_SECRET_ACCESS_KEY`: aws secret access key

Command line arguments:

* `APP_PORT`: port to run the container on (default 8080)
* `AVAILABILITY_ZONE`: ec2 availability zone e.g. ap-southeast-2 (optional)
* `AWS_SESSION_TOKEN`: aws session token (optional)
* `HOSTNAME`: ec2 hostname (optional)
* `INSTANCE_ID`: ec2 instance id (optional)
* `PRIVATE_IP`: ec2 private ip address (optional)
* `ROLE_ARN`: arn for the role to assume to generate temporary credentials (optional)
* `ROLE_NAME`: ec2 role name assigned to the instance (optional)
* `VPC_ID`: vpc id (optional)

**Note**: you will need to have `sts:AssumeRole` for the role that you want to use to generate temporary credentials.
The role also needs to have a trust relationship with the account that you use to assume the role, see
http://stackoverflow.com/questions/21956794/aws-assumerole-authorization-not-working/33850060#33850060.

### Run

Run it. This will run the bare server on localhost.

    make build run

Run it on <IP_ADDRESS> on Mac OSX or linux.

    make build run-macos
    make build run-linux

Run in docker

	make docker run-docker

repository: HLOverflow/aws-mock-metadata

repo_name: HLOverflow/aws-mock-metadata


text:
---
layout: default
nav_order: 1
has_children: false
parent: Streams
title: Sources Catalog
page_title: Sources Catalog
description: A catalog of sources that integrate with Streams in Zepel
permalink: streams/sources-catalog/
has_children: true
---

# Sources Catalog
{: .no_toc }

Connect multiple sources with Zepel and consolidate product feedback, feature requests, and error logs from several customers in one single place.

This enables you and your team to:
- build products with context
- prioritize
- delegate priorities to squads
- align squads with the prioritized outcomes

Zepel supports the following sources:

- [Intercom]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-intercom.md %})
- [Zendesk]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-zendesk.md %})
- [Canny]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-canny.md %})
- [Sentry]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-sentry.md %})
- [GitHub Issues]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-github-issues.md %})
- [Monday.com]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-monday.md %})
- [Trello]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-trello.md %})
- [Asana]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-asana.md %})
- [Slack]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-slack.md %})
- [API](https://zepel.io/developers/api/v2/#streams)
- [Internal Requests]({{ site.url }}{{ site.baseurl }}{% link guide/streams-catalog-internal-requests.md %})

![Zepel Streams](/guide/assets/uploads/zepel-streams.png)

repository: svikashk/docs

branch_name: refs/heads/develop

gha_language: SCSS

repo_name: svikashk/docs


text:
![GeneralAssemb.ly](../../img/icons/FEWD_Logo.png)

#FEWD - jQuery Review

A whirlwind review of jQuery.

---

##Best Practices

- Put your jQuery scripts at the bottom of your page. This will help ensure the HTML document has time to load and your script will actually have something to target.
- Wrap your functions and your jQuery in `$(document).ready(function{ //your jQuery awesomeness in here });`
- **DON'T FORGET TO INCLUDE THE JQUERY LIBRARY IN THE `<head></head>` OF YOUR PAGE!** Remember, you can Google "Google jQuery script" and get the link from the Google Developer Library.

---

##Selectors in jQuery

Remember, in jQuery, you must target something or else your script is for naught!

You can target a tag, ID, or class. Remember, the selector goes at the beginning of your jQuery statement:

```
$("#id-here")
$(".class-here")
$("p")
```
---

##Useful jQuery Functions

There are a myriad of functions you can do in jQuery once you've selected something to manipulate. You can change a CSS property, add an attribute, add or remove a class to an element, hide it, show it, etc.

---

##Useful jQuery Functions

If you want to manipulate the CSS of an element, you would use ```.css```:

```
$("p").css("color", "#333");
```

The syntax when using ```.css``` is:
.css("attribute", "value");

---

##Useful jQuery Functions

You can manipulate more than one CSS attribute using  ```.css```. The syntax looks like this:

.css({ "attribute" : "value", "attribute" : "value" });

Example:

```
$(".box").css({
	"color" : "#333",
	"background" : "#999"
});
```

---

##Useful jQuery Functions

If you wanted to add an attribute to an element, you would use ```.attr```:

```
$(".menu a").attr("href", "http://www.google.com");
```

The syntax when using ```.attr``` is:
.attr("attributename", "value");

---

##Useful jQuery Functions

To show and hide elements, there are two different sets of functions you can use.

```.show()``` / ```.hide()``` / ```.toggle()```

or

```.slideUp()``` / ```.slideDown()``` / ```.slideToggle()```

These are the equivalent of setting ```display: block``` (show) and ```display: none``` (hide) in CSS.

---

##Useful jQuery Functions

The only difference between show/hide and slideUp/slideDown is how the element appears and disappears.

Show/Hide is like taking the bottom right corner of the box and dragging it out to reveal the item or hide the item.

SlideUp/SlideDown is the equivalent of taking the bottom edge of the element and dragging it downward or upward to show or hide it.

---

##Useful jQuery Functions

Remember that ```.toggle()``` toggles only between ```.show()``` and ```.hide()```.

Conversely, ```.slideToggle()``` toggles between ```.slideUp()``` and ```.slideDown()```.

---

##Useful jQuery Functions

The show/hide and slide functions can take a speed parameter. This controls how fast the item appears and disappears.

This speed is measured in milliseconds. So, 1 second is 1000 milliseconds. The fastest speed you can indicate is 100. The syntax is as follows:

```
$(".open").hide(100);
```

You can also use 'fast' or 'slow':

```
$(".peekaboo").slideToggle('fast');
```

---

##Useful jQuery Functions

You can add, remove, and toggle classes in jQuery. This is helpful if you want to add an active state in a menu or want to toggle between classes.

The functions are:

```
.addClass()
.removeClass()
.toggleClass()
```

You only need to put the name of the class you want to work with - with no period - in the parentheses:

```
$("p").toggleClass("red");
```

---

##Useful jQuery Functions

**Tip:** If you wish to add and remove classes, it's best to write a line of jQuery that removes the class from all similar elements first, then write another line of jQuery immediately after that adds the class to the particular element you're targeting in the function.

Same goes for when you want to show and hide items. Hide everything first, then show the thing you want.

Remember, write the general rule first, then the exceptions to the rule.

---

##Useful jQuery Functions

You can also detect the presence of a class in a particular element. You can use ```.hasClass()``` to do this. This is useful for writing if/else statements in jQuery.

---

##Keyword: "This"

In jQuery "this" refers to the selected object.

---

##This in jQuery

How about this code?

```
$('a').on('click',function(e){
    $(this).fadeOut(500);
});
```

In the above code, this means that when you click on a link, it will fade that link out at a speed of 500 milliseconds.

---

##Tree Traversal

Using ```$(this)``` is especially useful for traversing the DOM tree - in other words, navigating through the tags you have written in your HTML document.

You can use several jQuery functions to help you select nearby or related elements.

---

##Tree Traversal

The first method of traversal is using ```.prev()``` and ```.next()```.

This looks at the first selector you declared and then selects the next tag or previous tag from your starting point.

---

##Tree Traversal

For instance, if you had HTML like this:

``

Something

Something else

``

And you wrote this jQuery statement:

```
$("li.menu-item").prev()
```

You would wind up working with the ```ul``` tag.

---

##Tree Traversal

If you had HTML like this:

`

Something

Something else

`

And you wrote this jQuery statement:

```
$("li.menu-item").next()
```

You would wind up working with the ```li``` tag immediately after the one with the class of .menu-item.

---

##Tree Traversal

The other means of traversal is by using these three functions:

```
.parent()
.children()
.siblings()
```

In the case of an unordered list:

- ```ul``` would be the parent
- ```li``` would be the child of ```ul```
- all the ```li``` items within that ```ul``` are siblings

---

##Useful jQuery Scripts

You don't have to write jQuery from scratch, though you might for simple menus or other simple tasks.

 Maybe tabs for people to navigate through? Accordions? Carousels?

These are two really nifty libraries that have a wide range of stuff you could use:

- **jQuery UI:** http://jqueryui.com/
- **jQuery Tools:** http://jquerytools.org/

---

##Pop Me Up

You ever see those fancy popup boxes that black out the background of a page? These are often used in photo galleries, but you see other uses for them. They are called modal windows. Modal yourself here:

- **FancyBox:** http://fancyapps.com/
- **Lightbox** (actually a JavaScript library, not jQuery): http://lokeshdhakar.com/projects/lightbox2/
- **Colorbox:** http://www.jacklmoore.com/colorbox/

---

##Fancy Scrollers

You may see some nifty "one-page" sites out there, that have sliding panels or links that scroll smoothly to a different part of the page.

- **One Page Nav Sample:** http://davist11.github.io/jQuery-One-Page-Nav/
- **Another One Page Demo:** http://www.thepetedesign.com/demos/onepage_scroll_demo.html

---

##Sticky Stuff

Sometimes, you have a header or footer or other element that you want to "stick" in place. jQuery is a nifty way to do this.

- **HCSticky:** http://someweblog.com/hcsticky-jquery-floating-sticky-plugin/

---

##Equalize me!

Sometimes, you have multiple columns that you need to make sure are the same size. You could use CSS to set a min-width, but what if you're never sure what the height of your content is going to be? No problem, Equalize will rescue you:

- **Equalize:** http://tsvensen.github.io/equalize.js/

---

##Fun With Grids

Sometimes, you'll see a really cool grid layout where all the boxes aren't the same height or length, but everything fits nicely together like bricks. It makes for a nice collage effect. To achieve that, use one of these:

- **Masonry:** http://masonry.desandro.com/
- **FreeWall:** http://vnjs.net/www/project/freewall/

---

##Hamburger Drawers

If you'd like to employ the ubiquitous hamburger navigation and use what's called a navigation drawer (comes in from the side), try this:

- **BigSlide:** http://ascott1.github.io/bigSlide.js/

---

##Video-Related Things

jQuery does some cool stuff with video. If you need your video to resize properly in a responsive design, use fitVids:

- **FitVids:** http://fitvidsjs.com/

If you'd like to use video as a background, check these out:

- http://dfcb.github.io/BigVideo.js/
- http://vodkabears.github.io/vide/

---

#...And So Much More!

Remember, Google is your friend. Chances are, if you need something in jQuery, someone has created it. Most really good jQuery plugins come with documentation that should tell you how to implement and use the plugin. So have fun (but don't go overboard)!

gha_language: CSS


text:
This is a bot I wrote in python to assist me in administrating the Reddit Mechanical Keyboards Discord Server.

Functions Include-
- Adding roles by keyword.
- Purging messages.
- Hiding channels on command.
- A simple vote function using emoji reactions.
- Tracking server activity (message count and active members) - WIP with overhaul
- Raffle function that select members who reacted to a message.

## Thanks to:
- [discord.py](https://github.com/Rapptz/discord.py) the API Wrapper Used
- [Mee6](https://github.com/cookkkie/mee6) Served a guide to build my plugin system.

repository: tankoks/MechKeys-Discord-Bot

repo_name: tankoks/MechKeys-Discord-Bot


text:
# Android Object Detection - OpenCV and YOLO

 Real time object detection Android application using OpenCV 4.1 and YOLO.

Author: Matteo Medioli

YOLO: https://pjreddie.com/darknet/yolo/

## 1.Import OpenCV 4.1 Module in AndroidStudio 3.4.1
1) Dowload OpenCV SDK from https://sourceforge.net/projects/opencvlibrary/files/4.1.0/opencv-4.1.0-android-sdk.zip/download
2) Clone this project.
3) Open Android Studio and import this project.
4) Build project.
5) From AndroidStudio top-menù select **New -> Import Module** and select your path to OpenCV sdk folder (i.e */where_opencv_saved/OpenCV-android-sdk/sdk*) and rename module as OpenCV.
6) After load OpenCV module, re-build project.

## 2.Add OpenCV dependecies to your application
After OpenCV module import:
1) From AndroidStudio top-menù select **File -> Project Structure**
2) Navigate to Dependencies and click on **app**. On the right panel there's a plus button **+** for add Dependency. Click on it and choose **Module Dependecy**.
3) Select **OpenCV** module loaded before.
4) Click Ok and Apply changes.
5) Build project.

## 3.How detection works: CameraActivity.java
This activity is the core of application and it implements *org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2*.
It has 2 main private instance variable: a **net** (*org.opencv.dnn.Net*) and a **cameraView** (*org.opencv.android.CameraBridgeViewBase*).
Basically has three main features:

#### a) Load Network
Load convolutional net from *\*.cfg* and *\*.weights* files and read *labels name* (COCO Dataset) in assets folder when calls onCameraViewStarted() using  **Dnn.readNetFromDarknet(String path_cfg, String path_weights)**.
**NOTE**: this repo doesn't contain weights file. You have to download it from YOLO site.

#### b) Detection from camera preview
Iteratively generate a frame from CameraBridgeViewBase preview and analize it as an image. Real time detection and the frames flow generation is managed by **onCameraFrame(CvCameraViewFrame inputFrame)**.
Preview frame is translate in a Mat matrix and set as input for **Dnn.blobFromImage(frame, scaleFactor, frame_size, mean, true, false)** to preprocess frames. Note that **frame_size** is 416x416 for YOLO Model (you can find input dimension in *\*.cfg* file). We can change the size by adding or subtracting by a factor of 32. Reducing the framesize increases the performance but worsens the accuracy.
The detection phase is implemented by **net.forward(List\<Mat> results, List\<String> outNames)** that runs forward pass to compute output of layer with name *outName*. In *results* the method writes all detections in preview frame as Mat objects.
Theese Mat instances contain all information such as positions and labels of detected objects.

#### c) Draw bounding-box and labelling
Performing **Non Maximum Suppression** by YOLO, in **List\<Mat> results** are stored all coordinates of optimal bounding boxes
(the first 4 numbers are [*center_x, center_y, width, height*], followed by all class probabilities). *classId* is the corresponding index for label of detection in COCO Dataset list *className*.

## TO DO
- [ ] Full screen JavaCameraView portrait mode
- [ ] Speed up JavaCameraView
- [ ] Add model chioce

repository: iamweiweishi/HanRiver

repo_name: iamweiweishi/HanRiver


text:
# A Mix of Timers

This example shows varius ways to use the systimer module.

1. A one-shot timer called `boot_delay` is set for a 5 seconds timeout after initialization.
2. Also a one-shot timer `no_food_for_dog` is set for a 30 secods timeout, which we will
   get into in the last part.
3. After 5 seconds is over the `boot_delay` function initializes a timer task called
   the `one_sec_tick` with an exact 1 second timeout using the `SYS_TIME_SEC(1)` macro.
4. The `one_sec_tick` task continues to run by returning the new timeout, by using
   the `SYS_TIME_OFFSET_LATENCY(timeout, latency)` macro, thereby guaranteeing to keep
   track of exact seconds.
5. After 10 seconds, the `one_sec_tick` functions enables the watchdog with a 250ms
   timeout, and registers a new timer task `feed_the_dog` with a 200ms period to
   reset the watchdog continuosly. Then it deletes itself by returning 0.
6. After a total of 30 seconds has passed. The `no_food_for_dog` function is called,
   this deletes the `feed_the_dog` task, as a result causing a watchdog timeout reset.


text:
# A Retrospective Study Analyzing The Risk Factors For Post-Operative Gastrointestinal Complications After Coronary Artery Bypass Graft (CABG)

Project Status: [Active]

## Project Description
Approximately 515,000 CABG procedures are performed annually. Gastrointestinal complications can represent significant setbacks in cardiac patients’ post-operative care. The objective of this project is to predict which patients are most likely to develop postoperative complications and produce treatment strategies.

### Skills Used
* Data Extraction
* Data Interpretation

### Technologies
* SQL
* Excel Pivot

## Featured Deliverables
* [Code](/3379%20Queries)
* [Protocol](/A%20retrospective%20study%20analyzing%20the%20risk%20factors%20for%20post-operati.pdf)

## Contact
* Find me on [Github](https://github.com/chelseamcqueen).
* Find me on [Linkedin](https://www.linkedin.com/in/chelseamcqueen/).

## Disclaimer
This research was supported (in whole or in part) by HCA Healthcare. The views expressed in this publication represent those of the author and do not necessarily represent the official views of HCA Healthcare or any of its affiliated entities.


text:
# PIZZA INN
#### By Fatma Khamis, 08/03/2021
## Description
This web application allow user to buy pizza of his choice choosing from a variety of toppings and make order online and can add addres information for delivery.
## Demo
Here is a working live demo:https://fatmakhamis.github.io/Pizza-Inn/.
## Setup/Installation Requirements
* Clone the repository
* Change directory to the project directory
* Open project on VSCode
* Start the project on live server
## Behavior Development Driven
* the app displays the types of pizza on offer
* the user should fill his name,email to the sigh up page
* the system prompts a user to make order on the type,size and desired toppings
* the system also calculates the bill and give the total in addition to asking for deliveries
## Known Bugs
* you may need to double click the navigation tabs
## Technologies Used
* HTML
* CSS
* Javascript
* jquery
## Support and contact details
To fix a abug or enhance this project,follow thw steps below:
* Fork the repo
* create a new branch (git checkout new-branch-name)
* make changes
* commit changes+push to the branch
* create a pull request

For more information dont hesitate to contact me on<EMAIL_ADDRESS>### License
[MIT License](https://choosealicense.com/licenses/mit/)
Copyright (c) 2021  FATMA KHAMIS

repository: fatmakhamis/Pizza-Inn

repo_name: fatmakhamis/Pizza-Inn


text:
# log4j2-elasticsearch-hc
This log4j2 appender plugin uses Apache Async HTTP client to push logs in batches to Elasticsearch clusters.

Netty buffer based API guarantees lower memory allocation than [log4j2-elasticsearch-jest](https://github.com/rfoltyns/log4j2-elasticsearch/tree/master/log4j2-elasticsearch-jest).

Output is generated with FasterXML Jackson based [JacksonJsonLayout](https://github.com/rfoltyns/log4j2-elasticsearch/blob/master/log4j2-elasticsearch-core/src/main/java/org/appenders/log4j2/elasticsearch/JacksonJsonLayout.java).

## Maven

```xml
<dependency>
    <groupId>org.appenders.log4j</groupId>
    <artifactId>log4j2-elasticsearch-hc</artifactId>
    <version>1.5.2</version>
</dependency>
```
## Usage

Add `HCHttp` to
* [`logj2.xml`](#example)
* or [log4j2.properties](https://github.com/rfoltyns/log4j2-elasticsearch/blob/master/log4j2-elasticsearch-hc/src/test/resources/log4j2.properties)
* or [configure programatically](#programmatic-config)

It's highly recommended to put this plugin behind `AsyncLogger`. See [log4j2.xml](https://github.com/rfoltyns/log4j2-elasticsearch/blob/master/log4j2-elasticsearch-hc/src/test/resources/log4j2.xml) example.

##### Example
```xml
<Appenders>
    <Elasticsearch name="elasticsearchAsyncBatch">
        <IndexName indexName="log4j2"/>
        <JacksonJsonLayout>
            <PooledItemSourceFactory poolName="itemPool" itemSizeInBytes="1024" initialPoolSize="3000"/>
        </JacksonJsonLayout>
        <AsyncBatchDelivery batchSize="1000" deliveryInterval="10000" >
            <IndexTemplate name="log4j2" path="classpath:indexTemplate-7.json" />
            <HCHttp serverUris="http://localhost:9200">
                <PooledItemSourceFactory poolName="batchPool" itemSizeInBytes="1024000" initialPoolSize="3"/>
            </HCHttp>
        </AsyncBatchDelivery>
    </Elasticsearch>
</Appenders>
```

### HCHttp Properties
Name | Type | Required | Default | Description
------------ | ------------- | ------------- | ------------- | -------------
serverUris | Attribute | no (MUST be specified by either `HCHttp` or `ServiceDiscovery`) | None | List of semicolon-separated `http[s]://host:[port]` addresses of Elasticsearch nodes to connect with.
connTimeout | Attribute | no | 1000 | Number of milliseconds before ConnectException is thrown while attempting to connect.
readTimeout | Attribute | no | 0 | Number of milliseconds before SocketTimeoutException is thrown while waiting for response bytes.
maxTotalConnections | Attribute | no | 8 | Number of connections available.
ioThreadCount | Attribute | no | No. of available processors | Number of `I/O Dispatcher` threads started by Apache HC `IOReactor`
itemSourceFactory | Element | yes | None | `ItemSourceFactory` used to create wrappers for batch requests. `PooledItemSourceFactory` and it's extensions can be used.
mappingType | Attribute | no | `_doc` | Name of index mapping type to use in ES cluster. `_doc` is used by default for compatibility with Elasticsearch 7.x.
pooledResponseBuffers | Attribute | no | yes | If `true`, pooled `SimpleInputBuffer`s will be used to handle responses. Otherwise, new `SimpleInputBuffer` wil be created for every response.
pooledResponseBuffersSizeInBytes | Attribute | no | 1MB (1048756 bytes) | Single response buffer size.

### Service Discovery

Since 1.5, service discovery can be configured using `ServiceDiscovery` tag. Once defined, batches and setup operations will be executed against addresses retrieved from [Nodes API](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster-nodes-info.html).

Supported across all versions of Elasticsearch.

Custom [`ServiceDiscoveryFactory`](https://github.com/rfoltyns/log4j2-elasticsearch/blob/master/log4j2-elasticsearch-hc/src/main/java/org/appenders/log4j2/elasticsearch/hc/discovery/ServiceDiscoveryFactory.java) can be defined to integrate with other address sources.

Name | Type | Required | Default | Description
------------ | ------------- | ------------- | ------------- | -------------
nodesFilter | Attribute | no | `_all` | Nodes filter as defined in [Elasticsearch 7.x documentation](https://www.elastic.co/guide/en/elasticsearch/reference/7.x/cluster.html#cluster-nodes) (`_nodes/<nodesFilter>/http`).
serverUris | Attribute | no | inherited from HCHttp | List of semicolon-separated address sources.
connTimeout | Attribute | no | 500 | Number of milliseconds before ConnectException is thrown while attempting to connect.
readTimeout | Attribute | no | 1000 | Number of milliseconds before SocketTimeoutException is thrown while waiting for response bytes.
pooledResponseBuffersSizeInBytes | Attribute | no | 32KB (32768 bytes) | Single response buffer size.
targetScheme | Attribute | no | http | Scheme of resolved addresses passed to HCHttp client.
refreshInterval | Attribute | no | 30000 | Number of milliseconds between the end of previous request and start of new one.
configPolicies | Attribute | no | serverList,security | List of comma-separated config policies to apply. Available policies: `shared`, `none`, `serverList`, `security`. See [Config Policies](https://github.com/rfoltyns/log4j2-elasticsearch/blob/master/log4j2-elasticsearch-hc#config-policies) for more details.

Example:
```xml
<Elasticsearch ...>
    <AsyncBatchDelivery ... >
        ...
        <HCHttp ...>
            ...
            <ServiceDiscovery serverUris="http://localhost:9250"
                              refreshInterval="10000"
                              nodesFilter="ingest:true" />
            ...
        </HCHttp>
    </AsyncBatchDelivery>
</Elasticsearch>
```

#### Config policies

`ServiceDiscovery` can inherit parts of HCHttp client config or even reuse whole client. By default, `HCHttp.serverUris` and `Security` settings are reused during creation of new `ServiceDiscovery` HTTP client. Following policies are available:
* `serverList` - create a new client, inherit HCHttp.serverUris
* `security` - create a new client, inherit HCHttp.auth
* `shared` - reuse HCHttp client
* `none` - create a new client, don't inherit anything

`serverList` and `security` can be used together. New client will inherit both config elements.

`shared` and `none` can only be used individually. They can't be mixed with other policies.

Example:
```xml
<Elasticsearch ...>
    <AsyncBatchDelivery ... >
        ...
        <HCHttp>
            ...
            <Security .../>
            <ServiceDiscovery serverUris="https://localhost:9200"
                              refreshInterval="10000"
                              targetScheme="https"
                              configPolicies="security" />
            ...
        </HCHttp>
    </AsyncBatchDelivery>
</Elasticsearch>
```

NOTE: Config policies were added for convenience. Recommended configuration should contain `configPolices=none`, `serverUris` configured ONLY for `ServiceDiscovery` and separate `Security` configs if needed.

### Programmatic config
See [programmatc config example](https://github.com/rfoltyns/log4j2-elasticsearch/blob/master/log4j2-elasticsearch-hc/src/test/java/org/appenders/log4j2/elasticsearch/hc/smoke/SmokeTest.java).

### Delivery frequency
See [delivery frequency](../log4j2-elasticsearch-core#delivery-frequency)

### Message output
See [available output configuration methods](../log4j2-elasticsearch-core#message-output)

### Failover
See [failover options](../log4j2-elasticsearch-core#failover)

### Backoff
Since 1.4, `BackoffPolicy` can provide additional fail-safe during delivery.
In the event of cluster failure or slowdown, when policy gets triggered, batch will be automatically redirected to configured `FailoverPolicy` (see [failover options](../log4j2-elasticsearch-core#failover)).

#### BatchLimitBackoffPolicy

`BatchLimitBackoffPolicy` is a simple `BackoffPolicy` based on a number of currently processed batches (batches that arrived at the `HCHttp` batch listener). Every arriving batch will increase the "in-flight count" by 1 if `maxBatchesInFlight` is not exceeded. Every response to a batch request decreases "in-flight count" by 1. Every batch that arrives when `maxBatchesInFlight` limit is met is redirected to configured `FailoverPolicy`.

:warning: **See [failover options](../log4j2-elasticsearch-core#failover) for available `FailoverPolicy` implementations. If no `FailoverPolicy` is configured, batch will be lost!**

Name | Type | Required | Default | Description
------------ | ------------- | ------------- | ------------- | -------------
maxBatchesInFlight | Attribute | no | 8 | Maximum number of batches delivered simultaneously (including the ones waiting for a response).

Example:
``` xml
<Elasticsearch ...>
    <AsyncBatchDelivery ... >
        ...
        <HCHttp ...>
            ...
            <BatchLimitBackoffPolicy maxBatchesInFlight="4" />
            ...
        </HCHttp>
    </AsyncBatchDelivery>
</Elasticsearch>
```

### Index name
See [index name](../log4j2-elasticsearch-core#index-name) or [index rollover](../log4j2-elasticsearch-core#index-rollover)

### Index template
See [index template docs](../log4j2-elasticsearch-core#index-template)

### SSL/TLS
Can be configured using `Security` tag:

#### PEM cert config
```xml
<HCHttp serverUris="https://localhost:9200" >
    <Security>
        <BasicCredentials username="admin" password="changeme" />
        <PEM keyPath="${sys:pemCertInfo.keyPath}"
             keyPassphrase="${sys:pemCertInfo.keyPassphrase}"
             clientCertPath="${sys:pemCertInfo.clientCertPath}"
             caPath="${sys:pemCertInfo.caPath}" />
    </Security>
</HCHttp>
```

#### JKS cert config
```xml
<HCHttp serverUris="https://localhost:9200" >
    <Security>
        <BasicCredentials username="admin" password="changeme" />
        <JKS keystorePath="${sys:jksCertInfo.keystorePath}"
             keystorePassword="${sys:jksCertInfo.keystorePassword}"
             truststorePath="${sys:jksCertInfo.truststorePath}"
             truststorePassword="${sys:jksCertInfo.truststorePassword}" />
    </Security>
</HCHttp>
```

### Compatibility matrix

Feature/Version | 2.x | 5.x | 6.x| 7.x
------------ | ------------- | ------------- | -------------| -------------
IndexTemplate | Yes | Yes | Yes| Yes
BasicCredentials | Yes | Yes | Yes| Yes
JKS | Yes | Not tested | Not tested| Not tested
PEM | Not tested | Yes | Yes| Yes

## Pluggable JCTools

See [Pluggable JCTools](../log4j2-elasticsearch-core#pluggable-jctools)

JVM params:

Param | Type | Default
------------ | ------------- | -------------
-Dappenders.BatchRequest.jctools.enabled | boolean | true
-Dappenders.BatchRequest.initialSize | int | 10000

## Dependencies

Be aware that following jars may have to be provided by user for this library to work:

* Netty: `io.netty:netty-buffer`
* Jackson FasterXML: `com.fasterxml.jackson.core:jackson-core,jackson-databind,jackson-annotations`
* Jackson FasterXML Afterburner module if `JacksonJsonLayout:afterburner=true`: `com.fasterxml.jackson.module:jackson-module-afterburner`
* Log4j2: `org.apache.logging.log4j:log4-api,log4j-core`
* Disruptor (if using `AsyncAppender`): `com.lmax:disruptor`
* Bouncy Castle (if using `Security`): `org.bouncycastle:bcprov-jdk15on,bcpkix-jdk15on`

See `pom.xml` or deps summary at [Maven Repository](https://mvnrepository.com/artifact/org.appenders.log4j/log4j2-elasticsearch-hc/latest) for a list of dependencies.


text:
# 100DaysofMLCode Challenge

## Table of Contents

1. Data Pre-processing
  * Importing Libraries
  * Importing Data sets
  * Handling the missing data values
  * Encoding categorical data
  * Split Data into Train data and Test data
  * Feature Scaling

## 100 Days Log

Track my daily activities [here](100Days_Log.md)

## How to Contribute

[Contribution Guidelines](CONTRIBUTING.md)


text:
# Swarmize deployment tools

This directory contains the bulk of the Swarmize deployment tools.

## Prerequisites

`deploy` was written against Ruby 1.9.3. You'll need this installed, along with Bundler. `rbenv` is recommended if you don't have a Ruby installed.

## Installation

From the `deploy` directory, run

	bundle install

to install all necessary dependencies.

## Configuration

The AWS gem will make use of the AWS CLI configuration, stored in `~/.aws`. Make sure you have Swarmize creds in there.

## Setting up your subfolder for deployment

A subfolder requires three things to be deployable:

* a `eb_name.txt` file, containing the name of the application on Elastic Beanstalk
* a `package.sh` file, containing all the code to get a zip file of the deployable application.

## How it works

The root folder's `./deploy.sh` script simply sets up the appropriate environment variables needed by `deploy.rb`, and passes the app to be deployed to `deploy.rb`.

`deploy.rb` then:

* finds the latest version of the application and checks it hasn't been uploaded already
* if not, it packages the application and uploads the resulting zipfile to S3.
* then, the deploy script tries to make a new version of the application with that code, and apply it to the live version
* finally, it notifies Slack that a deployment has taken place.

## Usage

From the root of the repository - not the deploy folder - run

	./deploy.sh [thing-to-deploy]

eg

	./deploy.sh swarmize-dot-com

repository: guardian/swarmize

gha_language: Ruby

repo_name: guardian/swarmize


text:
## Analysis code MMSplice manuscript
MMSplice predict variant effect on PSI, PSI5, PSI3, splicing efficiency and pathogenicity. This repository contains analysis code for MMSplice manuscript. MMSplice version `mmsplice==0.2.0`.

## Software dependencies
The analysis was done with python and ploting was done with R. Required packages are listed in env.yaml.
1. Install miniconda or anaconda.
2. Run: `conda env create -f env.yaml`. This will install a new conda environment `mmaplice-manuscript`.
3. Activate the environment: `source activate mmaplice-manuscript`. Run the analysis code (in jupyter-notebooks) in this environment.
4. Install COSSMO from https://github.com/PSI-Lab/COSSMO

## Folder structure
In general, the jupyter-notebooks were used to process, analysis the data and perform predictions. The result table are saved and read by R scripts for plotting.
- `script/Figure2`: Code to generate figure for the Vex-seq and MFASS data.
- `script/Figure3`: Code to generate figure for GTEx A5SS amd A3SS variants.
- `script/Figure4`: Code to generate figure for MaPSy data.
- `script/Figure5`: Code to generate figure for ClinVar data. Result table of other models were obtained from [Kipoi manuscript] (https://github.com/kipoi/manuscript)
- `data/`: contains raw and processed data


text:
### [CVE-2021-39364](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-39364)
![](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

Honeywell HDZP252DI 1.00.HW02.4 and HBW2PER1 1.000.HW01.3 devices allow command spoofing (for camera control) after ARP cache poisoning has been achieved.

### POC

#### Reference
- https://www.honeywell.com/us/en/product-security

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# aws-glue-monorepo-style

An example of AWS Glue Jobs and workflow deployment with terraform in monorepo style.

To learn more about decisions behind this structure chek out the supporting articles:
https://dev.to/1oglop1/aws-glue-first-experience-part-1-how-to-run-your-code-3pe3

## Deployment:

Before deploying I highly recommend using find and replace this string `your-awsglue-bucket` to a bucket name you like.

Requirements:

* AWS Account
* S3 bucket to store terraform state.

* set environment variables according to `.evn.example`
* `docker-compose up -d`
* `docker exec -it pytf /bin/bash`

Now we are going to work inside the docker container

* `make tf-init`
* `make tf-plan`
* `make tf-apply`
* `make jobs-deploy`

That's it!
If everything went well you can now go to AWS Glue Console and explore jobs and workflows.

Or start workflow from CLI `aws glue start-workflow-run --name etl-workflow`

Once you are finished with observations remove everything with  `make tf-destroy`.

## Disclaimer

Please keep in mind that IAM roles used in this example are very broad and should not be used as is.


text:
---
layout: default
---

# People

## Principal Investigators

![Awh](/files/images/awh.jpg){: .image-left}**Ed Awh**

Professor
Department of Psychology and Institute for Mind and Biology
University of Chicago

[Faculty Page](https://imb.uchicago.edu/directory/edward-awh-phd)

---

![Vogel](/files/images/vogel.jpg){: .image-left}**Ed Vogel**

Professor
Department of Psychology and Institute for Mind and Biology
University of Chicago

[Faculty Page](https://imb.uchicago.edu/directory/edward-vogel-phd)

## Post-docs

![Megan](/files/images/debettencourt.jpg){: .image-left}**Megan deBettencourt**

[Personal website](http://home.uchicago.edu/~debetten/)

---
![Ngiam](/files/images/ngiam.jpg){: .image-left}**William Ngiam**

[Personal website](https://williamngiam.github.io/)

[Twitter](https://twitter.com/will_ngiam/)

## PhD Students

![Nicole](/files/images/nicole.jpg){: .image-left}**Nicole Hakim**

[Google scholar profile](https://scholar.google.com/citations?user=0YNa8scAAAAJ&hl=en&oi=ao)

[Personal page](/hakim.html)

---

![Colin](/files/images/quirk.png){: .image-left}**Colin Quirk**

[Personal website](http://colinquirk.com/)

---

![Gisella](/files/images/squares.png){: .image-left}**Gisella Diaz**

---

![Will](/files/images/thyer.jpg){: .image-left}**William Thyer**

---

## Research Specialists

**Ariana Gale**

## Undergraduate Research Assistants

**Liam Chai**, 2017–
**Albert Chen**, 2017–
**Mei Arditi**, 2018–
**Yasemin Hasimoglu**, 2018–
**Paul Keene**, 2018–
**Itzel Velazquez**, 2019-
**Krystian Loetscher**, 2019-

## Alumni

### Former Post-docs

**Tobias Feldmann-Wüstefeld**
Current position: Lecturer, University of Southampton
[Personal website](http://feldmann-wuestefeld.de/)

**Eren Günseli**
Current position: Assistant Professor, Sabancı University
[Personal website](https://www.gunselilab.com/)

**Roy Luria**
Current position: Professor, Tel Aviv University
[Personal website](http://people.socsci.tau.ac.il/mu/royluria/)

**Hiroyuki Tsubomi**
Current position: Associate Professor, University of Toyama
[Personal website](https://sites.google.com/site/htsubomi/)

### Former PhD Students

**Joshua Foster**
Current position: Post-doc at BU
[Personal website](https://joshuajfoster.github.io/)

**Kirsten Adam**
Current position: Post-doc at UCSD
[Personal website](https://kirsten-adam.com/)

**David Sutterer**
Current position: Post-doc at Vanderbilt

**Irida Mance**
Current position: Apple

**Brittany Dungan**
Current position: Senior UX Researcher at Big Fish Games

**Keisuke Fukuda**
Current position: Assistant professor at University of Toronto Mississauga
[Lab website](https://fukudalab.org/)

**Eddie Ester**
Current position: Assistant professor at Florida Atlantic University
[Lab website](https://www.esterlabfau.com/)

**Trafton Drew**
Current position: Assistant professor at the University of Utah
[Lab website](http://aval.psych.utah.edu/)

**Andrew McCollough**
Current position: Data Scientist at EdgeRock Technology Partners, A CDI Company

### Former Masters Students

**Akiko Ikkai**
Current position: UX Researcher

**Akina Umemoto**
Current position: Postdoctoral Research Fellow at Toyama University/University of Toronto
[Personal website](https://www.researchgate.net/profile/Akina_Umemoto)

**Miranda Scolari**
Current position: Assistant professor at Texas Tech University
[Personal website](https://www.depts.ttu.edu/psy/people/mscolari/)

**Maro Machizawa**
Current position: Assistant professor at Hiroshima University
[Personal website](https://sites.google.com/site/maromachizawa/Home)

### Former Research Specialists

**Brendan Colson**
Current position: UX Researcher

### Former Undergraduate Research Assistants (incomplete)

**Murrie Affini**, 2016–2017
**Emma Bsales**, 2016–2018
**Maryam Bolouri**, 2018–2019
**Ricardo Fernandez**, 2017–2018
**Alden Herrera**, 2017
**Rebecca Kuang**, 2017–2018
**Denelle Mohammed**, 2018–2019
**Clara Sava-Segal**, 2017–2018
**Jainaha Srikumar**, 2016-2017
**Melanie Sykes**, 2017–2018
**Citlalli Vivar Aburto**, 2017-2018
**Yohyoh Wang**, 2017–2018
**Marina Weinberger**, 2017–2018
**Janna Wennberg**, 2018
**Stephanie Williams**, 2017–2018
**Jennifer Zhou**, 2018