text:
[![MIT License](https://img.shields.io/apm/l/atomic-design-ui.svg?)](https://github.com/tterb/atomic-design-ui/blob/master/LICENSEs)
[![BCH compliance](https://bettercodehub.com/edge/badge/hschneid/xfvrp?branch=master)](https://bettercodehub.com/)
![alt text](https://img.shields.io/static/v1?label=version&message=<IP_ADDRESS>&color=-)

xfvrp
======

There are a lot of solvers for the Vehicle Routing Problem (VRP) on github. Some are good at certain features (like CVRP or VRPTW) and some are quite complex.

xfvrp is a fast and easy-to-use solver for Rich Vehicle Routing Problems like
- Multiple compartments
  - Separate capacities for routes with only pickup, only delivery or mixed pickup and delivery
- Multiple time windows
- Multiple depots
- Heterogeneous fleet
- Pick and delivery or backhauls
- Replenishment sites
- State of the art optimization heuristics
- Presettings (i.e. packages must be loaded together or not)
- and many more.

Additional requirements are the useage and maintainability of the API like
- User shall change only the necessary values. The rest is done by default values.
- The user API shall be as easy as possible to understand. Users of xfvrp need only to know one class.
- No parameter tuning (i.e. mutation rate, popultation size, annealing temperature)
- No free lunch: Good results with good performance.

## License
This software is licenced under [MIT License] (https://opensource.org/licenses/MIT).

## Getting started
* Add dependency to your project
  * Maven:
    ```
    <dependency>
      <groupId>com.github.hschneid</groupId>
      <artifactId>xfvrp</artifactId>
      <version>11.3.0-RELEASE</version>
    </dependency>
    ```
  * Gradle:
    ```
    implementation 'com.github.hschneid:xfvrp:11.3.0-RELEASE'
    ```

A simple example for a capacitated vehicle route planning:
```
XFVRP xfvrp = new XFVRP();
xfvrp.addDepot().setXlong(5.667);
xfvrp.addCustomer().setXlong(1.002).setDemand(new float[]{1.5, 0, 2.3});
xfvrp.setVehicle().setName("Truck").setCapacity(new float[]{3, 2, 5});
xfvrp.setMetric(new EucledianMetric());
xfvrp.setOptType(XFVRPOptType.RELOCATE);

Report report = xfvrp.executeRoutePlanning();
report.getSummary().getDistance();
```

## Benchmarks
As a general purpose solver, XFVRP is not fully compatable with single problem solvers. But even though it can prove its relevance by [benchmarks](BENCHMARKS.md).

## Change log

### <IP_ADDRESS>
- Introduced new Mixed Fleet Heuristic
- Several Refactorings done by Fraunhofer IML

### 11.4.2 - 11.4.4
- Fixed irregular behaviour, when node.externId is not unique. Precheck method checks this now.
- Fixed error when checking vehicle types in blocks
- Fixed error when no nodes is allowed for a certain vehicle type. Then input must be corrected by caller.

### 11.4.1
- Fixed in report the summary per vehicle type, so that it considers multi compartments correctly as well.
- Fixed error, when customer demands and vehicle capacity have a different number of compartments

### 11.4.0
- Add more multi-compartment constraints
  - Considering more than 3 compartments (no limitation)
  - Vehicle capacity can be defined separately per compartment for PICKUP, DELIVERY or MIXED.
  - Replenishment nodes must not replenish (reset capacity) for every compartment.
- Add instance checks for MDVRPTW (of Vidal et al.)
- Internal restructuring to reduce complexity for data-import classes

### 11.3.0
- Drastically increased performance for some neighborhood searches by changing to route-based change operators and improved result sorting
  - Single node Move and Segment Move
  - Single node Swap and Segment Swap
  - Segment Exchange (Swap & move)
- Removed obsolete giant-route based neighborhoods, which are replaced by route-based neighborhoods

### 11.2.0
- Changed exception handling
  - No Runtime Exceptions (like IllegalState) anymore
- Added benchmark section in Readme
- Added benchmark for VRPTW with large instances to repo (more will be added in future)
- Minor cleanups in code
- First route-based neighborhood search
  - Increased performance by ca. 34% (tested on 60 large VRPTW instances)

### 11.1.0
- Cleanup of repository
- Add ReportBuilder (it compiles again :-) )
- Update of gradle 6.7 and Java 11
- Added SpotBug
- Cleaned obsolete code

### 11.0.0
- Automatical test with 70% code coverage of lines
- Removed unusual features (i.e. XFLP)
- A lot of code rework as preparation of further improvements
- Solved a lot of bugs, due to testing ;-)

repository: cryptonome/xfvrp

repo_name: cryptonome/xfvrp


text:
---
layout: blog
categories:
  - blog
title: "Adrienne Alexander tells Chi Hack Night what she does as a union lobbyist"
description: "Adrienne Alexander came to Chi Hack Night last night to tell us about her experience as a lobbyist working for the state’s largest public employees union."
date: 2016-02-03
image: /images/blog/2016-02-03-adrienne-alexander-tells-chi-hack-night-what-she-does-as-a-union-lobbyist/img1.jpg
author: Steven Vance
author_url: https://twitter.com/stevevance
author_image: /images/people/steven_vance.jpg
author_bio: "Steven Vance is a web developer and transportation planner who writes for Streetsblog Chicago."
author2:
author2_url:
author2_image:
published: true
---

Adrienne Alexander, or [@DriXander](https://twitter.com/drixander) on Twitter, [came to Chi Hack Night last night](/events/2016/02/02/lobbying-chicago-city-council.html) to tell us about her experience as a lobbyist working for one of the state’s largest public employee unions. She lobbies the Chicago City Council and the Illinois state legislature for bills and budget modifications that would impact the members of the American Federation of State, County and Municipal Employees [Council 31](http://www.afscme31.org).

Members of AFSCME (afs-me) are staff at numerous Chicago city departments and in state government. Alexander watches new bills that come in and analyzes what their impact might have on its members.

### The long road to legislative victory

Alexander gave the example of the privatization legislation that she lobbied, the [Privatization Transparency and Accountability Ordinance](https://chicago.councilmatic.org/legislation/o-2015-5434/), for three years. [Salon reported on the PTAO in 2013](http://www.salon.com/2013/09/20/privatization_fetish_grows_how_corporate_stooges_are_costing_cities_millions/), saying, "[it] is designed to help prevent abuses of privatization, and avoid the kinds of deals negotiated in the past that were intended to help close budget deficits but turned out to be massive boons for corporations and Wall Street while losing long-term revenue for the city."

Alexander, however, had been battling efforts to privatize city functions earlier. In 2011, she said, Mayor Rahm Emanuel was trying to privatize the water billing group. This would have been realized by amending the budget and reducing the amount budgeted for that group of staff.

"We represented those folks", she said. "It got a lot of aldermen upset, it was supposed to save $100,000 annually but also lay off 40 people." It didn’t happen. And neither did the 311 privatization that Emanuel proposed in 2015 for the 2016 budget.

Alexander said that it was hard to keep the press focused on this issue for three years, because nothing was happening. "If there’s nothing happening, they would say, then there’s nothing to write about", she said.

It was passed in November 2015. "It’s hard to get things passed that don’t have the mayor’s support," Alexander said. "A lot of the calls the aldermen get are not about policy, but about alleys, trash, tree trimming, these very ‘quality of life’ issues specific to their ward".

There’s a good reason – for them –in all of this, she explained. "You can be the most citywide alderman, really focused on policy, but if you don’t take care of the stuff in your ward then you will lose your election."

### Advice for Chi Hack Night

    Adrienne Alexander speaking to Chi Hack Night at Braintree. Photo by Kevin Wei.

Alexander gave some advice to Chi Hack Night members who are building tools that explain why some policies aren’t working and should change. Claire Micklin asked how to get alders to "mobilize on and care about policy issues, and can they affect policy change from the ground up if the mayor isn’t necessarily generating or supporting that policy issue?"

Micklin led the development of [My Building Doesn’t Recycle](http://mybuildingdoesntrecycle.com/), a map where Chicagoans can report that their multi-unit building doesn’t have a third-party recycling service (required if the tenants of a building with 5 or more units request it).

Alexander said "I think there’s not so much a culture of [alders generating their own policy initiatives] here, but I think it’s possible".

She advised Micklin, and anyone else who’s working to change a city policy, to:

*   Choose your sponsor carefully.
*   Be clear of what your expectations are, have a plan so you can help guide them
*   Have grassroots support, so it’s more than one person coming and talking to them about it
*   Make sure they’re hearing about it from different places, and find out who else they’re listening to.

In each ward, she said, there’s at least one organization that an alder really cares about, so if that organization is making something an issue, or it would be beneficial to that organization, then they could be helpful.

I’ve seen this kind of organization-derived influence a lot in property development matters. If there’s a neighborhood-based organization that purports to represent resident issues in a specific boundary, then the alder who’s receiving a new property development proposal will ask that the developer meet with the organization to gain their approval. I’ve seen situations, especially in the 1st Ward, where the alder supports the development if the organization supports the development.

Alexander concluded her response to Micklin’s question, saying, "It’s really helpful if you can do a lot of the legwork, and you can get the alderman plugged into the process."

*This was originally posted on [Steven Can Plan](http://www.stevencanplan.com/2016/02/adrienne-alexander-tells-chihacknight-what-she-does-as-a-union-lobbyist/) on Feb 3, 2016.*

license: MIT

branch_name: refs/heads/production

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive


text:
# StoreManagement

This is a store management app that provides main functions you'd expect from a store management app,
such as CRUD tables, CRD products on menu and products management on each table.

![View_Tables](https://github.com/SiozosThomas/Store-Management/blob/master/examples/table-list.png)

## Table of Contents

* [Features](#Features)
* [Setup](#Setup)
* [Develop](#Develop)
* [Build](#Build)
* [Dockerize](#Dockerize)
* [Examples](#Examples)
* [Author](#Author)
* [License](#License)

## Features
:scroll:

* Create Table.
* View Tables.
* Update Table.
* Delete Table.
* Add Product.
* View Products.
* Delete Product.
* Add Product to Table.
* Delete Product from Table.
* Login/Logout.
* Sum of selected products on each table.

## Setup
![Custom badge](https://img.shields.io/endpoint?color=%23CB3837&logo=NPM&style=plastic&url=https%3A%2F%2Ff54vff4z3g0b.runkit.sh%2F)

- Clone this repo to your desktop
- npm install
- Change on backend/app.js the connection of mongoose.
  - First Step, you'll need an account on MongoDB Atlas.
  - Second Step, create a new Cluster (Free).
  - Third Step, allow Network Access to your IP or <IP_ADDRESS>/0 (anyone).
  - Fourth Step, connect your app with your database.
  - You are ready!

## Develop
:computer:

- Run `ng serve` for Angular, running at localhost:4200
- Run `npm run start:server` for API, running at localhost:3000
- Open your browser at localhost:4200

## Build
:wrench:

Run `ng build` to build the project. The build artifacts will be stored in the `app-production/` directory. Use the `--prod` flag for a production build.

## Dockerize
:whale:

You need **backend/Dockerfile** , **./Dockerfile** and **docker-compose.yaml** files.

Also, if you use Hyper-V engine, you have to put your directory on "File Sharing".

### Run docker-compose

Run the command **docker-compose up -d** (for detach mode, remove -d if you don't want detach mode) in the directory with the docker-compose file.

If you want to close it, you can from your docker-desktop/dashboard or with the command **docker-compose down**.

**!NOTE**

You have to change your mongodb domain (backend/app.js) to:
```
 mongodb://host.docker.internal:27017/dbname
```
If you use local mongodb.(Container understands that that means localhost).

## Examples

### Login

![Login](https://github.com/SiozosThomas/Store-Management/blob/master/examples/login.png)

### Add Table

![Add_Table](https://github.com/SiozosThomas/Store-Management/blob/master/examples/add_table.png)

### Products

![Products](https://github.com/SiozosThomas/Store-Management/blob/master/examples/products.png)

### Add Product on Table

![Add_Product](https://github.com/SiozosThomas/Store-Management/blob/master/examples/add_product.png)

### Update Table

![Update_Table](https://github.com/SiozosThomas/Store-Management/blob/master/examples/update_table.png)

### View Tables

![View_Tables](https://github.com/SiozosThomas/Store-Management/blob/master/examples/table-list.png)

### Selected Sum

![Selected_Sum](https://github.com/SiozosThomas/Store-Management/blob/master/examples/selected.png)

## Author
:pencil2:

**Siozos Thomas**

## License
:key:

You can check out the full lecense [here](https://github.com/SiozosThomas/Store-Management/blob/master/LICENSE)
This project is lecensed under the terms of the **MIT** license.

repository: thomas-siozos/Store-Management

branch_name: refs/heads/master

repo_name: thomas-siozos/Store-Management


text:
# timesince

Formats a date as the time since that date (e.g., "4d ays, 6 hours").

Takes an optional argument that is a variable containing the date to use as the comparison point (without the argument, the comparison point is now). For example, if `blog_date` is a date instance representing midnight on 1 June 2006, and `comment_date` is a date instance for 08:00 on 1 June 2006, then the following would return “8 hours”:

---

```htmldjango
{{ blog_date|timesince:comment_date }}
```

Comparing offset-naive and offset-aware datetimes will return an empty string.

Minutes is the smallest unit used, and "0 minutes" will be returned for any date that is in the future relative to the comparison point.

branch_name: refs/heads/main


text:
# Endpoint: {api_url}/me/
This Endpoint is Responsible for returning current User Data

# HTTP Requests
The Following HTTP Requests are Possible
___
## GET

### Parameters

#### Required HTTP Headers

```http request
Authorization: session_id
```

#### JSON Payload
* none

#### Example

```http request
Authorization:<PHONE_NUMBER>
```

### Results

#### Successful Request
It will return the Userdata, and which type the user data
Further Requests to {API_URL}/me/{type} will give more details

```http request
'HTTP/1.1 200 OK'
```
```json
{
    "member_since": "2020-02-02 02:02:02",
    "type": "local"
}
```

#### Faulty Authorization

```http request
'HTTP/1.1 401 Unauthorized'
```
```json
```

license: Zlib

repository: norbekaiser/norb-api

repo_name: norbekaiser/norb-api


text:
Welcome to the Symfony CameraStore sample application for Tradenity PHP SDK
===========================================================================

## Live demo

Here you can find live demo of the [Camera store sample application](http://camera-store-sample.tradenity.com/).
This is the application we are going to build here.

## Prerequisites

(Will install automatically via maven)

-  Symfony framework > version 3 (other versions may work but not tested)
-  [Tradenity PHP SDK](https://github.com/tradenity/php-sdk)
-  [Symfony extensions for the Java SDK](https://github.com/tradenity/php-sdk-symfony-ext)

## Setup your credentials

First of all, you have to get API keys for your store, you can find it in your store `Edit` page.
To get there navigate to the stores list page, click on the `Edit` button next to your store name, scroll down till you find the `API Keys` section.

## Initialize the library

Add your Store keys to `app/config/config.yml` file, also your stripe public key.

```yml

parameters:
    locale: en
    tradenity_key: sk_xxxxxxxxxxxxxxxxxxxxx
    stripe_public_key: pk_xxxxxxxxxxxxxxxxxx

```

## Tutorials and sample applications

We also provide a detailed explanation of the code of this sample applications in the form of a step by step tutorials:

[Camera store for spring mvc tutorial](http://docs.tradenity.com/kb/tutorials/php/symfony).

## Run

In console, type:

`php bin/console server:start`


text:
# Laravel Module Generator

Simple Laravel Module Generator.

[![Build Status](https://travis-ci.org/tanerincode/module-generator.svg?branch=master)](https://packagist.org/packages/tanerincode/modulity) [![MIT License](https://camo.githubusercontent.com/e65c945b219ec6c6f63826a83df905b3191ae52c/68747470733a2f2f706f7365722e707567782e6f72672f6c61726176656c2f6672616d65776f726b2f6c6963656e73652e737667)](LICENSE) [![Coverage Status](https://coveralls.io/repos/github/tanerincode/modulity/badge.svg?branch=master)](https://coveralls.io/github/tanerincode/modulity?branch=master)
[![security](https://img.shields.io/badge/security-2%2F4-green)](SECURITY.md)
[![stable](https://img.shields.io/badge/stable-1.0.1-yellowgreen)](https://packagist.org/packages/tanerincode/modulity)

## Getting Started

This Package: Automatically creates a module or part in a Laravel Modular Pattern.

### Prerequisites

What things you need to install the software and how to install them

```
"php": "^7.2.0",
"illuminate/console": "^5.3.0",
"illuminate/support": "^5.3.0",
"laravel/laravel" : "^5.6.*"
""
```

### Installing

A step by step series of examples that tell you how to get a development env running

Step 1 : require composer package

```
composer require tanerincode/modulity
```

Step 2 : if this package not working automatically add provider in `config/app.php`

```
TanerInCode\Modulity\Providers\ModulityServiceProvider::class,
```

Step 3 : Publish config file and select `modulity.config`

```
php artisan vendor:publish
```

Step 4 : Update Modules Namespace, `modulity.php` or `.env` file

```
'name_space' => env("MODULE_GENERATOR_NAMESPACE", 'TanerInCode')
```

OR

```
MODULE_GENERATOR_NAMESPACE=TanerInCode
```

**PS: Do not touch `src_url`.**

Last Step : Replace the Psr-4 field in the Composer.json file with the namespace of your choice.

```
"autoload": {
    ...
    "psr-4": {
        ...
        "TanerInCode\\" : "app/Modules"
    }
```

## Built With

* [Laravel](https://laravel.com/docs/5.7) - The laravel framework

## Authors

* **Taner Tombas** - [TanerInCode](https://github.com/tanerincode)

## License

This project is licensed under the MIT License - see the [LICENSE.md](https://github.com/tanerincode/module-generator/blob/master/LICENSE) file for details

repository: soyoz/Modulity

repo_name: soyoz/Modulity


text:
SublimeLinter-contrib-radon
================================

[![Build Status](https://travis-ci.com/christopherpickering/SublimeLinter-contrib-radon.svg?branch=master)](https://travis-ci.com/christopherpickering/SublimeLinter-contrib-radon)

This linter plugin for [SublimeLinter](https://github.com/SublimeLinter/SublimeLinter) provides an interface to [radon](https://radon.readthedocs.io/en/latest/index.html) cyclomatic complexity. It will be used with files that have the “python” syntax.

Any python function/class/method with a complexity over 5 will have a warning showing the current complexity values.

## Installation
SublimeLinter must be installed in order to use this plugin.

Please use [Package Control](https://packagecontrol.io) to install the linter plugin.

Before installing this plugin, you must ensure that `radon` is installed on your system.

In order for `radon` to be executed by SublimeLinter, you must ensure that its path is available to SublimeLinter. The docs cover [troubleshooting PATH configuration](http://sublimelinter.readthedocs.io/en/latest/troubleshooting.html#finding-a-linter-executable).

## Settings
- SublimeLinter settings: http://sublimelinter.readthedocs.org/en/latest/settings.html
- Linter settings: http://sublimelinter.readthedocs.org/en/latest/linter_settings.html


text:
---
layout: post
image: /assets/images/backgrounds/rocketLaunch1.svg
header-image: /assets/images/backgrounds/rocketLaunch1.svg
title: Site Launched!
subtitle: In The Beginning
date: 2019-03-02T00:00:00.000Z
tags: News Jekyll Markdown
category: [ News ]
#comments: true
---
## Powered by
- [Jekyll](http://jekyllrb.com)
- [Webpack 4](https://webpack.js.org)
- [Popmotion](https://popmotion.io)
- [Staticman](https://staticman.net/docs/)

- [CSS/BEM](https://en.bem.info/methodology/quick-start/)
- [CSS Custom Properties](https://www.smashingmagazine.com/2017/04/start-using-css-custom-properties/)
- [Pro Web Type](https://prowebtype.com/)
- [A more modern scale for web typography](http://typecast.com/blog/a-more-modern-scale-for-web-typography)
- [Fontjoy Machine Learning Font Combinations](http://fontjoy.com/)
- [Paletton](http://paletton.com)
- [App Shell Model](https://developers.google.com/web/fundamentals/architecture/app-shell)

repository: chpmnrssll/advanced-static-site

repo_name: chpmnrssll/advanced-static-site


text:
# habu

Generate configurations for [cobra](https://github.com/spf13/cobra) and [viper](https://github.com/spf13/viper) from struct tags.

## Examples

* [Source: examples/features/main.go](examples/features/main.go)
    * [Generated: examples/features/options_habu.go](examples/features/options_habu.go)
* [Source: examples/subcommands/main.go](examples/subcommands/main.go)
    * [Generated: examples/subcommands/options_habu.go](examples/subcommands/options_habu.go)

## License

Apache 2.0

repository: taskie/habu

repo_name: taskie/habu


text:
# Document Clustering with Python

![](../.gitbook/assets/header_short.jpg)

In this guide, I will explain how to cluster a set of documents using Python. My motivating example is to identify the latent structures within the synopses of the top 100 films of all time \(per an IMDB list\). See [the original post](http://www.brandonrose.org/top100)for a more detailed discussion on the example. This guide covers:

*  tokenizing and stemming each synopsis
*  transforming the corpus into vector space using [tf-idf](http://en.wikipedia.org/wiki/Tf%E2%80%93idf)
*  calculating cosine distance between each document as a measure of similarity
*  clustering the documents using the [k-means algorithm](http://en.wikipedia.org/wiki/K-means_clustering)
*  using [multidimensional scaling](http://en.wikipedia.org/wiki/Multidimensional_scaling) to reduce dimensionality within the corpus
*  plotting the clustering output using [matplotlib](http://matplotlib.org/) and [mpld3](http://mpld3.github.io/)
*  conducting a hierarchical clustering on the corpus using [Ward clustering](http://en.wikipedia.org/wiki/Ward%27s_method)
*  plotting a Ward dendrogram
*  topic modeling using [Latent Dirichlet Allocation \(LDA\)](http://en.wikipedia.org/wiki/Latent_Dirichlet_allocation)

The 'cluster\_analysis' workbook is fully functional; the 'cluster\_analysis\_web' workbook has been trimmed down for the purpose of creating this walkthrough. Feel free to download the repo and use 'cluster\_analysis' to step through the guide yourself.

## How the repo is set up

Once you've pulled down the repo, all you need to do is run 'cluster\_analysis.ipynb'; it will find the various lists of synopses and titles. The 'Film\_Scrape.ipynb' contains the code I used to actually scrape the synopses, in case you are interested. The other items in the repo are mostly incidentals for setting up the webpage walk-through. There is also one pickled model.

At some point in the future I'll write up how I executed the web scraping in case it's of interest.

repository: vishnu-muraly/AppliedML

repo_name: vishnu-muraly/AppliedML


text:
<!-- Thank you for your contribution to MemCNN! Please replace {Please write here} with your description -->

### What was the problem?

{Please write here}

### How this PR fixes the problem?

{Please write here}

### Check lists (check `x` in `[ ]` of list items)

- [ ] Test passed
- [ ] Coding style (indentation, etc)

### Additional Comments (if any)

{Please write here}

repository: silvandeleemput/memcnn

gha_language: Python

repo_name: silvandeleemput/memcnn


text:
# svelte-nodegui-wasm-starter

**Clone and run for a quick way to see Svelte NodeGui + Wasm in action.**

This is a fork of the [svelte-nodegui-starter](https://github.com/nodegui/svelte-nodegui-starter) repo with the addition of using Wasm with Rust.  Note, this currently breaks hot reloading.

<img alt="logo" src="https://raw.githubusercontent.com/bradyjoslin/svelte-nodegui-wasm-starter/main/assets/demo.png" height="500" />

## To Use

To clone and run this repository you'll need [Git](https://git-scm.com) and [Node.js](https://nodejs.org/en/download/) (which comes with [npm](http://npmjs.com)) installed on your computer.

Make sure you have met the requirements listed here: https://docs.nodegui.org/#/tutorial/development-environment

Additionally, you'll need to have [Rust](https://www.rust-lang.org/) and [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/) installed.

From your command line:

```bash
# Create a copy of this repository (or just clone)
npx degit bradyjoslin/svelte-nodegui-wasm-starter#main my-app
# Go into the project's crate directory
cd my-app/crate
wasm-pack build
# Go into the project root directory
cd ../
# Install dependencies
npm install
# Build the app in development mode (unminified; watch mode on)
npm run dev
# (From another terminal) Run the built app
npm run start
```

## Wasm Interaction

A greet function is exposed in `crate/src/lib.rs`, which takes a string as an argument:

```rust
#[wasm_bindgen]
pub fn greet(name: &str) -> String {
    format!("Welcome to {} 🐕", name)
}
```

The Wasm package is imported, the greet function is called, and the result is rendered to the screen in `src/App.svelte`

```js
// ...

import * as wasm from '../crate/pkg'

let hi = wasm.greet("Svelte NodeGUI + WASM");

// ...

    <view style="flex: 1;">
        <text id="welcome-text">{hi}</text>
        <text id="step-1">1. Play around</text>
        <StepOne />
        <text id="step-2">2. Debug</text>
        <StepTwo />
    </view>

// ...
```

## Resources for Learning NodeGui

- [svelte.nodegui.org](https://svelte.nodegui.org) - all of Svelte NodeGui's documentation

## Resources for Learning wasm-pack

- [wasm-pack docs](https://rustwasm.github.io/docs/wasm-pack/introduction.html)

## Packaging app as a distributable

In order to distribute your finished app, you can use [@nodegui/packer](https://github.com/nodegui/packer)

### Step 1: (_**Run this command only once**_)

```sh
npx nodegui-packer --init MyAppName
```

This will produce the deploy directory containing the template. You can modify this to suite your needs. Like add icons, change the name, description and add other native features or dependencies. Make sure you commit this directory.

### Step 2: (_**Run this command every time you want to build a new distributable**_)

Next you can run the pack command:

```sh
npm run build
```

This will produce the js bundle along with assets inside the `./dist` directory

```sh
npx nodegui-packer --pack ./dist
```

This will build the distributable using `@nodegui/packer` based on your template. The output of the command is found under the build directory. You should gitignore the build directory.

More details about `@nodegui/packer` can be found here: https://github.com/nodegui/packer

## License

MIT

repository: bradyjoslin/svelte-nodegui-wasm-starter

repo_name: bradyjoslin/svelte-nodegui-wasm-starter


text:
# @lit-labs/ssr-react

## 0.1.1

### Patch Changes

- [#3720](https://github.com/lit/lit/pull/3720) [`575fb578`](https://github.com/lit/lit/commit/575fb578473031859b59b9ed98634ba091b389f7) - Use hydration modules from `@lit-labs/ssr-client`

- Updated dependencies [[`575fb578`](https://github.com/lit/lit/commit/575fb578473031859b59b9ed98634ba091b389f7)]:
  -<EMAIL_ADDRESS>
## 0.1.0

### Minor Changes

- [#3605](https://github.com/lit/lit/pull/3605) [`b731bb5e`](https://github.com/lit/lit/commit/b731bb5e6d07af2e0ca2de911b781fa3794231cd) - Initial release of `@lit-labs/ssr-react` package.

  This package contains tools to deeply server render Lit components being used in React projects.

### Patch Changes

- Updated dependencies [[`f2eb9796`](https://github.com/lit/lit/commit/f2eb97962c7e77373b3b8861ab59639de22da3d0), [`ca74ff6e`](https://github.com/lit/lit/commit/ca74ff6eda710b929ca7aaf759a98cdfa350cc0d), [`b95c86e5`](https://github.com/lit/lit/commit/b95c86e5ec0e2f6de63a23409b9ec489edb61b86), [`e00f6f52`](https://github.com/lit/lit/commit/e00f6f52199d5dbc08d4c15f62380422e77cde7f), [`a5a584d5`](https://github.com/lit/lit/commit/a5a584d5b935f85cef4cbb8c9ff95cae34a8f41c), [`61ec3dab`](https://github.com/lit/lit/commit/61ec3dab761e379c65f9e27946e53137da83fb58), [`88a40177`](https://github.com/lit/lit/commit/88a40177de9be5d117a21e3da5414bd777872544)]:
  -<EMAIL_ADDRESS>  -<EMAIL_ADDRESS>

repository: sijakret/lit-html

repo_name: sijakret/lit-html


text:
# ReportListing

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**LastModified** | [**time.Time**](time.Time.md) | Date file was last modified | [optional]
**Name** | **string** | Name of the file | [optional]
**Size** | **string** | File size | [optional]

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

gha_language: Go


text:
---
title: 406. Love Consecrates the Humblest Act - Seventh Day Adventist Hymnal
metadata:
    description: |
      SDAH 406. Love Consecrates the Humblest Act. 1. Love consecrates the humblest act And haloes mercy’s deeds; It sheds a benediction sweet And hallows human needs.
    keywords:  |
      SDAH, Seventh Day Adventist Hymnal, adventhymnals, advent hymnals, Love Consecrates the Humblest Act, Love consecrates the humblest act
    author: Brian Onang'o
---

#### Advent Hymnals
## 406. LOVE CONSECRATES THE HUMBLEST ACT
#### Seventh Day Adventist Hymnal

```txt

1.
Love consecrates the humblest act
And haloes mercy’s deeds;
It sheds a benediction sweet
And hallows human needs.

2.
When in the shadow of the cross
Christ knelt and washed the feet
Of His disciples, He gave us
A sign of love complete.

3.
Love serves and willing, stoops to serve;
What Christ in love so true
Has freely done for one and all,
Let us now gladly do!

```

- |   -  |
-------------|------------|
Title | Love Consecrates the Humblest Act |
Key |  |
Titles | undefined |
First Line | Love consecrates the humblest act |
Author |
Year |
Composer|  |
Hymnal|  - |
Tune|  |
Metrical pattern | |
# Stanzas |  |
Chorus |  |
Chorus Type |  |
Subjects |  |
Texts |  |
Print Texts |
Scripture Song |  |

repository: GospelSounders/adventhymnals

repo_name: GospelSounders/adventhymnals


text:
# nvflip
Reverse or set the state of "flipping" on an Nvidia graphics card. This is handy when using screen recorders for screencasting. Simple Screen Recorder does this check, but some other recorders do not.

# Syntax
    nvflip [off|on]
Reverse flipping state: `nvflip`

Turn flipping off     : `nvflip off`

Turn flipping on      : `nvflip on`

# Notes
This little script illustrates writing the result of one command to a temporary file, then reading the results of that file to make a decision. This script does require Nvidia hardware drivers in Linux (BSD?).

repository: ServusCarolus/nvflip

repo_name: ServusCarolus/nvflip


text:
---
layout: post
title: "SimWeek 12"
categories: [Simulation Week]
tags: [FEA, CFD, LBM, engineering]
comments: true
image:
  feature: simweek12.png
  teaser: simweek12-teaser.png
  credit:
  creditlink:
---

# Finite Element Analysis

- How to make a supercomputer worth £200 using Raspberry 3 [ART]

- A crack propagation study in MoFEM. Very nice! [MOV]

Hierarchical approximation basis resolving singularity, with 4th order approximation at the crack tip and 1st order polynomial far from it.

Here is shown the evolution of crack surface. pic.twitter.com/iLICZfW2AZ
— Lukasz Kaczmarczyk (@LukaszKaczmarcz) 16 March 2018

# Computational Fluid Dynamics

- A week without Lattice-Boltmann Method is a lost week. Good looking animation of a helicopter study in EXA PowerFLOW [MOV]

- Schrödinger's Smoke. This video is rather VFX instead of typical CFD study, but looks amazing.. [MOV]

- If someone would like to understand how vortex generators are working, here is a very decent video [MOV]

- The best museum which is available online - the NASA timeline of numerical simulations [ART]

- I truly don't what is better here.. The results of simulations or the way the author presented results from measurements [MOV]

- An article about the Reynolds number. [ART]

# Engineering

- Sketchfab website allows to play with 3D models. Pretty cool stuff! [MODEL3D]

 Animated Heart Anatomy by Peter Domiano on Sketchfab

- I have never thought how the books are digitalised. I was quite amazed when I saw this video [MOV]

This is how they digitize books.. pic.twitter.com/Bh5BMSaOpA
— Interesting Engineering (@IntEngineering) 22 March 2018

<title>MathJax TeX Test Page</title>

- The scientist will try to change a light into matter using $E=mc^2$. They are still wondering though if it is possible [ART]

repository: spolanski/blog

repo_name: spolanski/blog


text:
# SharpUp

----

SharpUp is a C# port of various [PowerUp](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Privesc/PowerUp.ps1) functionality. Currently, only the most common checks have been ported; no weaponization functions have yet been implemented.

[@harmj0y](https://twitter.com/harmj0y) is the primary author.

SharpUp is licensed under the BSD 3-Clause license.

## Usage

```
SharpUp.exe [audit] [check1] [check2]...

    audit   - Specifies whether or not to enable audit mode. If enabled, SharpUp will run vulenrability checks
              regardless if the process is in high integrity or the user is in the local administrator's group.
              If no checks are specified, audit will run all checks. Otherwise, each check following audit will
              be ran.

    check*  - The individual vulnerability check to be ran. Must be one of the following:

              - AlwaysInstallElevated
              - CachedGPPPassword
              - DomainGPPPassword
              - HijackablePaths
              - McAfeeSitelistFiles
              - ModifiableScheduledTask
              - ModifiableServiceBinaries
              - ModifiableServiceRegistryKeys
              - ModifiableServices
              - ProcessDLLHijack
              - RegistryAutoLogons
              - RegistryAutoruns
              - TokenPrivileges
              - UnattendedInstallFiles
              - UnquotedServicePath

    Examples:
        SharpUp.exe audit
            -> Runs all vulnerability checks regardless of integrity level or group membership.

        SharpUp.exe HijackablePaths
            -> Check only if there are modifiable paths in the user's %PATH% variable.

        SharpUp.exe audit HijackablePaths
            -> Check only for modifiable paths in the user's %PATH% regardless of integrity level or group membership.
```

## Compile Instructions

We are not planning on releasing binaries for SharpUp, so you will have to compile yourself :)

SharpUp has been built against .NET 3.5 and is compatible with [Visual Studio 2015 Community Edition](https://go.microsoft.com/fwlink/?LinkId=532606&clcid=0x409). Simply open up the project .sln, choose "release", and build.

## Acknowledgments

SharpUp incorporates various code C# snippets and bits of PoCs found throughout research for its capabilities. These snippets and authors are highlighted in the appropriate locations in the source code, and include:

* [Igor Korkhov's code to retrieve current token group information](https://stackoverflow.com/questions/2146153/how-to-get-the-logon-sid-in-c-sharp/2146418#2146418)
* [JGU's snippet on file/folder ACL right comparison](https://stackoverflow.com/questions/1410127/c-sharp-test-if-user-has-write-access-to-a-folder/21996345#21996345)
* [Rod Stephens' pattern for recursive file enumeration](http://csharphelper.com/blog/2015/06/find-files-that-match-multiple-patterns-in-c/)
* [SwDevMan81's snippet for enumerating current token privileges](https://stackoverflow.com/questions/4349743/setting-size-of-token-privileges-luid-and-attributes-array-returned-by-gettokeni)
* [Nikki Locke's code for querying service security descriptors](https://stackoverflow.com/questions/15771998/how-to-give-a-user-permission-to-start-and-stop-a-particular-service-using-c-sha/15796352#15796352)
* [Raika](https://github.com/Raikia) for providing example unquoted service path search code.
* [RemiEscourrou](https://github.com/RemiEscourrou) for contributing additional ACE checking code and example modifiable service registry key code.
* [Coder666](https://github.com/Coder666) for adding ACE filtering code to filter only ACEs with access allowed.
* [vysecurity](https://github.com/vysecurity) for providing Registry Auto Logon and Domain GPP Password example code.
* [djhohnstein](https://github.com/djhohnstein) for merging in several outdated PRs and refactoring the entire code base.

repository: IMULMUL/SharpUp

gha_language: C#

gha_license_id: NOASSERTION

repo_name: IMULMUL/SharpUp


text:
# Contributing to Overwatch

Any contribution you can make to Overwatch is very welcome.

Feel free to open a new issue on the [Github issue tracker](https://github.com/zsturgess/overwatch/issues) if you think you have found a bug, or wish to suggest an enhancement. Ensure your issue is correctly marked with the `bug` or `enhancement` label.

## Contributing a patch

For any changes you wish to make, you should create an issue on the issue tracker, detailing the problem and your intended fix. This allows everyone involved in the Overwatch project to discuss your intended fix and collaborate on the intended solution.

To get started on your patch, fork the [main overwatch repository](https://github.com/zsturgess/overwatch). Start a new branch for your work, avoid committing directly to the master branch, even on your own fork.

All commit messages should contain the issue number that is being worked towards. Overwatch uses Travis CI to run automated tests against pull requests, so commits that make no code changes, such as changes to documentation or comments should have [skip ci] in the commit message.

Once your patch is ready (including writing any tests or documentation, and checking the existing tests do not fail), submit a pull request on the main overwatch repository's master branch.

repository: zsturgess/overwatch

gha_language: PHP

repo_name: zsturgess/overwatch


text:
### Class

```zenscript
import mods.roots.Spells;
```

#### Methods

```zenscript
Spell getSpell(
  string spellName // the name of the spell (spell_ will be prepended if not provided)
);
```

---

### Examples

```zenscript
import mods.roots.Spells;
import mods.roots.Spell;
import mods.roots.Costs;
import mods.roots.Herbs;

var harvest = Spells.getSpell("harvest") as Spell; // If not placed at the beginning, "spell_" will be automatically added.
harvest.setCooldown(800); // Sets the cooldown of the Harvest spell to 40 seconds.
harvest.setCost(Herbs.wildewheet, 1.25); // Increases the wildewheet cost of Harvest from the default of 0.55 to 1.25
harvest.setModifierCost(Costs.additional_cost, Herbs.wildroot, 0.9); // Increases the cost of the wildroot-related modifier's additional cost from the default of 0.125 to 0.9
harvest.setInteger("radius_x", 20);
harvest.setInteger("radius_z", 20);
harvest.setInteger("radius_y", 20); // Increases the size of the base Harvest radius to 20 blocks in all directions.
```

### Notes

You will want to use the `/roots spells` command in order to get a list of the relevant properties and their default values output to `roots.log` in order to determine which property names you wish to adjust.

repository: AnKangPig/CraftTweaker-Documentation

repo_name: AnKangPig/CraftTweaker-Documentation


text:
# Sprite

Sprite is a object to render textures at a free position on the screen. It can be used for characters, bullets etc.

## Textures

Textures mean images loaded by DotFeather.

Textures are expressed as `Texture2D` structure, and you can load textures by calling a static method of `Texture2D` structure.

```cs
Texture2D texture = Texture2D.LoadFrom("./assets/title.png");
```

### Load and Split textures

DotFeather has a function to load and split textures so that you can load sprite sheet, in which a image for animation is arranged in a grid shape in one image.

```cs
Texture2D[] textures = Texture2D.LoadAndSplitFrom("./assets/zombie.png", 16, 2, new Size(16, 16));
```

This program reads the file in ./assets/zombie.png and cuts out as 16x16, 16 horizontal and 2 vertical, totally 32 textures.

## Sprites

After loading textures, create a instance of sprite and display it.

```cs
Sprite title = new Sprite(texture, 0, 32);
Sprite zombie = new Sprite(textures[0], 64, 16);
Root.Add(sprite);
```

In addition, you can directly generate sprites by specifying path:

```cs
Sprite sprite = Sprite.LoadFrom("./assets/skeleton.png");
```

## Animating Sprite

`AnimatingSprite` class loads splitted textures array, and perform texture-animation.

Let's actually use `AnimatingSprite` as following example:

```cs
var zombieWalking = new AnimatingSprite(textures, -1, 4);
Root.Add(zombieWalking);

// Don't forget
zombieWalking.StartAnimating();
```

In the constructor of the `AnimatingSprite` class, you can specify the texture array as the first argument, the loop count as the second argument, and the time as the third argument.

If the number of loops is 1 or more, it loops that number of times. If 0, do not loop. And if it is -1, it loops infinitely.

Time is the frame time until switching to the next texture. For example, if it is 5, a single texture will be displayed in 5 frames.

Since `AnimatingSprite` does not animate automatically after initialization, be sure to call the` StartWalking` method.

Next: [Tilemap](tilemap.md)

repository: acid-chicken/DotFeather

repo_name: acid-chicken/DotFeather


text:
outlier_filter {#outlier_filter-package-design}
===========

# Purpose / Use cases

The `outlier_filter` package is a library package containing the implementations of the three
outlier filters from the TierIV [AutowareArchitectureProposal repository](https://github.com/tier4/AutowareArchitectureProposal.iv):
 * `radius_search_2d_filter` - uses PCL functions to radially search a point for surrounding neighbors
 * `voxel_grid_outlier_filter` - uses voxels to determine if a particular voxel contains outliers
 * `ring_filter` (Not Implemented Yet) - uses ring information from the lidar to determine if a point is an outlier

# Design
<!-- Required -->
<!-- Things to consider:
    - How does it work? -->

The algorithm originally coupled with the ROS2 Node interfaces has been separated to create two new
packages following the package design guidelines in the AutowareAuto. This library package contains
the main implementation of the filtering algorithms for the three outlier filter types.

## Assumptions / Known limits
<!-- Required -->

### Discretization

The `voxel_grid_outlier_filter` implementation using discretized voxel to determine whether a point is an
outlier. Due to the nature of discretized algorithms, a small approximation error could be
introduced. For applications where the reduction of approximation error is important, alternative
outlier filter implementations such as the `radius_search_2d_filter` should be used instead.

### Radius Search 2D Only

The `radius_search_2d_filter` implementation is only in the 2d space. More details in the sections below.

### Controlling Access To Parameters

As parameters may be changed during runtime, the node class using the filter classes will need to be
control access to the parameters via mutexes. The functions that require guarding are
`update_parameters` and `filter`.

## Inputs / Outputs / API
<!-- Required -->
<!-- Things to consider:
    - How do you use the package / API? -->
### Constructor

Parameters used by the filtering algorithm should be initially passed into the filter class through
the class constructor. A typical constructor for filter class in this package would be in the
form:

```{cpp}
explicit OUTLIER_FILTER_PUBLIC src/perception/filters/outlier_filter/src/voxel_grid_outlier_filter.cpp(int input_a, int input_b);
```

Where `input_a` and `input_b` are the exhaustive list of parameters required for the filter
functionality. The name of the filter should be appended with the suffix `Filter`.

#### radius_search_2d_filter

The following parameters are required by the `radius_search_2d_filter`:
 * `search_radius_` - radius around point where neighbors are searched (Type: `double`, Unit: meters)
 * `min_neighbors_` - minimum number of neighbors required for point to not be considered an outlier (Type: `int`)

#### voxel_grid_outlier_filter

The following parameters are required by the `voxel_grid_outlier_filter` class constructor:
 * `voxel_size_x` - voxel leaf size in the x-axis (Type: `float`, Unit: meters)
 * `voxel_size_y` - voxel leaf size in the y-axis (Type: `float`, Unit: meters)
 * `voxel_size_z` - voxel leaf size in the z-axis (Type: `float`, Unit: meters)
 * `voxel_points_threshold` - minimum number of points in voxel for a voxel to be valid (Type: `int`)

### Modifying Parameters

The classes allow for parameters to be modified during run-time. The Node class using the filter
library should call the `update_parameters` method and pass in all the parameters; for example:

```{cpp}
std::mutex mutex_;
float search_radius = 1.0;
int min_neighbors = 5;
auto filter = std::make_shared<RadiusSearch2DFilter>(search_radius, min_neighbors);

// Perform some update on the parameters
search_radius = 1.5;
{
    std::lock_guard<std::mutex> lock(mutex_);
    filter->update_parameters(search_radius, min_neighbors);
}
```

### Filtering Function

Each of the filter classes should contain some filter activation function which will run the filter
on an input point cloud.

```{cpp}
void OUTLIER_FILTER_PUBLIC filter(
    const pcl::PointCloud<pcl::PointXYZ> & input,
    pcl::PointCloud<pcl::PointXYZ> & output);
```

Depending on the filtering method the point type used in the input may differ. The filtered point
cloud is stored in `output`.

## Inner-workings / Algorithms {#outlier-filter-algorithm}
<!-- If applicable -->
### radius_search_2d_filter

The `radius_search_2d_filter` filtering method is straightforward. The input point cloud is
flattened by converting the PointXYZ to PointXY. It utilizes the [PCL `Search` object]
(https://pointclouds.org/documentation/classpcl_1_1search_1_1_search.html) to search a radius
(defined by `search_radius_`) around the point of interest for neighboring points. If the minimum
number of neighboring points is found, the original point is added to the output point cloud.

### voxel_grid_outlier_filter

The `voxel_grid_outlier_filter` filtering method using the PCL library `VoxelGrid` object to discretize the
point cloud into equi-sized voxels containing a certain number of points. Then the 3D grid is
searched to determine if a point lies within a voxel. Points returning an existing voxel are not
considered outliers and are added to the output point cloud.

## Error detection and handling
<!-- Required -->

N/A

# Security considerations
<!-- Required -->
<!-- Things to consider:
- Spoofing (How do you check for and handle fake input?)
- Tampering (How do you check for and handle tampered input?)
- Repudiation (How are you affected by the actions of external actors?).
- Information Disclosure (Can data leak?).
- Denial of Service (How do you handle spamming?).
- Elevation of Privilege (Do you need to change permission levels during execution?) -->

N/A

# External References

## radius_search_2d_filter

The original implementation of the `radius_search_2d_filter` can be found in the TierIV
AutowareArchitectureProposal repository:
* [`radius_search_2d_outlier_filter_nodelet.hpp`](https://github.com/tier4/AutowareArchitectureProposal.iv/blob/ros2/sensing/preprocessor/pointcloud/pointcloud_preprocessor/include/pointcloud_preprocessor/outlier_filter/radius_search_2d_outlier_filter_nodelet.hpp)
* [`radius_search_2d_outlier_filter_nodelet.cpp`](https://github.com/tier4/AutowareArchitectureProposal.iv/blob/ros2/sensing/preprocessor/pointcloud/pointcloud_preprocessor/src/outlier_filter/radius_search_2d_outlier_filter_nodelet.cpp)

## voxel_grid_outlier_filter

The original implementation of the `voxel_grid_outlier_filter` can be found in the TierIV
AutowareArchitectureProposal repository:
* [`voxel_grid_outlier_filter_nodelet.hpp`](https://github.com/tier4/AutowareArchitectureProposal.iv/blob/ros2/sensing/preprocessor/pointcloud/pointcloud_preprocessor/include/pointcloud_preprocessor/outlier_filter/voxel_grid_outlier_filter_nodelet.hpp)
* [`voxel_grid_outlier_filter_nodelet.cpp`](https://github.com/tier4/AutowareArchitectureProposal.iv/blob/ros2/sensing/preprocessor/pointcloud/pointcloud_preprocessor/src/outlier_filter/voxel_grid_outlier_filter_nodelet.cpp)

# Related issues
<!-- Required -->

See:
 - Port from ArchitectureProposal (#917)

repository: bytetok/vde

repo_name: bytetok/vde


text:
# PythonRestAPITesting
![Python Testing Logo](/images/pythonTestingBanner.webp)

Example code for testing a REST API using Python Requests and Pytest.

Run from the command line with: pytest tests\01_basic_tests.py --html=pytest_report.html

or run the runMe.bat file

Report file is created as : pytest_report.html

## Goal:
* 3(4) tests for rest service available here: http://ec2-3-123-145-12.eu-central-1.compute.amazonaws.com/api

## Roles:
* Admin - superuser which has access to admin system via token
* User - client which can only query publicly opened endpoints (the ones without need of token)

## Tests
1. Smoke Test
    * Check that the API is up and healthy. If this fails, all other tests are skipped.

1. Wrong Token Test
    * Admin provides incorrect token while trying to get logs from environment

1. Admin updates fund id field
    * User can see some fund id in ‘api/v0/fund’ endpoint
    * Admin updates fund id it to different value
    * User can now see new fund id in ‘api/v0/fund’ endpoint

1. Admin clears log
    * Make sure that there is at least one log entry in logs endpoint (you can generate logs entry by querrying v0/fund or v0/challenges)
    * Admin clears log
    * Admin validates logs are cleared

repository: GMc-RT/PythonRestAPITesting

repo_name: GMc-RT/PythonRestAPITesting


text:
Glide
=====

This is source code repo of glide. For User guide check the [Glide's homepage](http://glide-gae.appspot.com).

[![Build Status](https://travis-ci.org/kdabir/glide.png)](https://travis-ci.org/kdabir/glide)

## Contributing

See [Contribution Guidelines](CONTRIBUTING.md)

repository: triadynata/glide

repo_name: triadynata/glide


text:
# MNASNet 1.0 Inference

## Description

This document has instructions for running MNASNet 1.0 inference using
Intel-optimized PyTorch.

## Bare Metal
### General setup

Follow [link](/docs/general/pytorch/BareMetalSetup.md) to install Conda and build Pytorch, IPEX, TorchVison and Jemalloc.

### Model Specific Setup

* Set Jemalloc Preload for better performance

  The jemalloc should be built from the [General setup](#general-setup) section.
  ```bash
  export LD_PRELOAD="path/lib/libjemalloc.so":$LD_PRELOAD
  export MALLOC_CONF="oversize_threshold:1,background_thread:true,metadata_thp:auto,dirty_decay_ms:9000000000,muzzy_decay_ms:9000000000"
  ```

* Set IOMP preload for better performance

  IOMP should be installed in your conda env from the [General setup](#general-setup) section.
  ```bash
  export LD_PRELOAD=path/lib/libiomp5.so:$LD_PRELOAD
  ```

* Set ENV to use AMX if you are using SPR
  ```bash
  export DNNL_MAX_CPU_ISA=AVX512_CORE_AMX
  ```

## Datasets

### ImageNet

The [ImageNet](http://www.image-net.org/) validation dataset is used to run MNASNet 1.0
accuracy tests.

Download and extract the ImageNet2012 dataset from [http://www.image-net.org/](http://www.image-net.org/),
then move validation images to labeled subfolders, using
[the valprep.sh shell script](https://raw.githubusercontent.com/soumith/imagenetloader.torch/master/valprep.sh)

A after running the data prep script, your folder structure should look something like this:
```
imagenet
└── val
    ├── ILSVRC2012_img_val.tar
    ├── n01440764
    │   ├── ILSVRC2012_val_00000293.JPEG
    │   ├── ILSVRC2012_val_00002138.JPEG
    │   ├── ILSVRC2012_val_00003014.JPEG
    │   ├── ILSVRC2012_val_00006697.JPEG
    │   └── ...
    └── ...
```
The folder that contains the `val` directory should be set as the
`DATASET_DIR` (for example: `export DATASET_DIR=/home/<user>/imagenet`).

## Quick Start Scripts

|  DataType   | Throughput  |  Latency    |   Accuracy  |
| ----------- | ----------- | ----------- | ----------- |
| FP32        | bash batch_inference_baremetal.sh fp32 | bash online_inference_baremetal.sh fp32 | bash accuracy_baremetal.sh fp32 |
| BF16        | bash batch_inference_baremetal.sh bf16 | bash online_inference_baremetal.sh bf16 | bash accuracy_baremetal.sh bf16 |

## Run the model

Follow the instructions above to setup your bare metal environment, download and
preprocess the dataset, and do the model specific setup. Once all the setup is done,
the Model Zoo can be used to run a [quickstart script](#quick-start-scripts).
Ensure that you have enviornment variables set to point to the dataset directory
and an output directory.

```
# Clone the model zoo repo and set the MODEL_DIR
git clone https://github.com/IntelAI/models.git
cd models
export MODEL_DIR=$(pwd)

# Env vars
export DATASET_DIR=#path_to_Imagenet_Dataset
export OUTPUT_DIR=#Where_to_save_log

# Run a quickstart script (for example, FP32 batch inference)
cd ${MODEL_DIR}/quickstart/image_recognition/pytorch/mnasnet1_0/inference/cpu
bash batch_inference_baremetal.sh fp32
```

<!--- 80. License -->
## License

[LICENSE](/LICENSE)

repository: rahulunair/models

repo_name: rahulunair/models


text:
# Movies-ETL

##A. Background

**E**xtract data from Wikipedia and Kaggle databases about movie reviews.
**T**ransform (Clean and combine the data) to one and **L**oad (upload) to SQL ,postgres database

##B. Key Assumptions / Method for ETL
1. Inspect and filter data
	- example alternat title and condensing thevarious columns
	- unique id for data sets
2. Duplicates ar common, remove them as part of the cleaning process
	- Use regular expression to filter
	- drop duplicates
3. Drop null columns
	- 90% or more data in the column entries are null

4. get the dtypes correct by using pandas to_numeric etc type conversions
	- prior to that have to parse the data in the key columns and get
them to the correct exprssion
	- use regex type to tranform the data and get to consistent units
	 - i.e million, billion etc converted to same baseline
5.Search for bad data/corrupted data and clean it out.
	- sometimes columns are mixed up, drop those rows are fix it if possible.

6. Merging databases
	- list column by column to merge across the databases
	- get columns in conssitent style [e.g budget, box ofice data...]
	- option 1 :clean up columns and merge the best of each
	- option 2 :if there is much cleaner column, use that and drop the other.
		- sometimes you can plot the column against each other to see the skew and make decisions
		- look for outliers and eliminate columns with too many outliere or not correctable.
7. uploading to sql
        - create a connection string to access to database
	- use pandas to_sql to connect and ceate. This connection object is used to load columns and data.
	- large data have to uploaded in chunks , e.g 1000000  bytes..

8. Automate the process for periodic update with the complete python script
	- challenge.py for this exercise (movies_etl.ipynb for practice/development)
	- example of output for this challenge

![](challenge_output.png)


text:
# How Do I Enable Outbound SMTP Authentication

Below is an example of the configuration options needed to enable this module. The only supported Outbound_SMTP_AUTH_Type options are PLAIN and LOGIN.

```
outbound_smtp_auth { }
Keep_Message_Dicts_In_Memory = true

# Example of use . Here with a domain:
Domain "messagesystems.com" {
 Outbound_SMTP_AUTH_Type = "LOGIN"
 Outbound_SMTP_AUTH_User = "myuser"
 Outbound_SMTP_AUTH_Pass = "mypass"
}
```


text:
# Use Prometheus Monitoring to install and configure MySQL exporters

Prometheus Monitoring allows you to install and configure MySQL exporters, and provides out-of-the-box dashboards.

## Entry

1.  Log on to the [ARMS console](https://arms-ap-southeast-1.console.aliyun.com/#/home).

2.  In the left-side navigation pane, click **Prometheus Monitoring**.

3.  In the upper-left corner, select the target region and click the name of the target Kubernetes cluster.

4.  In the left-side navigation pane, click **Exporter access**.

## Add a MySQL exporter

1.  On the **Exporter access** page, click **add Exporter** in the upper-right corner.

2.  In the search box in the upper-right corner of the **Exporter list** dialog box, enter an Exporter name and click the target Exporter icon.

3.  In the MySql Exporter configuration dialog box, configure the parameters on the **Configuration** tab and then click **OK**.

    |Parameter|Description|
    |---------|-----------|
    |**Exporter name**|The name of the exporter. The name must meet the following requirements:    -   It can contain only lowercase letters, digits, and hyphens \(-\), and cannot start or end with a hyphen \(-\).
    -   It must be unique.
If you do not specify this parameter, the system uses the default name that consists of the exporter type and a numeric suffix.|
    |**MySqlAddress**|The endpoint of the MySQL database.|
    |**MySqlPort**|The port number of the MySQL database. Example: 3306.|
    |**Username**|The username that you can use to connect to the MySQL database.|
    |**Password**|The password that you can use to connect to the MySQL database.|

4.  On the **Exporters** page, click the DASHBOARD link in the **dashboard** column to view the Prometheus dashboard.

    ![pg_prom_dashboard_mysql](https://static-aliyun-doc.oss-accelerate.aliyuncs.com/assets/img/en-US/3154268061/p97619.png)

5.  On the **Exporters** page, you can perform the following operations on the added Exporter:

    -   Click **Delete** in the **Actions** column to delete the Exporter.
    -   Click **Log** in the **Actions** column to view the operational logs of the Exporter.
    -   Click **Details** in the **Actions** column to view the Exporter details, including the environment variables and description of the Exporter.

**Related topics**

[Use Prometheus Service to monitor other exporters]()

url: https://raw.githubusercontent.com/hglakfs/arms/b0dedb5bfe2a39fbaebc7a0556a54bdf078321ae/intl.en-US/Prometheus Service/Exporters/Use Prometheus Monitoring to install and configure MySQL exporters.md

repository: hglakfs/arms

repo_name: hglakfs/arms


text:
---
layout: project
type: project
draft: true
image: images/movie-rating.jpeg
title: Flick Critik
permalink: projects/flick-critik
date: 2020-06-30
labels:
  - Javascript
  - Meteor
  - React
summary: A local web app that allows users to rate and review movies, that was designed in ICS 427, Software Quality Assurance.
---

In my ICS 427 class, I was part of Team Splendor and we made a movie rating and reviewing local web app called Flick Critik. This web app allows users to rate
and review movies that are in our database. We had the home page, an account system for signing up / in / out, seperate pages for each movie as well as a page that contained the list of movies, and the ratings & reviews page. This project was also designed with the Secure Development Lifecycle (SDL) in mind. Every week, we would write weekly reports and continue to follow the SDL to ensure that our project was secure. We were able to ensure that our project was secure by following
all of the parts of the SDL such as dynamic analysis, static analysis, etc...

For this project, the main parts that I worked on were the ratings and reviews page. I had done this before in a previous project so the code was a little similar. However, the usage of that code was a bit different from this one so I had to transition that old code into a newer version. Within these pages, it gave users an
option to rate the movies on a scale of 1-5 and review the movies by leaving comments as to what their thoughts on the movies were. These comments would then show
up for other users to see so they can get a sense of what the movie was like.

Overall, from this experience, what I learned was not necessarily how to code the program as it was something similar to what I had previously done (although it
did help refresh my memory of the concepts), but how to go through the Secure Development Lifecycle and enact it throughout the coding process. By following the
Secure Development Lifecycle, we were able to secure our program through the various methods and we got a sense as to what cybersecurity computer scientists have
to do in order to secure their programs. Although this is just scratching the surface, I still feel like we got a good grasp on the world of cybersecurity and how it works in the coding process.

You can find the repository for our project [here](https://github.com/team-splendor/flick-critik).

[Here](https://github.com/team-splendor/flick-critik/blob/master/ICS%20427%20Flick%20Critik%20Report.pdf) is the link to our reports that followed the Secure Development Lifecycle. We explain in depth what we did throughout the project in each week and how we tested everything along the way in order to ensure the security of our program.


text:
# Appendix B - Big Bang Troubleshooting

- [Appendix B - Big Bang Troubleshooting](#appendix-b---big-bang-troubleshooting)
  - [Iron Bank authentication](#iron-bank-authentication)
  - [Flux install](#flux-install)
  - [Git Repository](#git-repository)
  - [ConfigMap or Secrets](#configmap-or-secrets)
  - [Helm Release](#helm-release)
  - [Kustomization](#kustomization)
  - [Packages](#packages)

Big Bang can take a long time to run.  After making changes, it could take 10-15 minutes to take effect.  Use the [sync.sh](../hack/sync.sh) script to speed this up.

Big Bang is configured to retry failed package installations and upgrades.  Before concluding you have a failure, make sure you allow Big Bang to attempt to resolve dependencies and retry.

## Iron Bank authentication

| Symptom | Cause | Resolution |
|--|--|--|
| Despite entering correct credentials, get `unauthorized: authentication required` from Iron Bank | Using a non-robot account with an expired token | Login with the non-robot account manually at `registry1.dso.mil`, then retry.  For production, contact the Iron Bank team to obtain a robot account and update pull credentials to use it in your environment |

## Flux install

Helpful debugging commands:

```shell
# Get the status
kubectl get pods -n flux-system

# Get the logs
kubectl get events -n flux-system
```

| Symptom | Cause | Resolution |
|--|--|--|
| Install script timed and pods are still pulling the image | Slow connection to docker registry | Adjust `--timeout` value in `flux install` to wait longer |
| Pod status is `ImagePullBackOff` or `ErrImagePull` | Bad registry, version, or credentials | Fix the `--registry`, `--version`, or `--image-pull secret` options or use the `hack/flux-install.sh` script for pulling from Iron Bank |

## Git Repository

Helpful debugging commands:

```shell
# Get the status
kubectl get gitrepositories -A

# Get the logs
kubectl get events --field-selector involvedObject.kind=GitRepository -A
```

| Symptom | Cause | Resolution |
|--|--|--|
| `unable to clone ... error: authentication required` | Pull credentials for Git invalid or not provided | Add credentials to a `Secret` and reference it in `GitRepository.spec.secretRef.name`.  If possible, encrypt the secret and include it in the Kustomization deployment for your environment.
| `auth secret error: Secret ... not found` | `GitRepository` is trying to use credentials but cannot find the `Secret` | Make sure the secret exists and is in the same namespace as the `GitRepository` resource.   If possible, encrypt the secret and include it in the Kustomization deployment for your environment.
| `unable to clone ... error: repository not found` | Invalid Git url | Fix url for Git repository and redeploy |
| `unable to clone ... error: couldn't find remote ref` | Invalid branch or tag | Fix branch or tag for Git repository and redeploy |

## ConfigMap or Secrets

| Symptom | Cause | Resolution |
|--|--|--|
|`ConfigMap` or `Secret` does not exist| GitRepository or Kustomization failed.  Namespace was incorrect. | Use [GitRepository](#git-repository) and [Kustomization](#kustomization) sections to troubleshoot.  Use `kubectl get secrets,configmaps -A` to verify resource was not in the wrong Namespace. |

## Helm Release

Helpful debugging commands:

```shell
# Get the status
kubectl get hr -A

# Get the logs
kubectl get events --field-selector involvedObject.kind=HelmRelease -A

# Describe the HelmRelease to get more information
kubectl describe hr <NAME> -n bigbang

# Get all logs/events for a specific HelmRelease object
flux logs --kind=HelmRelease --namespace bigbang --name <NAME>
```

| Symptom | Cause | Resolution |
|--|--|--|
| `Reconciliation in Progress` | This is normal and indicates flux is currently applying updates | Wait |
| `dependency ... is not ready` | This is normal and indicates flux is currently waiting on another resource to complete | Wait |
| `Error: YAML parse error on ...` | Syntax error in helm chart | Use `helm template` to narrow down the problem.  Fix it and commit to Git |
| `Helm install failed: failed to create resource ... unable to create new content in namespace because it is being terminated` | This seems to happen when a re-deploy of Big Bang occurs to early after a Big Bang delete. |  Try to remove the namespace using `kubectl get ns <stuck namespace> -o json | jq '.spec.finalizers = []' | kubectl replace --raw "/api/v1/namespaces/$NS/finalize" -f`.  If this does not work, a cluster restart may be necessary. |
| `Error: failed to download ...` | Path to Helm chart is incorrect | Find the HelmRelease configuration and update `spec.path` to the correct path of the helm chart |
| `Helm uninstall failed: uninstall: Release not loaded: ____: release: not found` | Helm install failed because of an error and a rollback/uninstall is attempted but release has not been installed. | Describe the HelmRelease in question or use flux to get the logs to get more info abut why it failed to install. |
| `reconciliation failed: Helm rollback failed: an error occurred while cleaning up resources. original rollback error: no XXXX with the name "XXXX" found: unable to cleanup resources: object not found, skipping delete` | This error happens when an upgrade fails and flux attempts a rollback but there are templates that have been renamed/removed. | Describe the HelmRelease in question or use flux to get the logs to get more info abut why exactly the upgrade failed. |

## Kustomization

Helpful debugging commands:

```shell
# Get the status
kubectl get kustomizations -A

# Get the logs
kubectl get events --field-selector involvedObject.kind=Kustomization -A
```

| Symptom | Cause | Resolution |
|--|--|--|
| `kustomization path not found` | `spec.path` in Kustomization resource in is incorrect | Fix `spec.path` and redeploy |
| `Source not found` | `spec.sourceRef` in Kustomization resource is incorrect | Fix `spec.sourceRef` to point to repository resource and redeploy |
| `decryption secret error: Secret ... not found` | SOPS private key secret is missing or misconfigured | Check `decryption` settings in the Kustomization resource to make sure `secretRef` is pointing to the correct secret.  Make sure the `Secret` holding the private key is deployed in the cluster. |
| `kustomize build failed: json: unknown field` | There is a syntax error with the kustomization files. | Use `kustomize build` on the `<env>` folder or `base` folder to narrow down the problem.  Fix the error and push to Git. |
| `evalsymlink failure ... no such file or directory` | A reference to a file in `kustomization.yaml` is incorrect | Use `kustomize build` on the `<env>` folder or `base` folder to narrow down the problem.  Fix the error and push to Git. |
| `Error: accumulating resources ...` | A reference to a base is incorrect | Use `kustomize build` on the `<env>` folder or `base` folder to narrow down the problem.Review the `bases:` section for correct paths to find the error.  Fix the error and push to Git. |
| `Error fetchingref: fatal: couldn't find remote ref ...` | The branch, tag, or sha used for a remote base is incorrect | Use `kustomize build` on the `<env>` folder or `base` folder to narrow down the problem.  It is likely the remote reference to the Big Bang's Kustomize in the `base` folder.  Review the `bases:` section for correct paths to find the error.  Fix the error and push to Git. |
| `Error: merging from generator ...` | Kustomize is trying to merge with a resource that is non-existent.  This is usually due to naming the merging `ConfigMap` or `Secret` incorrectly compared to a base `ConfigMap` or `Secret`. | Use `kustomize build` on the `<env>` folder or `base` folder to narrow down the problem.


text:
---
title: How to list all files larger/smaller than certain size
meta_description: If you want to list all flac files smaller than 12mb or bigger than or even delete them all.
layout: post
permalink: how-to-list-all-files-largersmaller-than-certain-size
categories: [bash, ubuntu]
---
If you want to list all flac files smaller than 12mb:

{% highlight bash %}
find -name "*.flac" -size -12000k
{% endhighlight %}

If you want to list files bigger than, just change the **- **for a **+**

{% highlight bash %}
find -name "*.flac" -size +12000k
{% endhighlight %}

Now if you want to delete them, just add a -delete after that:

{% highlight bash %}
find -name "*.flac" -size -12000k -delete
{% endhighlight %}

branch_name: refs/heads/gh-pages

gha_language: CSS


text:
---
layout: post
title: "An approach to image denoising using manifold approximation without clean images"
date: 2019-04-28 13:53:28
categories: arXiv_CV
tags: arXiv_CV Super_Resolution Image_Enhancement Deep_Learning
author: Rohit Jena
mathjax: true
---

* content
{:toc}

##### Abstract
Image restoration has been an extensively researched topic in numerous fields. With the advent of deep learning, a lot of the current algorithms were replaced by algorithms that are more flexible and robust. Deep networks have demonstrated impressive performance in a variety of tasks like blind denoising, image enhancement, deblurring, super-resolution, inpainting, among others. Most of these learning-based algorithms use a large amount of clean data during the training process. However, in certain applications in medical image processing, one may not have access to a large amount of clean data. In this paper, we propose a method for denoising that attempts to learn the denoising process by pushing the noisy data close to the clean data manifold, using only noisy images during training. Furthermore, we use perceptual loss terms and an iterative refinement step to further refine the clean images without losing important features.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1904.12323](http://arxiv.org/abs/1904.12323)

##### PDF
[http://arxiv.org/pdf/1904.12323](http://arxiv.org/pdf/1904.12323)


text:
CloudManaged - SabreDAV abstraction
---

Library to abstract SabreDAV library from your own (Web\Card\Cal) DAV implementation

## License

This library is under the MIT license. See the complete license in the library:

[LICENSE](https://github.com/CloudManaged/sabredav-abstraction/LICENSE)

## About

SabreDAV abstraction is a [CloudManaged](https://github.com/CloudManaged) initiative.
See also the list of [contributors](https://github.com/CloudManaged/sabredav-abstraction/graphs/contributors).

## Reporting an issue or a feature request

Issues and feature requests are tracked in the [GitHub issue tracker](https://github.com/CloudManaged/sabredav-abstraction/issues).

repository: CloudManaged/sabredav-abstraction

repo_name: CloudManaged/sabredav-abstraction


text:
---
title: What we learned
type: tutorials
order: 9
---

The behavior of user interfaces can be described accurately with a state machine, which can be visualized through a graph. The graph is often a more concise, precise, and easy-to-understand description of requirements.

Writing the behavior as a state machine also makes some behaviors impossible by construct, which gives us contracts for free (such as the assurance that a user cannot submit a weak password). Moreover, the machine will react gracefully to unexpected events -- by ignoring them. This contributes to robust UIs.

The behavior of the interface is completely separated from the DOM representation and update concerns. This is why Kingly self-describes as the library for portable UIs. We can thus use any UI library we want -- or no library, according to our preferences and requirements:

|*UI library* |Possible reason for choice |
|:---|:---|
|*Vanilla JS* | potentially the fastest option|
|*morphdom*| real DOM diffing, no virtual DOM|
|*Vue*| template-based, easier to cooperate with designers with HTML skills|
|*React*| virtual DOM diffing, large ecosystem|

Kingly machines can be traced thanks to a dev tool extension and optional debugging messages in the console. Kingly machines can be drawn with a graph editor and compiled into zero-dependency small vanilla JavaScript functions.

In the next tutorial, we will modelize a chess game interface as a state machine. This example will feature more advanced concepts such as hierarchy, history pseudo-states, dependency injection, and more.

Alternatively, the reader who would rather have a more conceptual overview of state machines can refer to a [detailed article](https://medium.com/dailyjs/user-interfaces-you-can-trust-with-state-machines-49de7fa138a6) on the subject.

repository: andyjakubowski/kingly-site

repo_name: andyjakubowski/kingly-site


text:
# Laravel Embed

Effortless responsive embeds for videos, slideshows and more.

Created by Ben Sampson

## Requirements

- Laravel `8` or newer
- PHP `7.4.0` or newer

## Installation

### 1. Composer

```bash
composer require bensampo/laravel-embed
```

### 2. Include styles

Somewhere inside the `<head>` element of the document, include:

```html
<x-embed-styles />
```

If you'd prefer to include the styles in your own CSS file, you may copy the contents of [`styles.blade.php`](https://github.com/BenSampo/laravel-embed/blob/master/resources/views/components/styles.blade.php).

### 3. Publish views (optional)

If you'd like to edit any of the views you may publish them:

```bash
php artisan vendor:publish --provider="BenSampo\Embed\EmbedServiceProvider"
```

Once published they can be found in `/resources/views/vendor/embed/`.

## Usage

Simply include the following blade component in your view making sure to pass the `url` attribute.

The `url` should be the public URL for the page you're trying to embed.

```html
<x-embed url="https://www.youtube.com/watch?v=oHg5SJYRHA0" />
```

### Setting the aspect ratio

By default most embedded services are shown at a ratio of `16:9`. Some services may override this if they have a more appropriate default. However, you can always change this by passing in a ratio to the `aspect-ratio` attribute.

```html
<x-embed url="https://www.youtube.com/watch?v=oHg5SJYRHA0" aspect-ratio="4:3" />
```

The aspect ratio is maintained at different viewport sizes.

### Fallback

If no service exists to handle the URL a fallback view is rendered. You can customize this by publishing the views and editing `/resources/views/vendor/embed/services/fallback.blade.php`.

### Validation

A validation rule can be used to check for a supported service in a given URL.

```php
use BenSampo\Embed\Rules\EmbeddableUrl;

public function store(Request $request)
{
    $this->validate($request, [
        'url' => ['required', new EmbeddableUrl],
    ]);
}
```

You may specify a list of allowed services using the `allowedServices` method.

```php
use BenSampo\Embed\Services\Vimeo;
use BenSampo\Embed\Services\YouTube;
use BenSampo\Embed\Rules\EmbeddableUrl;

public function store(Request $request)
{
    $this->validate($request, [
        'url' => [
            'required',
            (new EmbeddableUrl)->allowedServices([
                YouTube::class,
                Vimeo::class
            ])
        ],
    ]);
}
```

## Embed Services

Laravel embed supports multiple popular embed services such as YouTube, Vimeo and Slideshare.

[See the full list →](https://github.com/BenSampo/laravel-embed/tree/master/src/Services)

Please submit an issue (or better yet a PR!) if the service you'd like to embed is not listed.

repository: BenSampo/laravel-embed

repo_name: BenSampo/laravel-embed


text:
# City Explorer

**Author**: Yaser Al-Ananbeh
**Version**: 1.0.0

## Overview
<!-- Provide a high level overview of what this application is and why you are building it, beyond the fact that it's an assignment for this class. (i.e. What's your problem domain?) -->
City explorer is a website to make the users able to display a map for any country or city that they are searching about

## Getting Started
<!-- What are the steps that a user must take in order to build this app on their own machine and get it running? -->
they can use any browser to enter the website url and use the project

## Architecture
<!-- Provide a detailed description of the application design. What technologies (languages, libraries, etc) you're using, and any other relevant design information. -->
the technologies (React js , node, locationiQ Api, axios,bootstrap)

## Change Log
<!-- Use this area to document the iterative changes made to your application as each feature is successfully implemented. Use time stamps. Here's an example:

01-01-2001 4:59pm - Application now has a fully-functional express server, with a GET route for the location resource. -->

Name of feature:1. Set up your React repository & API keys.

Estimate of time needed to complete: 1hour

Start time: 5:00

Finish time: 2:00

Actual time needed to complete: 2HOURS

Name of feature:2. Locations: As a user of City Explorer, I want to enter the name of a location so that I can see the exact latitude and longitude of that location.

Estimate of time needed to complete: 2hour

Start time: 7:00

Finish time: 9:30

Actual time needed to complete: 2 hours and 30 min

Name of feature:3. Map: As a user, I want to see a map of the city so that I can see the layout of the area I want to explore.

Estimate of time needed to complete: 1hour

Start time: 10:00

Finish time: 11:00

Actual time needed to complete: 1hour

Name of feature:4. Errors: As a user, I want clear messages if something goes wrong so I know if I need to make any changes or try again in a different manner.

Estimate of time needed to complete: 1hour

Start time: 11:00

Finish time: 11:30

Actual time needed to complete: 30min

Name of feature:5. Movies: As a user of City Explorer, I want to see info about movies related to the city I searched, so that I can learn more about the destination.

Estimate of time needed to complete: 1hour

Start time: 7:30

Finish time: 8:30

Actual time needed to complete: 30hour
## Credit and Collaborations
<!-- Give credit (and a link) to other people or resources that helped you build this application. -->

![image](img.png)


text:
# T1069.001 - Permission Groups Discovery: Local Groups
## [Description from ATT&CK](https://attack.mitre.org/techniques/T1069/001)

Adversaries may attempt to find local system groups and permission settings. The knowledge of local system permission groups can help adversaries determine which groups exist and which users belong to a particular group. Adversaries may use this information to determine which users have elevated permissions, such as the users found within the local administrators group.

Commands such as net localgroup of the [Net](https://attack.mitre.org/software/S0039) utility, dscl . -list /Groups on macOS, and groups on Linux can list local groups.

## Atomic Tests

- [Atomic Test #1 - Permission Groups Discovery (Local)](#atomic-test-1---permission-groups-discovery-local)

- [Atomic Test #2 - Basic Permission Groups Discovery Windows (Local)](#atomic-test-2---basic-permission-groups-discovery-windows-local)

- [Atomic Test #3 - Permission Groups Discovery PowerShell (Local)](#atomic-test-3---permission-groups-discovery-powershell-local)

- [Atomic Test #4 - SharpHound3 - LocalAdmin](#atomic-test-4---sharphound3---localadmin)

- [Atomic Test #5 - Wmic Group Discovery](#atomic-test-5---wmic-group-discovery)

- [Atomic Test #6 - WMIObject Group Discovery](#atomic-test-6---wmiobject-group-discovery)

- [Atomic Test #7 - Permission Groups Discovery for Containers- Local Groups](#atomic-test-7---permission-groups-discovery-for-containers--local-groups)

## Atomic Test #1 - Permission Groups Discovery (Local)
Permission Groups Discovery

**Supported Platforms:** macOS, Linux

**auto_generated_guid:** 952931a4-af0b-4335-bbbe-73c8c5b327ae

#### Attack Commands: Run with `sh`!

```sh
if [ -x "$(command -v dscacheutil)" ]; then dscacheutil -q group; else echo "dscacheutil is missing from the machine. skipping..."; fi;
if [ -x "$(command -v dscl)" ]; then dscl . -list /Groups; else echo "dscl is missing from the machine. skipping..."; fi;
if [ -x "$(command -v groups)" ]; then groups; else echo "groups is missing from the machine. skipping..."; fi;
if [ -x "$(command -v id)" ]; then id; else echo "id is missing from the machine. skipping..."; fi;
if [ -x "$(command -v getent)" ]; then getent group; else echo "getent is missing from the machine. skipping..."; fi;
cat /etc/group
```

## Atomic Test #2 - Basic Permission Groups Discovery Windows (Local)
Basic Permission Groups Discovery for Windows. This test will display some errors if run on a computer not connected to a domain. Upon execution, domain
information will be displayed.

**Supported Platforms:** Windows

**auto_generated_guid:** 1f454dd6-e134-44df-bebb-67de70fb6cd8

#### Attack Commands: Run with `command_prompt`!

```cmd
net localgroup
net localgroup "Administrators"
```

## Atomic Test #3 - Permission Groups Discovery PowerShell (Local)
Permission Groups Discovery utilizing PowerShell. This test will display some errors if run on a computer not connected to a domain. Upon execution, domain
information will be displayed.

**Supported Platforms:** Windows

**auto_generated_guid:** a580462d-2c19-4bc7-8b9a-57a41b7d3ba4

#### Attack Commands: Run with `powershell`!

```powershell
get-localgroup
Get-LocalGroupMember -Name "Administrators"
```

## Atomic Test #4 - SharpHound3 - LocalAdmin
This module runs the Windows executable of SharpHound in order to remotely list members of the local Administrators group (SAMR)

**Supported Platforms:** Windows

**auto_generated_guid:** e03ada14-0980-4107-aff1-7783b2b59bb1

#### Inputs:
| Name | Description | Type | Default Value |
|------|-------------|------|---------------|
| domain | FQDN of the targeted domain | string | $env:UserDnsDomain|
| sharphound_path | SharpHound Windows executable | path | PathToAtomicsFolder\..\ExternalPayloads\SharpHound.exe|
| output_path | Output for SharpHound | path | $env:TEMP\SharpHound\|

#### Attack Commands: Run with `powershell`!

```powershell
New-Item -Path "#{output_path}" -ItemType Directory > $null
& "#{sharphound_path}" -d "#{domain}" --CollectionMethod LocalAdmin --NoSaveCache --OutputDirectory "#{output_path}"
```

#### Cleanup Commands:
```powershell
Remove-Item -Recurse #{output_path} -ErrorAction Ignore
```

#### Dependencies:  Run with `powershell`!
##### Description: SharpHound binary must exist on disk and at specified location (#{sharphound_path}).
And the computer must be domain joined (implicit authentication).
##### Check Prereq Commands:
```powershell
if (Test-Path "#{sharphound_path}") { exit 0 } else { exit 1 }
```
##### Get Prereq Commands:
```powershell
New-Item -Type Directory "PathToAtomicsFolder\..\ExternalPayloads\" -ErrorAction Ignore -Force | Out-Null
Invoke-WebRequest "https://github.com/BloodHoundAD/BloodHound/blob/e062fe73d73c015dccb37fae5089342d009b84b8/Collectors/SharpHound.exe?raw=true" -OutFile "#{sharphound_path}"
```

## Atomic Test #5 - Wmic Group Discovery
Utilizing wmic.exe to enumerate groups on the local system. Upon execution, information will be displayed of local groups on system.

**Supported Platforms:** Windows

**auto_generated_guid:** 7413be50-be8e-430f-ad4d-07bf197884b2

#### Attack Commands: Run with `powershell`!

```powershell
wmic.exe group get name
```

## Atomic Test #6 - WMIObject Group Discovery
Utilizing PowerShell cmdlet - get-wmiobject, to enumerate local groups on the endpoint. Upon execution, Upon execution, information will be displayed of local groups on system.

**Supported Platforms:** Windows

**auto_generated_guid:** 69119e58-96db-4110-ad27-954e48f3bb13

#### Attack Commands: Run with `powershell`!

```powershell
Get-WMIObject Win32_Group
```

## Atomic Test #7 - Permission Groups Discovery for Containers- Local Groups
Attackers may try to obtain a list of services that are operating on remote hosts and local network infrastructure devices, in order to identify potential vulnerabilities that can be exploited through remote software attacks. They typically use tools to conduct port and vulnerability scans in order to obtain this information.

##### Description: Verify docker is installed.
##### Check Prereq Commands:
```sh
which docker
```
##### Get Prereq Commands:
```sh
if [ "" == "`which docker`" ]; then echo "Docker Not Found"; if [ -n "`which apt-get`" ]; then sudo apt-get -y install docker ; elif [ -n "`which yum`" ]; then sudo yum -y install docker ; fi ; else echo "Docker installed"; fi
```
##### Description: Verify docker service is running.
##### Check Prereq Commands:
```sh
sudo systemctl status docker  --no-pager
```
##### Get Prereq Commands:
```sh
sudo systemctl start docker
```

repository: redcanaryco/atomic-red-team

gha_language: C

repo_name: redcanaryco/atomic-red-team


text:
# Releasing

* Update `version.rb` file accordingly.
* Update `CHANGELOG.md` file.
* Update `Gemfile.lock` file via running `bundle install`.
* Build and publish (and verify that everything ok):

```bash
bundle exec rake build
gem push *built_file*
```
* Tag the release: `git tag vVERSION`.
* Push changes: `git push --tags`.
* Update the release notes on GitHub.com.
* Announce the new release,
   making sure to say "thank you" to the contributors
   who helped shape this version!

repository: texpert/datarockets-style

repo_name: texpert/datarockets-style


text:
# employee-db
![{data.license}](https://shields.io/badge/license-MIT-green)

## Description

Employee-db is an easy to use CLI application for anyone to interact with and make changes. This Content Management System provides access to manage a company's employee database using NodeJS, Inquirer and MySQL.

## Content

* [GitHub Repository](https://github.com/Rudy-Menjivar/employee-db/)

* [Demo](#video-demo)

* [Installation](#installation)

* [Usage](#usage)

* [Contributing](#contributing)

* [Questions](#questions)

## Video-Demo

## Installation

Run the following command to install the required dependencies:
```
npm install
```

## Usage

Run this command to invoke this application:
```
node server.js
```

## Contributing

Any community contributions will help in achieving this project's success, so any help is greatly appreciated.

To participate in this project, please review the following guidelines:

1. Create a branch for your update (after forking and cloning)

   `git checkout -b <branchName>`

2. Make changes or additions to new or existing file & stage it

   `git add <fileName.ext>`

3. Commit your file by adding comments about code enhancements

   `git commmit -m <your code comments>`

4. Push your changes with your remote branch name

   `git push -u origin <branchName>`

5. Finally, submit [feature requests and bugs](https://github.com/Rudy-Menjivar/employee-db/issues) and open a [pull request](https://github.com/Rudy-Menjivar/employee-db/pulls)

## License

Copyright (c) Rudy-Menjivar. All rights reserved.

Licensed under the [MIT](./LICENSE.txt) license.

## Questions

If you have any questions then feel free to contact me, and you can find my complete work at GitHub.
-<EMAIL_ADDRESS>- [GitHub](https://github.com/Rudy-Menjivar)

repository: Rudy-Menjivar/employee-db

repo_name: Rudy-Menjivar/employee-db


text:
# mkdocs-cms
Integration of Netlify-CMS with MkDocs.
You can try it with this one click deploy button.


text:
---
title: "Visualizing a CNN"
draft: false
weight: 16
katex: true
---

### Visualizing What our Layers are Learning
- In order to implement neural style transfer, we need to evaluate the features at various layers in our convolutional network
- In order to do this, we can visualize what our layers (and neurons) are actually learning
- To do this, we should:
        1. Train a network
        2. Pick a unit in each layer
        3. Find the nine image patches that maximize the unit's activations
- In other words, we should find the region of an image that maximize the activations returned by a particular neuron
- This will help us in understand what each neuron is actually learning
- As a reminder, the deeper layers will learn more specific details about an image
- On the other hand, the shallow layers will learn more generalized information about the image
- This is because neural networks learn moving from the back of the network to the front of the network (i.e. backward propagation)
- In other words, a convolutional network breaks the image down moving from higher level to lower level layers

### Describing Visualize
- define feature map
- visualizing network using max activations
- visualizing network using mean activations

---

### tldr

---

### References
- [Paper about Visualizing Convolutional Networks](https://arxiv.org/pdf/1311.2901.pdf)
- [Video about Visualizing Convolutional Networks](https://www.youtube.com/watch?v=ghEmQSxT6tw)
- [Visualizing Convolutional Networks using Mean Activations](https://towardsdatascience.com/how-to-visualize-convolutional-features-in-40-lines-of-code-70b7d87b0030)
- [Visualizing Convolutional Networks using Max Activations](https://www.youtube.com/watch?v=ChoV5h7tw5A&list=PLkDaE6sCZn6Gl29AoE31iwdVwSG-KnDzF&index=38)


text:
## Authorization workflow endpoints diagrams

These are diagrams about how the application is authorizing to an user. They are not all endpoint using in this project, only the  authorization

### Add a user
It's used to sign up component after create a user and returns a user id and a token

### Request a token
It's used for request ta new token when a user have log out the application. Use in Log In component

### Get Spotify token
It's used to:

- Get in search component
- Get all user artists
- Get popular artist tracks

**Note:** The application is getting a new token after each call to the endpoint

## Check valid token

After the application is closed and we open again we have to check if the token on this application is still valid, because this token could be damaged or could have been expired (valid for only 24h)

branch_name: refs/heads/develop


text:
# Twitch Chat Statistics

Do you stream on Twitch? Did you ever want to know how many viewers in your chat are followers? Well, wonder no longer!

## Runtime Requirements

* Java JDK 1.7

## Running it (the easy way)

* Download the latest release zip on Github [here](https://github.com/mgway/chatstat/releases)
* Extract the contents of the zip file

#### Windows
* Run the `run-chatstat.bat` file to start the application
  * If you're wary of random batch files, follow these steps:
    * Shift + right click in the Explorer window containing the extracted files
    * Select "Open command window here"
    * Type "java -jar twitch-chatstat" and then hit tab to autocomplete the rest of the file name
    * It should look like `java -jar twitch-chatstat-0.3.jar`, with potentially different numbers at the end
    * Hit enter to run the application
* Browse to [http://localhost:8080](http://localhost:8080) to see the application
* When you're done with the app, press ctrl+c and then 'y' in the command window for a graceful shutdown, or click the normal close button if you just don't care

#### Linux/OS X
* Open a terminal window and navigate to where you extracted the zip
* Type "java -jar twitch-chatstat" and then hit tab to autocomplete the rest of the file name
  * It should look like `java -jar twitch-chatstat-0.1.jar`, with potentially different numbers at the end
* Hit enter to run it
* Browse to [http://localhost:8080](http://localhost:8080) to see the application
* When you're done with the app, press ctrl+c in that terminal window

## Uncommon Problems
* The JAR is executable, so double clicking it on Windows or OS X will run the application in console-less mode
  * Everything will work as expected in this mode, just be aware that you'll have to kill the application via task manager when you're done
* There is some sort of error about a database in the console?
  * Delete the one (or more) .db files in the application directory. If that doesn't work, submit an issue to this project on GitHub

## Development Requirements

* Maven 3.0+
* Squirrel SQL is useful, but not required

## Building it

* Clone from github
* Run `mvn install`
* Run `mvn spring-boot:run`
* Browse to http://localhost:8080
* Good luck

## To Do/Forthcoming Features
* Subscriber counts
* Flexible retry intervals
* Less noisy viewer count updates

Have a feature idea? While it would be super cool if you could go ahead and implement it yourself and then send me a pull request,
I'll also be watching the [issues tracker](https://github.com/mgway/chatstat/issues) on GitHub for feature requests

repository: mgway/chatstat

repo_name: mgway/chatstat


text:
---
title: "Build and Push the Docker Image"
chapter: false
weight: 52
pre: "<b>5.2 </b>"
---

We will now build a Docker image with our NPM package and publish the image to our JFrog Artifactory repository.

![JFrog Docker Logo](/images/docker-logo.png)

![JFrog CLI Docker](/images/jfrog-cli-docker.svg)

1. Return to your Cloud9 terminal. Let's create a Docker image for our NPM application. Let's create an environment variable for our image name. Substitute your _server name_ in the following command.

``
export image_name=<server name>.jfrog.io/docker-demo/npm-app:latest
``

2. Now let's build a docker image with the following command.

``
docker build -t $image_name .
``

This command should result in a successful Docker image build.
![Docker Build](/images/docker-build.png)

{{%expand "Docker rate limit policies! Artifactory can help!" %}}
Docker Hub has set a new limit on data transfer beginning November 1st for free accounts: 100 pulls for anonymous users and 200 pulls for authenticated/free users for every 6 hours per IP address or a unique user.

Artifactory can protect you from this by proxying and caching images! This reduces the number of pulls from Docker Hub.

![Docker Remote](/images/docker-remote.png)
.{{% /expand%}}

3. Now use the JFrog CLI to push the docker image.

``
jfrog rt docker-push $image_name docker-demo --build-name=npm_build --build-number=1
``

4. Now trigger a Xray scan of the build.

``
jfrog rt build-scan npm_build 1
``

This command should result in successful scanning.
![Xray Scan](/images/xray-scan.png)

5. If our build passes the Xray scan, we can promote it with the following command. This promotes from the _dev_ repository to the _prod_ repository. Substitute your _server name_ in the following command.

``
jfrog rt docker-promote npm-app docker-demo-dev-local docker-demo-prod-local --copy
``

{{%expand "Review what we have done." %}}
![Docker Review](/images/docker-review.png)
.{{% /expand%}}

6. In your JFrog Platform instance, go to **Artifactory** ► **Artifacts** to see this in the docker repositories.

![Promote](/images/promote.png)

repository: jfrog/aws-ecs-docker-compose-workshop

repo_name: jfrog/aws-ecs-docker-compose-workshop


text:
# ( [[Style-Visual-Arts-2020]])

In the visual arts , style is a "...distinctive manner which permits the grouping of works into related categories"[1] or "...any distinctive, and therefore recognizable, way in which an act is performed or an artifact made or ought to be performed and made". [2]

# ( [[Woodfield-1994]])

We see here how little style is determined by observations of nature alone, and that it is always decorative principles, convictions of taste, to which the last decision is assigned. 19

^19 Wölfflin, Kunstgeschichteliche Grundbe griffe (1915), trans. M. D. Hottinger as Principles of Art History (London, 1932), p. 51.

repository: guillaumedescoteauxisabelle/ma-biblio

repo_name: guillaumedescoteauxisabelle/ma-biblio