text:
# Getting Started with _ShopBridge_ Project

This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).

ShopBridge is an e-commerce application that offers basic CRUD functionalities to help manage ítems. It can be tested at https://shopbapi-2cbf8.web.app/

## Testing Locally

In order to run it, pull this repository and go to main folder. Be sure you're using Node.js version 14 (specific version used for this Project was **14.17.5**  [NVM node manager.](https://github.com/nvm-sh/nvm)) Inside the project directory `shopbridge/`, run the following commands to install dependencies:

### `npm install`

After installing dependencies, run the app in the development mode with:

### `npm start`

In the console, you should see:

Ignore the warning, it's a little React trick.

Open [http://localhost:3000](http://localhost:3000) to view it in the browser. If changes are made to the app code, the page will reload.

## About the Project

The main files are as follows:

`src/` folder that contains the main files of the project
`public/` react offers this folder to contain static files. If we look inside this folder, we have the index.html which is the main file and a set of files that are related to it.
`package.json`

Inside `src/` we can observe multiple files such as `index.js, App.js and index.css`. The first one is the most important one, it takes the `App.js` file that contains the whole application and renders it into the `index.html`. \
On the other hand, `index.css`, implements global styles.

Other Important folders are:

`api/`: contains necessary instructions to use the firebase api.
`components/`: all the necessary components that make up the app
`images/` images of the items
`pages/` following best practices, every route should have its own file
`store/` files to construct a global state in react
`styles/` contains all styles for each component or page
`test/` all implemented tests.

## Dependencies

Project was made using `create-react-app`, an easy, simple way to start building a React application, without manually using builder tools like webpack. Of course, webpack, Babel, ESLint, etc. are used on the background.

`firebase` is the only extra dependency used, for API connection purposes.

## Styles

The applied styles are largely hand-made. React comes with a utility to use _css modules_, in order to avoid global styles, so styles are scoped. Only `index.css` contains global styles.

## Testing

Project uses `Jest` and `React testing Library` for testing, these come together in `create-react-app` \
To run tests just type the follow command:

### `npm test`

Launches the test runner in the interactive watch mode. \
If a menu of options is showed, then just press key `a` to run all the tests:

At the end, a message like this should be shown:

### Coverage

To check current test coverage run:

### `npm run test:coverage`

This will execute all test and then create a report with the coverage data. A table summarizing all coverage is show in the console. After executing tests, a `coverage/` folder will be created in the root folder, cointaining an `html` file that shows test information in a more detailed manner.

Coverage for the current version of the App:

`index.js` and `reportWebVitals.js` are files which don't need to be tested. They are included in the testing process and lower the score, though. This can be avoided by excluding them via `jest.config.js`file

## Deploy

To deploy React applications we need a Static Site Host. Given that React it's used to create a SPA, its build generates static files which don’t need a resource that offers server side code. First, we need to create a build of our application by using:

### `npm run build`

This will build the app for production and create a `build` folder as shown in the image. With this, the app is ready to be deployed. Of course, depending on the hosting choice, there'll be a way to add the build folder to it and serve the application.

> Note: build folder is included in .gitignore since it can be generated.

### Deploy to Firebase

This app is being served on firebase at https://shopbapi-2cbf8.web.app/ you can test its functionality there.
There are some files in root that are used to deploy on Firebase.
- `firebase.json` and `.firebaserc` are files generated by _firebase-cli_ to access Firebase services.
- `.github/workflows`: contains the `firebase.yml` to define deployment steps.

Firebase hosting, database, and firestore (to serve images) are being used in this project and deployment process to firebase hosting is triggered by GitHub actions.

### Dockerfile

Another option is to use a Dockerfile, since services as GCP or AZURE used container registry, we can deploy this application wrapping it into an image ready to be served.

- `Dockerfile` file show all the instructions necessary to build an image with the application in production mode.
- `nginx` folder is needed since in it there is a file to configure nginx to allow SPA applications to handle routes.

We can test it locally by executing:

### `docker build -t image-name .`

and then:

### `docker run -d -it -p 80:80/tcp --name rimage-name:latest`

Local server must be running at localhost.

## Time spent

The project took 5 days to complete, as it was started on Saturday afternoon, using 8 hours a day on average.
Four aspects are to be taken into account:

- Frontend functionality
- Frontend presentational aspects (styling, DOM, etc)
- Required Validations
- Unit Test Coverage

It’s quite complicated to give an exact amount of time spent in the project since things are made on the go, but a likely breakout could be:

### To improve

- While I the current CSS and styling, I have to recognize that It took me quite a while to achieve the styles used in the project. For testing purposes, I think it would have been better to use a library with styled components like [Reactstrap] (https://reactstrap.github.io/) that would have saved quite a bit of time.
- Testing was quite challenging but interesting as well.

repository: esneidermanzano/shopbridge

repo_name: esneidermanzano/shopbridge


text:
# Making a Galata Release

1. Bump the Galata version in [packages/galata/package.json](packages/galata/package.json). Also update example project's Galata dependency version to match, in [packages/galata-example/package.json](packages/galata-example/package.json).

    Galata package needs to be versioned with the same major, minor and patch versions as the JupyterLab it is made for. For example, if Galata is based on JupyterLab 3.0.1, a valid Galata version is 3.0.1-1 to 3.0.1-n. This version matching is enforced before Galata packages are published.

    JupyterLab version, that Galata is made for, is determined by  `@jupyterlab/application` dependency version in the [yarn.lock](yarn.lock). If the JupyterLab version is not changing with the new Galata release then only increment the release number after `-` (for example `3.0.1-2` to `3.0.1-3`). However, if JupyterLab version is changing with the new Galata release then reset the release number after `-` to 1 (for example `3.0.1-3` to `3.0.2-1`).

2. Re-install dependencies and rebuild.

```
yarn
yarn run build
```

3. Run tests and make sure that all pass. Before running tests, JupyterLab must be up and running. You can use the launch command described in `Launch JupyterLab` section of [README.md](README.md#launch-jupyterlab)

```
yarn run test
```

4. Commit your version changes.

5. Once version update is in the `main` branch, publish a new release on GitHub (https://github.com/jupyterlab/galata/releases) with the list of changes in the description.

6. Pull latest of `main` branch and publish npm package to npm registry. You will need an npmjs.org account to be able to publish this package.

```
cd packages/galata
npm login --registry https://registry.npmjs.org
npm publish
```

repository: jupyterlab/galata

branch_name: refs/heads/main

extension: md

gha_language: JavaScript

license_type: permissive

repo_name: jupyterlab/galata


text:
Dockerfile for SonarQube 4.4
============

Dockerfile to create [SonarQube](http://www.sonarqube.org/) 4.4 server with existing MySQL server.

### Normal container
Use the `Dockerfile` to build an image. Run the container with environment variables, `DB_USERNAME`, `DB_PASSWORD` and `DB_URL`. A database `sonar` should be created first on the MySQL server.

Example command line to run:

```bash
docker run -i -t -e DB_USERNAME=sonar -e DB_PASSWORD=password -e DB_URL=mysqlserver:3306 -p 80:9000 <Image ID>
```

Then you can access `http://localhost` to use Sonar.

### AWS Elastic Beanstalk

If you want to run SonarQube on [AWS Elastic Beanstalk](http://aws.amazon.com/elasticbeanstalk/), you need to specify values of environment variables `DB_USERNAME`, `DB_PASSWORD` and `DB_URL` in Beanstalk console. Refer to [here](http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_docker.container.console.html) for more details.

It's better that package the `Dockerfile` and `Dockerrun.aws.json` in a zip file and use it.

license: MIT

branch_name: refs/heads/master


text:
![Snyk logo](https://snyk.io/style/asset/logo/snyk-print.svg)

***

Snyk helps you find, fix and monitor for known vulnerabilities in your dependencies, both on an ad hoc basis and as part of your CI (Build) system.

## Snyk Paket Parser

This parser processes a `paket.lock` and returns a flat list of dependencies.

#### For example:
Input `paket.lock`:
```
  Microsoft.CSharp (4.5) - restriction: || (&& (< net20) (>= netstandard1.0) (< netstandard1.3)) (&& (< net20) (>= netstandard1.3) (< netstandard2.0))
```

Output:
```
  [
    { name: 'Microsoft.CSharp', version: '4.5' restriction: '|| (&& (< net20) (>= netstandard1.0) (< netstandard1.3)) (&& (< net20) (>= netstandard1.3) (< netstandard2.0))'}
  ]
```

repository: huudangdev/tungtung-chat-platform

gha_license_id: MIT

repo_name: huudangdev/tungtung-chat-platform


text:
# How To Run Inference Using TensorRT C++ API
The blog post is here: https://www.learnopencv.com/how-to-run-inference-using-tensorrt-c-api/

### To run PyTorch part:
```shell script
python3 -m pip install -r requirements.txt
python3 pytorch_model.py
```

### To run TensorRT part:
1. Install [CMake](https://cmake.org/) at least 3.10 version
2. Download and install NVIDIA CUDA 10.0 or later following by official instruction: [link](https://developer.nvidia.com/cuda-10.0-download-archive)
3. Download and extract CuDNN library for your CUDA version (login required): [link](https://developer.nvidia.com/rdp/cudnn-download)
4. Download and extract NVIDIA TensorRT library for your CUDA version (login required): [link](https://developer.nvidia.com/nvidia-tensorrt-6x-download). The minimum required version is <IP_ADDRESS>
5. Add the path to CUDA, TensorRT, CuDNN to PATH variable (or LD_LIBRARY_PATH)
6. Build or install a pre-built version of OpenCV and OpenCV Contrib. The minimum required version is 4.0.0.

```shell script
mkdir build
cd build
cmake -DOpenCV_DIR=[path-to-opencv-build] -DTensorRT_DIR=[path-to-tensorrt] ..
make -j8
trt_sample[.exe] resnet50.onnx turkish_coffee.jpg
```

# AI Courses by OpenCV

Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.


text:
node-red-node-group
===================

A Node-RED node to allow flows containing groups to be imported into older versions
of Node-RED.

The ability to create groups was introduced in Node-RED 1.1.0, adding a new core
node type called `group`.

This module provides its own `group` node type that can be installed into older
versions of Node-RED to allow them to run flows containing that type.

It does *not* provide any group-like functionality - it *only* registers a
placeholder `group` node type.

The module will only register the type if it detects it is being loaded into
Node-RED 1.0.x or older, otherwise it does nothing.

Install
-------

Run the following command in your Node-RED user directory - typically `~/.node-red`

    npm i node-red-node-group

repository: node-red/node-red-nodes

gha_license_id: NOASSERTION

repo_name: node-red/node-red-nodes


text:
![Docker & Nginx](https://cloud.githubusercontent.com/assets/6241518/4104908/424e46f8-319b-11e4-9a2e-49a8cc49951c.jpg)

**docker-nginx** is a CentOS-based docker container for [Nginx](http://nginx.org). It is intended for use with [dylanlindgren/docker-phpfpm](https://github.com/dylanlindgren/docker-phpfpm).

Nginx 1.6.1 is compiled from source with the below modules enabled:
- http_gzip_static_module
- http_stub_status_module
- http_ssl_module - for HTTPS support
- http_spdy_module
- pcre
- http_image_filter_module
- file-aio
- ipv6
- http_dav_module
- http_flv_module
- http_mp4_module
- http_gunzip_module
- [spnego-http-auth-nginx-module](https://github.com/stnoonan/spnego-http-auth-nginx-module) - for Kerberos authentication

## Getting the image
This image is published in the [Docker Hub](https://registry.hub.docker.com/u/dylanlindgren/docker-nginx/). Simply run the below command to get it on your machine:

```bash
docker pull dylanlindgren/docker-nginx
```
Alternatively you can clone this repository and build the image using the `docker build` command.
## Nginx site config and www data
All site and log data is configured to be located in a Docker volume so that it is persistent and can be shared by other containers (such as [PHP-FPM](https://github.com/dylanlindgren/docker-phpfpm), or a backup container).

There are two volumes defined in this image:

- `/data/nginx/www`
- `/data/nginx/config`

Within these folders this image expects the below directory structure:
```
/data
└────nginx
     ├─── www
     |    ├─── website1_files
     |    |    └  ...
     |    └─── website2_files
     |         └  ...
     └─── config
          ├─── logs
          |    └  ...
          └─── sites
               ├─── available
               |    |  website1
               |    |  website2
               |    └  ...
               └─── enabled
                    |  website1_symlink
                    └  ...
```
[PHP-FPM](https://github.com/dylanlindgren/docker-phpfpm) requires access to the `www` directory in the same location as Nginx has it, so instead of mounting `/data/nginx/www` in this container, we will mount it in the PHP-FPM container and use the `--volumes-from` switch (as due to the `--link` command the PHP-FPM container needs to be run first anyway).

The `available` and `enabled` directories under `/data/nginx/config/sites` both operate in the same fashion as the regular `sites-available` and `sites-enabled` directories in Nginx - that is, put your website config files all in the `available` directory and create symlinks to these files in the `enabled` directory with the below command (after `cd`ing into the `enabled` directory).
```bash
ln -s ../available/website1 website1
```

Each of the files under the `/data/nginx/config/sites/available` directory should contain a definition for a Nginx server. For example:
```
server {
    listen       80;
    server_name  www.website1.com;
    root              /data/www/website1_files/public;

    location ~* \.(html|jpg|jpeg|gif|png|css|js|ico|xml)$ {
        access_log        off;
        log_not_found     off;
        expires           360d;
    }

    location ~* \.php$ {
        include fastcgi.conf;
        fastcgi_pass phpfpm_backend;
    }
}
```

## Creating and running the container
**NOTE:** a container based on [dylanlindgren/docker-phpfpm](https://github.com/dylanlindgren/docker-phpfpm) must be created before running the below steps. In the below commands, this container is referred to as `phpfpm`.

To create and run the container:
```bash
docker run --privileged=true -p 80:80 -p 443:443 --name nginx -v /data/nginx/config:/data/nginx/config:rw --volumes-from phpfpm --link phpfpm:fpm -d dylanlindgren/docker-nginx
```
 - the first `-p` maps the container's port 80 to port 80 on the host, the second maps the container's 443 to the hosts 443.
 - `--name` sets the name of the container (useful when starting/stopping).
 - `-v` maps the `/data/nginx/config` folder as read/write (rw).
 - `--volumes-from`  gets volumes from the `phpfpm` container (it should have `/data/nginx/www` mapped)
 - `--link` allows this container and the `phpfpm` container to talk to each other over IP.
 - `-d` runs the container as a daemon

To stop the container:
```bash
docker stop nginx
```

To start the container again:
```bash
docker start nginx
```
### Running as a Systemd service
To run this container as a service on a [Systemd](http://www.freedesktop.org/wiki/Software/systemd/) based distro (e.g. CentOS 7), create a unit file under `/etc/systemd/system` called `nginx.service` with the below contents
```bash
[Unit]
Description=Nginx Docker container (dylanlindgren/docker-nginx)
After=docker.service
After=phpfpm.service
Requires=docker.service
Requires=phpfpm.service

[Service]
TimeoutStartSec=0
ExecStartPre=-/usr/bin/docker stop nginx
ExecStartPre=-/usr/bin/docker rm nginx
ExecStartPre=-/usr/bin/docker pull dylanlindgren/docker-nginx
ExecStart=/usr/bin/docker run --privileged=true -p 80:80 -p 443:443 --name nginx -v /data/nginx/config:/data/nginx/config:rw --volumes-from phpfpm --link phpfpm:fpm dylanlindgren/docker-nginx
ExecStop=/usr/bin/docker stop nginx

[Install]
WantedBy=multi-user.target
```
Then you can start/stop/restart the container with the regular Systemd commands e.g. `systemctl start nginx.service`.

To automatically start the container when you restart enable the unit file with the command `systemctl enable nginx.service`.

Something to note is that this service is set to require `phpfpm.service` which is a service which runs the php-fpm container made with  [dylanlindgren/docker-phpfpm](https://github.com/dylanlindgren/docker-phpfpm).

## Acknowledgements
The below pages were very useful in the creation of both of these projects.

 - [enalean.com](http://www.enalean.com/en/Deploy-%20PHP-app-Docker-Nginx-FPM-CentOSSCL)
 - [stage1.io](http://stage1.io/blog/making-docker-containers-communicate/)
 - [coreos.com](https://coreos.com/docs/launching-containers/launching/getting-started-with-systemd/)
 - [spnego-http-auth-nginx-module](https://github.com/stnoonan/spnego-http-auth-nginx-module)
 - [Pitfalls - Nginx Community](http://wiki.nginx.org/Pitfalls)

repository: aya/docker-nginx

repo_name: aya/docker-nginx


text:
# NodeJS & PostgreSQL API REST with ORM Sequelize

![](https://res.cloudinary.com/cozyplace/image/upload/v1624047478/maxresdefault_cyc4nl.jpg)

Creation of REST API with Node.js and Express.js as main technologies in the backend, this api connects to a PostgreSQL database that should be hosted on your localhost with the name of Desarrollos, the backend interacts with the database through an ORM in this case Sequelize was used

## Things that you need: Things
 * NodeJS
 * ExpressJS
 * PostgresSQL
 * Sequelize
 * Babel

## Configuration 🔧
This project requires a .env file for its operation, the only thing it requires is that you initialize a port where you want the project to run, for example PORT = 5000

## Installation 🔧
npm install

### Command to run on dev mode
npm run dev

## Contributing ✒
Pull requests are welcome !. And if you have an idea for a feature and dont have time to do this, feel free to open an issue!

## License 📄
[MIT] (https://choosealicense.com/licenses/mit/)

repository: orlandCasta/PostgreSQL-Sequelize-NodeJS

repo_name: orlandCasta/PostgreSQL-Sequelize-NodeJS


text:
Title: Avalonia
Order: 100
---

<iframe width="560" height="315" src="https://www.youtube.com/embed/q6uWPtKw3UQ" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

# Package Installation

Please note that the ReactiveUI support for [Avalonia](https://avaloniaui.net/) is provided directly by that team. See them for any support questions.

Assuming the following project structure:

```
- MyCoolApp (netstandard library)
- MyCoolApp.Avalonia (application)
- MyCoolApp.UnitTests (tests)
```

* Install `ReactiveUI` into your netstandard libraries, application and tests.
* Install `Avalonia.ReactiveUI` into your application and add `.UseReactiveUI()` to your AppBuilder.
* Install `ReactiveUI.Testing` into your tests.

repository: reactiveui/website

gha_language: HTML

repo_name: reactiveui/website


text:
---
layout: post
title: hydrogeolog update
---

1. learning from TMA9548 i2c multiplexer

it is found that if all the sensors connected to 9548 are not powered at the same time,
9548 may become disfunctional if it attempts to read from sensors. such disfunctional phenomenon persists even if arduino is restarted. the only way to recover is to power off 9548 and back on.
the way of getting around this is switch on all the sensors before reading, and switched them off all once. one could also connect reset (5v) to downside switch, or simply do a power control

2. wish list form V2
   a.more leg holes for supporting the board
   b.reset arduino, and use onboard tx and rx to communicate between pi and arduino. it is preferred to provide a jumper for this function.
   c.reverse switch for pi (use ), 5V reverse switch,  12V reverse switch
   d.more nikkel area for the terminal block
   e.switch for voltage in switch
   f.more detail comments for pin holes
   g.reducing the size of the board
   h.commoning bolck to be affiliated to anything on default
   i.reducing the width of the leads track
   k.enlarge the gap between transistor pad
   j.analog 12 is not functional............
   m.making sure all rpi output pins have specific interface.
   n.labelling the system
   o.assessing if selected mosfet are proper for the functions
   p.giving ample space to be able to install either raspberry pi and raspberry pi zero.

3. voltage divide for battery level. TO180914
   we have configured a thrid divider (2000 ohm and 1000 ohm resis). by then voltage was 13.56 on the battery. in between the battery the voltage was 4.18, which gives 1024 from arduino analog 1024 (which is strange as it is supposed to give 1024 when power is 5v)
nevertheless 4.18*3 is 12.54, which is not 13.56 anyway. it is not clear for now why this had happened but as a power divider, one should use a quiter divide ratehr than a third for arduino.

4. wish list for version 3
    surface mounting.


text:
# BME280 Library

By: Michael Burmeister

Language: C

Created: Apr 15, 2018

Modified: May 1, 2019

This is a library written in C that commuicates with the BME280 sensor from Adafruits.

The library uses i2c to communicate with the sensor and provides Temperature, Humidity, and Barametric pressure.

This sensor requires a lot of math to built the data for these sensors and doing this in integer math is complicated.

The library also has a define to use floating point as well.

enjoy

Mike

Updated code so that if the sensor is not found the code would not hang.  Added documentation for functions.

repository: parallaxinc/propeller

gha_language: Propeller Spin

repo_name: parallaxinc/propeller


text:
# Readme

## Introduction

This demo implements a simple web drawing app showing how to use HTML5 Pointer Events. With HTML5 Pointer Events, you can create an app that is compatible on many popular browsers that detect pen ink, mouse, and touch data using a single unified API. HTML5 Pointer Events is supported on most, but not all popular browsers. For those browsers that do not support HTML Pointer Events, one solution is to use the older CSS pointer events API, which is also demonstrated in the app.

To run this application, a Wacom tablet driver must be installed and a supported Wacom tablet must be attached. All Wacom tablets supported by the Wacom driver are supported by this API. Get the driver that supports your device at: https://www.wacom.com/support/product-support/drivers.

When you load the sample code, ScribbleDemo.html, into a browser, you will get a drawing canvas, some simple controls, and a field to look at HTML5 Pointer Events data. The main focus of ScribbleDemo.html is, of course, to scribble with pen ink, touch or mouse data. Pen and touch-enabled Wacom tablets provide pen ink data and touch data that includes properties that are used to modify the drawing strokes.

## Application Details

The HTML5 Pointer Events app supports the following:

- Drawing with pen, touch and mouse input
- Detection of whether the browser you're using supports HTML5 Pointer Events
- Using pen pressure to modify pen strokes
- Using pen tilt to modify pen strokes
- Setting pen color (primary for pen tip, secondary for pen button press)
- A debug monitor that shows input data
- Saving the drawing to a png file

The following illustrates the demo running on Chrome:

![ScribbleDemo](./Media/sc-rm-sdupe-demo.png)
| # |Description |
|:-----:|:------------------------------------------------------|
|![1](./Media/rm_1.png)|Indicates the browser supports HTML5 Pointer Events |
|![2](./Media/rm_2.png) |Selectable Primary pen color |
|![3](./Media/rm_3.png) |Selectable Secondary pen color by pen button selection |
|![4](./Media/rm_4.png) |Pen stroke using tilt |
|![5](./Media/rm_5.png) |Pen stroke using pressure only |
|![6](./Media/rm_6.png) |Touch stroke |
|![7](./Media/rm_7.png) |Mouse stroke |
|![8](./Media/rm_8.png) |Debug window showing pointer data |

## See Also

[Overview](https://developer-docs.wacom.com/intuos-cintiq-business-tablets/docs/web-api-overview) - HTML5 Pointer Events overview

[Basics](https://developer-docs.wacom.com/intuos-cintiq-business-tablets/docs/web-api-basics) - Details on how to start writing HTML5 Pointer Events applications

[Reference](https://developer-docs.wacom.com/intuos-cintiq-business-tablets/docs/web-api-reference) - Information on the HTML5 Pointer Events API

[FAQs](https://developer-support.wacom.com/hc/en-us/articles/12845845085975-Web-API) - HTML5 Pointer Events programming tips

## Where To Get Help

If you have questions about this demo or the Wintab API, please visit our support page: https://developer.wacom.com/developer-dashboard/support

## License

This sample code is licensed under the MIT License: https://choosealicense.com/licenses/mit/

repository: Wacom-Developer/wacom-device-kit-web

repo_name: Wacom-Developer/wacom-device-kit-web


text:
# GMNet: Graph Matching Network for Large Scale Part Semantic Segmentation in the Wild
Official Tensorflow Implementation for "GMNet: Graph Matching Network for Large Scale Part Semantic Segmentation in the Wild", U. Michieli, E. Borsato, L. Rossi, P. Zanuttigh, ECCV 2020

In this work, we propose a novel framework combining higher object-level context conditioning and part-level spatial relationships to address the semantic segmentation of parts of multiple objects.

To tackle object-level ambiguity, a class-conditioning module is introduced to retain class-level semantics when learning parts-level semantics.
In this way, mid-level features carry also this information prior to the decoding stage.

To tackle part-level ambiguity and localization we propose a novel adjacency graph-based module that aims at matching the relative spatial relationships between ground truth and predicted parts.

The webpage of the paper is [here](https://lttm.dei.unipd.it/paper_data/GMNet/)

The full paper can be downloaded from [here](https://lttm.dei.unipd.it/paper_data/GMNet/Michieli_2020_GMNet.pdf)

The slides and the recordings of the presentation are available:

[1 min slides](https://umbertomichieli.github.io/download/slides/slides_2020_ECCV_short.pdf)

[1 min talk](https://www.youtube.com/watch?v=c_NBnVCOVSk)

[10 min slides](https://umbertomichieli.github.io/download/slides/slides_2020_ECCV_long.pdf)

[10 min talk](https://www.youtube.com/watch?v=frdEmvLaUVw)

![teaser](eccv_architecture.png)

![teaser](graph_matching.png)

# Requirements and Installation

This repository uses Python 3.x and Tensorflow 1.13 (TF 1.10 - 1.15 should work just well)

The code is built upon the official implementation of the [Deeplab architecture](https://github.com/tensorflow/models/tree/master/research/deeplab).
We refer to their [installation guidelines](https://github.com/tensorflow/models/blob/master/research/deeplab/g3doc/installation.md).

In particular remember to export the python path back to (assuming you are in Deeplab/research/deeplab/):
> export PYTHONPATH=$PYTHONPATH:`pwd`:`pwd`/../../../Deeplab

## Known Issue:

Currently, there is a bug in the part-level tfrecords generation.

**Temporary Workaround:** while the issue is being investigate you can directly download part-level tfrecords from
[here](https://drive.google.com/drive/folders/193qJXouWxtlmp4nU3TgqanRdR_-WqX5h?usp=sharing) and then perform training and evaluation.

## Download data and checkpoints

In this project we used two datasets: Pascal-Part-58 and Pascal-Part-108.

The datasets and some checkpoints of interest are available [here](https://lttm.dei.unipd.it/paper_data/GMNet/data.zip)

## Generate object-level tfrecords
To generate the tfrecords of the Pascal-VOC2012 with 21 classes:

> python -u build_voc2012_data.py \
--image_folder dataset/RGB \
--semantic_segmentation_folder dataset/label21 \
--list_folder dataset \
--output_dir tfrecord_21_classes

NB: all the paths need to be adjusted properly.
For information on the flags, see their helper description.

## Generate object-level softmax maps

Then, we generate object-level softmax maps for object-level conditioning while learning parts.
You may use whatever semantic segmentation network pretrained on object-level classes.
The higher the accuracy at the object level and the more effective will result the guidance.

For convenience, we trained a model on the 21 object-level classes of Pascal and we place it in the archive file downloaded earlier.

For instance, the command to train the complete model (GMNet) on the Pascal-Part-58 is:

> python -u train.py \
--logtostderr \
--train_split train \
--model_variant resnet_v1_101_beta \
--atrous_rates 6 \
--atrous_rates 12 \
--atrous_rates 18 \
--output_stride 16 \
--decoder_output_stride 4 \
--train_crop_size "513,513" \
--base_learning_rate 0.005 \
--train_batch_size 10 \
--training_number_of_steps 50000 \
--dataset pascal_voc_seg_58_parts \
--tf_initial_checkpoint pretrained/imagenet/resnet_v1_101_2018_05_04/model.ckpt \
--train_logdir TRAIN_58_parts \
--dataset_dir tfrecord_58parts_complete \
--model_softmax 1 \
--graph_loss 1 \
--weighted_graph 1 \
--class_dilation_kernel 2 \
--graph_lambda_loss 0.1 \
--graph_loss_type 'mean_squared_error' \
--aux_loss 1 \
--aux_lambda_loss 0.0001 \
1> TRAIN_58_parts.txt 2>&1

## Perform Evaluation and Visualization

The command to evaluate the complete model (GMNet) on the Pascal-Part-58 is:

> python -u eval.py \
--logtostderr \
--eval_split val \
--model_variant resnet_v1_101_beta \
--atrous_rates 6 \
--atrous_rates 12 \
--atrous_rates 18 \
--output_stride 16 \
--decoder_output_stride 4 \
--eval_crop_size "513,513" \
--checkpoint_dir TRAIN_58_parts \
--eval_logdir EVAL_58_parts \
--dataset pascal_voc_seg_58_parts \
--dataset_dir tfrecord_58parts_complete \
--max_number_of_evaluations 1 \
--model_softmax 1 \
1> EVAL_58_parts.txt 2>&1

To visualize the part-level predictions, instead, the command is:

> python -u vis_parts.py \
--logtostderr \
--eval_split val \
--model_variant resnet_v1_101_beta \
--atrous_rates 6 \
--atrous_rates 12 \
--atrous_rates 18 \
--output_stride 16 \
--decoder_output_stride 4 \
--eval_crop_size "513,513" \
--checkpoint_dir TRAIN_58_parts \
--vis_logdir VIS_58_parts \
--dataset pascal_voc_seg_58_parts \
--dataset_dir tfrecord_58parts_softmax \
--max_number_of_evaluations 1 \
--model_softmax 1 \
1> VIS_58_parts.txt 2>&1

## Cite the paper
If you use this repository or you find our work useful, please consider to cite:

       @inProceedings{michieli2020gmnet,
       author = {Michieli, Umberto and Borsato, Edoardo and Rossi, Luca and Zanuttigh, Pietro},
       title  = {GMNet: Graph Matching Network for Large Scale Part Semantic Segmentation in the Wild},
       booktitle = {European Conference on Computer Vision (ECCV)},
       year      = {2020},
       month     = {August}
       }

## Acknowledgments

Our code is derived from the [official Tensorflow implementation of the Deeplab v3](https://github.com/tensorflow/models/tree/master/research/deeplab).

The dataset is derived from the [Pascal-Part](http://roozbehm.info/pascal-parts/pascal-parts.html) proposed in Chen et al., "Detect What You Can: Detecting and Representing Objects using Holistic Models and Body Parts", CVPR 2014.

We also acknowledge the work of Zhao et al. "Multi-class Part Parsing with Joint Boundary-Semantic Awareness", ICCV 2019, for providing the 58 labels split (Pascal-Part-58).

Remember to cite also their work if you use this code.

## License

[Apache License 2.0](LICENSE)


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

### Description

The SpamBam plugin for WordPress allows remote attackers to bypass restrictions and add blog comments by using server-supplied values to calculate a shared key.

### POC

#### Reference
- http://securityreason.com/securityalert/4438

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

repository: trickest/cve

repo_name: trickest/cve


text:
# LaTeX Glossary Entry
This small [Python](https://www.python.org) program creates efficiently a **full LaTeX glossary entry** to your clipboard and command line.

Why doing it by hand when you can do it by code?

The benefit of using a [LaTeX](https://www.latex-project.org) [Glossary](http://tug.ctan.org/macros/latex/contrib/glossaries/glossariesbegin.pdf) is to get abbreviations and their descriptions nicely and automatically structured in your document.

But only with the generated LaTeX-Code, an example is below.

# Run
By running

```
python lge.py "Volume Clipping" "VC" "selectively disables or enables rendering operations inside a \Gls{ri}, which is in practice predominantly the intersection of two or more overlapping objects"
```

a full LaTeX glossary entry as

```
\newglossaryentry{VCG}{
    name={VC},
    description={Volume Clipping (VC) selectively disables or enables rendering operations inside a \Gls{ri}, which is in practice predominantly the intersection of two or more overlapping objects}
}
\newglossaryentry{VC}{
    type=\acronymtype,
    name={VC},
    description={Volume Clipping},
    first={Volume Clipping (VC) \glsadd{VCG}},
    see=[Glossary:]{VCG}
}
```
will be printed on the command line for you to verify the result and also copied to your clipboard for direct pasting.

## Dependencies
Make sure you have Python's `pip` and on Ubuntu `xclip` installed. You can install it on Ubuntu with:

```
sudo apt-get install python-pip xclip
```
and [Pyperclip](https://github.com/asweigart/pyperclip) by running:

```
pip install pyperclip
```
or both with
```
sudo apt-get install python-pip xclip && pip install pyperclip
```

repository: ManuelTS/latexGlossaryEntry

repo_name: ManuelTS/latexGlossaryEntry


text:
## Data Modeling

Data modeling (data modelling) is the process of creating a data model for the data to be stored in a database. ... Data modeling helps in the visual representation of data and enforces business rules, regulatory compliances, and government policies on the data.

### What is Data Modelling?
Data modeling (data modelling) is the process of creating a data model for the data to be stored in a database. This data model is a conceptual representation of Data objects, the associations between different data objects, and the rules. Data modeling helps in the visual representation of data and enforces business rules, regulatory compliances, and government policies on the data. Data Models ensure consistency in naming conventions, default values, semantics, security while ensuring quality of the data.

### Why use Data Model?
The primary goal of using data model are:

- Ensures that all data objects required by the database are accurately represented. Omission of data will lead to creation of faulty reports and produce incorrect results.
- A data model helps design the database at the conceptual, physical and logical levels.
- Data Model structure helps to define the relational tables, primary and foreign keys and stored procedures.
- It provides a clear picture of the base data and can be used by database developers to create a physical database.
- It is also helpful to identify missing and redundant data.
- Though the initial creation of data model is labor and time consuming, in the long run, it makes your IT infrastructure upgrade and maintenance cheaper and faster.

## functional programming

In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions. ... When a pure function is called with some given arguments, it will always return the same result, and cannot be affected by any mutable state or other side effects.

## Object-oriented programming

is a programming paradigm based on the concept of "objects", which can contain data and code: data in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).

A feature of objects is that an object's own procedures can access and often modify the data fields of itself (objects have a notion of this or self). In OOP, computer programs are designed by making them out of objects that interact with one another OOP languages are diverse, but the most popular ones are class-based, meaning that objects are instances of classes, which also determine their types.

Many of the most widely used programming languages (such as C++, Java, Python, etc.) are multi-paradigm and they support object-oriented programming to a greater or lesser degree, typically in combination with imperative, procedural programming. Significant object-oriented languages include: (list order based on TIOBE index) Java, C++, C#, Python, R, PHP, Visual Basic.NET, JavaScript, Ruby, Perl, Object Pascal, Objective-C, Dart, Swift, Scala, Kotlin, Common Lisp, MATLAB, and Smalltalk.

![](https://www3.ntu.edu.sg/home/ehchua/programming/java/images/OOP_Objects.png)

## Continuous Integration (CI)

In software engineering, continuous integration (CI) is the practice of merging all developers' working copies to a shared mainline several times a day Grady Booch first proposed the term CI in his 1991 method although he did not advocate integrating several times a day. Extreme programming (XP) adopted the concept of CI and did advocate integrating more than once per day – perhaps as many as tens of times per day.

![](https://academy.hsoub.com/uploads/monthly_2020_09/continuous-integration-and-continuous-delivery-xenonstack.png.4f492314f1368eb657f3b96a4ab0f91a.png)

url: https://raw.githubusercontent.com/MURADALSHORMAN/reading-notes/1be628b59dc2d8a4592c5f0d02878e44f9989b5d/Code 401 - Advanced Software Development/Read04.md

repository: MURADALSHORMAN/reading-notes

repo_name: MURADALSHORMAN/reading-notes


text:
# Event

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**createdDate** | [**\DateTime**](\DateTime.md) | Gets or sets the UTC-based date and time that this event was created. | [optional]
**detailedMessage** | [**\FrankHouweling\AzureDevOpsClient\Hooks\Model\FormattedEventMessage**](FormattedEventMessage.md) | Gets or sets the detailed message associated with this event. | [optional]
**eventType** | **string** | Gets or sets the type of this event. | [optional]
**id** | **string** | Gets or sets the unique identifier of this event. | [optional]
**message** | [**\FrankHouweling\AzureDevOpsClient\Hooks\Model\FormattedEventMessage**](FormattedEventMessage.md) | Gets or sets the (brief) message associated with this event. | [optional]
**publisherId** | **string** | Gets or sets the identifier of the publisher that raised this event. | [optional]
**resource** | **object** | Gets or sets the data associated with this event. | [optional]
**resourceContainers** | [**map[string,\FrankHouweling\AzureDevOpsClient\Hooks\Model\ResourceContainer]**](ResourceContainer.md) | Gets or sets the resource containers. | [optional]
**resourceVersion** | **string** | Gets or sets the version of the data associated with this event. | [optional]
**sessionToken** | [**\FrankHouweling\AzureDevOpsClient\Hooks\Model\SessionToken**](SessionToken.md) | Gets or sets the Session Token that can be used in further interactions | [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)

repository: thibau-v/AzureDevOpsClient

repo_name: thibau-v/AzureDevOpsClient


text:
# passworld

A share-able password vault powered by microsoft tech

## Hosting

If you want to set this up for yourself, here's how:

+ [deploy this code](https://azuredeploy.net) to a new `web app`, inside a `resource group`
+ visit [portal.azure.com](https://portal.azure.com)
+ create a new `key vault`, inside the `resource group` that was created above
+ navigate to AAD, then App Registrations
+ create an add app (of type web app) - use `https://<yourAzureWebAppName>.azurewebsites.net/auth/callback` for the `sign on url`
+ (optional) register a `replyUrl` for the aad app, allowing return to `localhost:3001/auth/callback` for development
+ edit the manifest of your aad app to include the following under `requiredResourceAccess` as a new entry in the array: ```{
      "resourceAppId": "cfa8b339-82a2-471a-a3c9-0fc0be7a4093",
      "resourceAccess": [
        {
          "id": "f53da476-18e3-4152-8e01-aec403e6edc0",
          "type": "Scope"
        }
      ]
    }``` this allows your application to issue tokens for keyvault on behalf of users
+ add a `key` that your web app will use to authenticate, and copy it's value
+ navigate to the `application settings` for your web app, and paste this value under the key `CLIENT_SECRET`
+ repeat the process, copying the aad app `application id`, and paste it under the key `CLIENT_ID`
+ under the key `REDIRECT_URI`, paste the value entered above, as the aad `replyUrl`
+ under the key `VAULT_URI`, enter the value `<nameOfCreatedKeyVault>.vault.azure.net`
+ (optional) under the key `SESSION_SECRET`, enter some unique value to salt user session keys with
+ (optional) if you know what you're doing, and want to use another openid well known configuration, paste it's uri under the key `IDENTITY_URI`
+ navigate to the `access policies` for your key vault, and add security groups, and/or individuals whom you wish to have access to your passwords -
grant these users `get`, `list`, and `set` secret permissions.
+ direct users to `https://<yourAzureWebAppName>.azurewebsites.net`

### Troubleshooting

#### Authentication fails

AAD is extremely finicky. I found in practice that my aad application was a v1 application, and therefore does not work
with the default `IDENTITY_URI`. I ended up using `https://login.microsoftonline.com/benbengreenier.onmicrosoft.com/.well-known/openid-configuration`
which is a v1 identity provider specfically for my organization. You may have luck using the same (replacing benbengreenier with your org name),
or you might try `https://login.microsoftonline.com/common/.well-known/openid-configuration`.

### AADSTS65005

> Error message: The client application has requested access to resource 'https://vault.azure.net'.
This request has failed because the client has not specified this resource in its requiredResourceAccess list.

This can occur if you haven't correctly allowed aad to issue tokens for keyvault on behalf of users.
See [this SO question](http://stackoverflow.com/questions/30096576/using-adal-for-accessing-the-azure-keyvault-on-behalf-of-a-user/41603433#41603433).

## License

MIT

repository: bengreenier-archive/passworld

repo_name: bengreenier-archive/passworld


text:
---
layout: default
---

# 1996-03-10 - Re: SurfWatch

## Header Data

From<EMAIL_ADDRESS>(Steven Weller)

To<EMAIL_ADDRESS>Message Hash: 3dfa145f43ff67e2347bbacb449662bddbe9e1dfe9c448b8de8176a9caeb5989

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-03-10 03:31:34 UTC

Raw Date: Sun, 10 Mar 1996 11:31:34 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Steven Weller)
Date: Sun, 10 Mar 1996 11:31:34 +0800
To<EMAIL_ADDRESS>Subject: Re: SurfWatch
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>>   I predict that 6 months after the first internet rating system is widely
>> deployed, the largest use of search engines such as altavista will be to
>> look for pages with the most "naughty" ratings.  Perhaps such services will
>> allow text searches for free, but charge for searches based on the rating
>> tag...
>> --
>> Jeff Weinstein - Electronic Munitions Specialist
>> Netscape Communication Corporation
>><EMAIL_ADDRESS>- http://home.netscape.com/people/jsw
>> Any opinions expressed above are mine.

In the mid-eighties in the UK they adopted the idea of a red triangle
continuously displayed on the screen of movies shown on TV that were
considered to have more than the normal share of wobbly pink bits, airborne
blood, etc.

Viewing figures for obscure 70's French movies shown at 1:30am soared as
all the horny geeks sat through two hours of forest/eating/traffic or
whatever scenes waiting for the 7 seconds of nudity.

I'm sure that far more children saw these movies than would have without
the government sponsored red flag with the words "Get It Here" being waved
like crazy as the movie rolled.

-------------------------------------------------------------------------
Steven Weller                      |  "The Internet, of course, is more
                                   |  than just a place to find pictures
                                   |  of people having sex with dogs."
<EMAIL_ADDRESS>                 |       -- Time Magazine, 3 July 1995

{% endraw %}
```

## Thread

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

+ Return to "[Simon Spero <ses@tipper.oit.unc.edu>](/authors/simon_spero_ses_at_tipper_oit_unc_edu_)"
+ Return to<EMAIL_ADDRESS>(Steven Weller)](/authors/stevenw_at_best_com_steven_weller_)"

+ 1996-03-10 (Sun, 10 Mar 1996 11:31:34 +0800) - Re: SurfWatch -<EMAIL_ADDRESS>(Steven Weller)_
  + 1996-03-10 (Sun, 10 Mar 1996 13:19:38 +0800) - [Re: SurfWatch](/archive/1996/03/80b3286200e8eaa7d47bcdee238a95a1fccfe3edef662c0e5659ebf7f7346e00) - _Simon Spero<EMAIL_ADDRESS>


text:
---
action-group: yes
title: Women’s Homelessness Involvement Group (WHIG)
slug: womens-homelessness-inclusion
key: womens-homelessness-inclusion
content:
  heading: Women’s Homelessness Involvement Group (WHIG)
  subHeading: Issues specific to women facing homelessness.
  body: >-
    **What is the purpose of the group?**

    * To drive change towards more women-only accommodation

    **What we mean by women-only accommodation is:**

    * Completely separate from male accommodation

    * Small accommodation – a smaller building with fewer rooms

    * Properly staffed and trauma informed

    * To improve homeless services for women in Manchester

    * Through meaningful involvement from experts by experience to ensure women’s voices are heard, listened to and acted on by services and decision makers

    **What are the aims of the group?**

    * Influence providers and commissioners

    * Improve women’s emergency accommodation (and women’s experience of this)

    * Influence a more joined up and gendered approach to staff training and workplace practices

    * Improve service information available for women and access for women

      **Why and how was the group established?**

      The group was established in late 2018, after a launch event. Street Support and Manchester Homelessness Partnership (MHP) set-up the group, because they felt that there was a need for something for women. The launch event held last in 2018 brought together about 100 women, this was coordinated by Street Support and co-facilitated by them and Eve Holt. From this the women said that they wanted a women’s homelessness action group and this was taken forward bsy MASH and Riverside for the first few meetings. Since 2020 WHIG has been coordinated by The Pankhurst Trust (Incorporating Manchester Women's Aid).

      **What Does Membership look like?**

      Membership of the group is open to women and those who identify as women, including those with lived experience, volunteers and staff who are committed to involvement and influencing change that improves women's experiences of homeless services and accommodation. There is representation from a range of organisations. There is also a key aim of encouraging representation from the local authority. there are no restrictions on numbers.

      **How does the group work?**

      WHIG is working towards a true co-production model and is adopting these principles in it's approach through actively encouraging representation from a range of different services and individuals with lived experience coming together to do work, make decisions and listen to each other. Like all MHP Action Groups, this group is working towards a shared purpose and the vision of the MHP to end homelessness. There are a range of different opportunities for individuals to feed into the group via monthly face to face meetings, working groups and the WHIG mailing list.

    **Where and when does the group meet?**

    WHIG holds monthly face to face meetings at various locations across Manchester on the 4th Wednesday of the month. We want to make the group as accessible as possible so if you are working with women who would like to attend WHIG and can host a meeting, please contact us<EMAIL_ADDRESS>

    **Women’s Homelessness Involvement Group’s Political Asks**

    We at the Women’s Homelessness Involvement Group (WHIG) have developed some [key political asks](https://mhp.org.uk/assets/uploads/political-asks_sketches-whig.pdf). These are based on what women who are experiencing homelessness and stakeholders from frontline services have told us are the gaps in provision and barriers to accessing support. Through a coproduced approach with women, we have developed solutions to address those gaps and identified what is needed to improve homelessness services for women.
  id: 57166268e4b09686f6b2c893
  contactEmail<EMAIL_ADDRESS>  signupLink: https://forms.office.com/Pages/ResponsePage.aspx?id=XVwzcf1bkE61VN8N5KjjQkQ2JR41SuRLu92-3-tlPOtURDMzQjVZWEczSFdPS1M2SEZMR1RVTkpHVC4u
  newsUrl: http://news.streetsupport.net/tag/women/
  image:
---

repository: StreetSupport/mhp

repo_name: StreetSupport/mhp


text:
---
title: Smear (draft)
layout: default
---

An investigation into the work of Mike Kelley lead to the creation of two video works, both titled _Smear_.  This continued until the remnants of my spit formed a pattern on the surface.

Both works deal with the surface of the screen as a key driver. The intention was to create the illusion of me trying to emerge out of the television, quietly licking behind the screen and observing the viewer from behind the glass.

As these videos were rushed and treated as drafts they could not really be considered as anything more. However, it was a valuable experience and shift from _Pictures of friends_ (see research booklet), trying to find nonrepresentational methods of “painting” while also creating a conversation with the “grandparents” of contemporary art.


text:
---
parent: Virtualization
version: 4.4
---

# List View

## VM List

The VM list contains columns for the following:

* Name
* Namespace
* Status
  * Running, Off, Error (with custom messages), Cloning, Migrating, Snapshotting, Importing, Warning, Pending (with changes that will apply after restart), Unknown
* Created
  * Date formatting should follow OpenShift’s console
  * If possible, a tooltip should appear on hover with the exact creation date, including year.
* Node
* IP Address

### Max number of columns and prioritization

We set 6 columns to be the max number we will display in list views. We also determined priorities/usefulness of each column and set the priority order from left to right.

![VM list six columns](img/vmlist.png)

### Status Popovers and Icons

[The Resource status](http://openshift.github.io/openshift-origin-design/web-console/4.0-designs/status/status)

Statuses should be colored blue to indicate that they can be clicked/tapped.
Hovering should only underline the blue status text.
Clicking on a blue status should display a status popovers with a brief description of the issue or underlying process.
Clicking on the "Learn more" with the external link icon (seen below in the Guest Agent example) should bring the user to external documentation for further details.
“View details” without the external link icon would be more appropriate if the status is an error, for example, and clicking would bring the user to the Events page.
The status popovers are replacing the status tooltips because they're significantly more accessible on mobile and easier to copy/paste from and they also provide actions that the user can take upon.
A popover is used to provide contextual information for another component on click. The popover itself is made up of two main elements: arrow and content. The content element follows the pattern of the popover box component, with a close icon in the top right corner, as well as a header and body.

![status popovers instead of tooltips](img/statuspopovers.png)

We replaced the old lightning bolt icon for ‘Running’ with fa-refresh icon.
An asterisk can be appended to the status to highlight a potential issue that the user should be aware of. For example, when the IP address is unavailable because of missing guest agent, the ‘Running’ status will be appended with an asterisk.

## Filtering

### Item filters

The predefined filters in the filter bar can be used to narrow the VM list by most statuses. The user clicks each filter to toggle it on and off.

![Filter only the VMs with errors](img/itemfiltererror.png)

### Search filter

The generic search filter allows the user to filter results by any text string in any column. This could enable users to quickly find a VM by IP address or possibly other fields in the future. Multiple filters could be delineated by a comma in the search query.

![Search filter](img/searchfilter.png)

## Sorting

Sorting by columns is possible for any data table variation. Enabling the component within a table eases the ability to scan and read through the content. This option is favored over adding sorting functionality to the toolbar.

![Sorting](img/sorting.png)

1. **Sorted column** when a column is being sorted, the column header will turn blue and the sort icon will represent the direction of the sort. Subsequent clicks on the sortable column header will toggle the direction of the sort.
2. **Hovered sort** when a column is sortable, the sort icon will appear to the right of the column header. Upon hover, the icon will change to a darker grey indicating that the icon is actionable.
3. **Sortable column** when a column is sortable, the sort icon will appear to the right of the column header in a light grey color. Sorting will not become active until the user selects the column header. This triggers the arrow to point upwards and the content to be sorted in ascending order.

![Sorting with examples](img/sorting2.png)

## States and Actions

When a VM is off, the actions kebab contains options to Run, Edit, Migrate, Clone, Create template, Take snapshot, and Delete the VM.

![Dropdown when the vm is off](img/vmlistdropdownoff.png)

When a VM is running the Run option is replaced with two dropdowns for Power and Connect to Console.

![Dropdown when the vm is running](img/dropdownpower.png)

The Power dropdown contains options to Suspend, Restart, or Shut down the VM. Because these are potentially destructive actions, clicking any of these options will display a modal for the user to confirm.

![Confirmation modal](img/confirmationmodal.png)

The modals for Restart and Shutdown include an additional button to “Force” the action. They also include warnings about the possibility for data loss.

![Restart modal](img/restartmodal.png)

![Shutdown modal](img/shutdownmodal.png)

The Connect to Console dropdown contains quick links to the consoles that are enabled for the VM.

![Connect to console dropdown](img/connecttoconsoledropdown.png)

When a VM is in a transitional state (cloning, migrating, taking a snapshot, etc.) any unavailable actions in the kebab are disabled and the original action (“Clone”) is replaced with a cancel action (“Cancel Clone”).

![Vm in transitional state the original action is replaced w_cancel action](img/transitionalstatemenu.png)

repository: openshift/openshift-origin-design

gha_language: SCSS

repo_name: openshift/openshift-origin-design


text:
## Data Formats

> Response structure:

```json
{
  "statusCode": { Number },
  "result": { Object | Array }
}
```

CogniCity provides responses in JSON format. The `statusCode` object gives the HTTP response status for the request (also available in the response header). The `response` property may be either an `Object` or an `Array` depending on the data returned.

Where responses contain geographical information both the [GeoJSON](http://geojson.org/) and [TopoJSON](https://github.com/topojson/topojson) formats are supported.

The `/floods` endpoint also supports responses using the [Common Alerting Protocol](https://docs.oasis-open.org/emergency/cap/v1.2/CAP-v1.2-os.html), an XML format.

CogniCity uses the [PostgreSQL BIGINT](https://www.postgresql.org/docs/current/static/datatype-numeric.html) data type. As these numbers are potentially greater than JavaScript's `Numbers.MAX_SAFE_INTEGER` they are returned as strings.

repository: urbanriskmap/cognicity-api-docs

repo_name: urbanriskmap/cognicity-api-docs


text:
---
layout: post
title:  "Variable Pyramid Creator"
date:   2018-02-07 10:51:47 +0530
technologies: Processing 3
img: variable-pyramid.JPG
---

A program that takes the pyramid's height as an input parameter and outputs a pyramid of the requested height.

This project was completed as part of the Introduction to Computer Programming course.

Please note that there is no link to the code as this was developed for an university course assignment and the professor requested that the code be kept private. However, I was awarded 100% in this assignment.

Technologies used include {{page.technologies}}.

## Example Pyramid Outputs

#### 1. Height of 3
The following image is a sample output of a pyramid of height 3.

#### 2. Height of 5
The following image is a sample output of a pyramid of height 5.

#### 3. Height of 6
The following image is a sample output of a pyramid of height 6.

extension: markdown


text:
import './introduction.less'

# Introduction

- RcPress is a static website generator based on React.js.
- It is built with [Ant Design](https://ant.design/) and its configuration style borrows from [Vuepress](https://rcpress.vuejs.org/).

import ImgWidthBase from '@components/ImgWidthBase'

  <ImgWidthBase url="antd-icon.svg" width={120} />
   +
  <ImgWidthBase url="react-icon.svg" width={120}/>

## Features

- It only needs a simple configuration and some markdown knowledge to get started quickly. Users who are familiar with [Vuepress](https://vuepress.vuejs.org/) are more comfortable to use.
- Supports rendering to common Ant Design components using markdown syntax, such as [Alert](https://www.yvescoding.com/rcpress/guide/markdown#prompt-box)
- Support [mdx](https://github.com/mdx-js/mdx), support [custom layout](https://www.yvescoding.com/rcpress/guide/theme#custom-layout) (eg custom website header, bottom, home page, etc.)

## Technology Stack

- [Ant Design](https://ant.design/docs/react/introduce)
- markdown
- [mdx](https://github.com/mdx-js/mdx)
- [React](https://reactjs.org/)

## Support environment

- Modern browsers and IE11.
- Support server rendering.

## Version

- rcpress version: [![npm package](https://img.shields.io/npm/v/@rcpress/core.svg?style=flat-square)](https://www.npmjs.org/package/@rcpress/core)

repository: YvesCoding/rcpress

repo_name: YvesCoding/rcpress


text:
---
title: "What is God - by Sadhguru"
date: 2013-07-18 22:30:35 00:00
permalink: /videos/2019
source: "https://www.youtube.com/watch?v=tZ0e8JRu_9U"
featured: false
provider: "YouTube"
thumbnail: "http://i1.ytimg.com/vi/tZ0e8JRu_9U/hqdefault.jpg"
user:
  id: 1619
  username: "shelesh"
  name: "Shelesh Kumar"
tags: ["wisdom","god","spirituality"]
html: "<iframe width=\"640\" height=\"480\" src=\"http://www.youtube.com/embed/tZ0e8JRu_9U?wmode=transparent&feature=oembed\" frameborder=\"0\" allowfullscreen></iframe>"
id: 2019
---

Sadhguru speaks of the creator and creation and how people tend to divide between the two by thinking that the creator is great, but the creation is filthy.

Sadhguru explains that whatever idea you have about God is only a definition according to what we see around us, as most people see God as an exaggerated version of themselves. Whatever is the source of creation can only be experienced and not understood.

Yogi, mystic and visionary, Sadhguru is a spiritual master with a difference. An arresting blend of profundity and pragmatism, his life serves as a reminder that yoga is a contemporary science, vitally relevant to our times.

For more information on Sadhguru visit http://www.sadhguru.org/
S-014

repository: sawyerh/organizedwonder

repo_name: sawyerh/organizedwonder


text:
---
title: 'GitHub Universe liveblog: Clarence Wardell, U.S. Digital Service'
author: 'Beyang Liu'
publishDate: 2016-05-30T00:00-07:00
tags: [
  "blog"
]
slug: clarence-wardell
heroImage: https://images.ctfassets.net/le3mxztn6yoo/1NbGrwYvFeOq6imUOimgMg/27e1186b665e0e9ed3e9e8e2ca118fc2/1_75TAuLENSspfiw96cW5Q2A.jpeg
published: true
---

Innovation fellow of the U.S. Digital Service, a.k.a. the “president’s startup.”

His time as innovation fellow started in 2014, right around the time the conversation around law enforcement and Ferguson was coming to a tipping point. Big demand for better data around policing, especially with officer shootings.

![1*75TAuLENSspfiw96cW5Q2A](//images.contentful.com/le3mxztn6yoo/1NbGrwYvFeOq6imUOimgMg/27e1186b665e0e9ed3e9e8e2ca118fc2/1_75TAuLENSspfiw96cW5Q2A.jpeg)

They compiled 49 recommendations based on data for the White House. We looked around the country and saw police departments actively responding to citizen concerns, not waiting around for mandates or legislation — Dallas, Seattle, Louisville. They invited folks to the White House to have a discussion and workshops. They started a conversation to share more data and ended the meeting with a commitment board: 14 PDs committed to releasing policing data in formats that were machine-readable. They didn't ask for a specific product right away, but wanted folks to get the process started and off the ground. This became the Police Data Initiative in May 2015.

As of this past summer, they’ve reached 56 police departments around the country, both big and small. 80 jurisdictions, 150+ data sets covering 40 million individuals.

Police Data Initiatives commitments:

*   leadership buy-in
*   release at lease 3 datasets in open format (disaggregated, machine readable)
*   designed “quarterback” who partakes in bi-weekly community of practice phone calls — stand-ups to share data with other PDs
*   engage citizens through data

![1*Xs-1BcGE3N3fW81IGTHbYQ](//images.contentful.com/le3mxztn6yoo/5gxMRsW3sAc8g24W4Y4mKc/f48ba804fd991605eca9200206008cd6/1_Xs-1BcGE3N3fW81IGTHbYQ.jpeg)

Police Data Initiatives key activities:

*   recruit new jurisdictions
*   manage growing community of practice
*   successful execution for datasets and community events

Early successes:

*   Public Safety Open Data Portal
*   New Orleans Police Department Operation Spark: engaging student hackers to hack on community policing data
*   Code for America: Indianapolis Metropolitan Police Department’s Project Comport: show data on police use of force

![1*xYsLyqbSYDht-HNW3 2NAg](//images.contentful.com/le3mxztn6yoo/41naiLxNcASU0MwoyMuc8c/f88715c20140b275d27329dc85cf68e3/1_xYsLyqbSYDht-HNW3_2NAg.jpeg)

We’re starting to see a new paradigm. Police departments across the country are coming around to the idea of sharing data as the default. It’s the People’s Data, not just the police’s data.

How to get involved?

*   [www.wh.gov/policedata](http://www.wh.gov/policedata)
*   [www.wh.gov/buildingtrust](http://www.wh.gov/buildingtrust)
*   codeforamerica.github.com.io/pdi-census

repository: zag/about

repo_name: zag/about


text:
# Jellyfin Operator (k8s)

## Description

[Jellyfin][Jellyfin source] is a media system for streaming to any device from
your own server.

## Usage

To use Jellyfin, need to have a working Kubernetes environment, and have bootstrapped a
Juju controller of version 2.9+, with a model ready to use with the Kubernetes
cloud.

Example deployment:

```shell
charmcraft pack
juju deploy ./jellyfin-k8s_ubuntu-20.04-amd64.charm jellyfin --resource jellyfin-image=jellyfin/jellyfin:unstable
juju deploy nginx-ingress-integrator ingress
juju relate jellyfin ingress
```

### Scale Out Usage
To add additional Jellyfin units for high availability,

```shell
juju add-unit jellyfin-k8s
```

## Relations
Currently, supported relations are:
- `ingress`, for interfacing with [nginx-ingress-integrator][nginx-ingress-integrator operator].

## OCI Images
This charm can be used with the following image:
- `jellyfin/jellyfin:unstable`

[Jellyfin source]: https://github.com/jellyfin/jellyfin
[nginx-ingress-integrator operator]: https://charmhub.io/nginx-ingress-integrator

repository: sed-i/jellyfin-operator

repo_name: sed-i/jellyfin-operator


text:
---
layout: post
title: "We need your input!"
date: 2019-12-18 08:00:00
isStaticPost: true
image: hero.jpg
color: olive

---

**We need your help!**

We are finalizing the event schedules and we [would like your input](http://bit.ly/bcc2020-poll) on several options we are considering for the schedule.

The next gathering of the [BOSC](https://www.open-bio.org/events/bosc/about/) and [Galaxy](https://galaxyproject.org/) communities will be the [Bioinformatics Community Conference 2020 (BCC2020)](https://bcc2020.github.io/), being held in Toronto, just after [ISMB 2020](https://www.iscb.org/ismb2020) in Montréal.  BCC2020 brings these communities together for a unified set of events spanning July 18-25, and including training, presentation sessions, networking and a CollaborationFest.

 Please take a few minutes [to let us know what you think about](http://bit.ly/bcc2020-poll)

* Intermixing tutorial sessions and presentation sessions (a la [GCC2019](https://gcc2019.sched.com/)), or not (a la [GCCBOSC 2018](https://gccbosc2018.sched.com/))
* Possible demo presentation formats
* And any suggestions you have for keynote speakers and panel topics

**[Please submit your guidance by January 7](http://bit.ly/bcc2020-poll).**

Thanks for your time and input, and we hope to see you in Toronto!

[BCC2020 Organizers](https://bcc2020.github.io/about/#team)


text:
# Cookbook

The cookbook is a continuously growing collection of recipes that explain how to correctly solve the most recurrent problems that developers face in their day to day work with the KunstmaanBundlesCMS.

* [Going single language](going-single-language.md)
* [Managing translations](manage-translations.md)
* [Google Analytics dashboard](google-analytics-dashboard.md)
* [Administer robots.txt](administer-robots-txt.md)
* [Building a custom admin list filter that works on multiple columns](building-custom-filter-on-multiple-columns.md)
* [Using the LeadGenerationBundle](using-the-leadgenerationbundle.md)
* [Using the MenuBundle](using-the-menubundle.md)
* [Using the MultiDomainBundle](using-the-multi-domain-bundle.md)
* [Defining custom ckeditor configuration](defining-custom-ckeditor-configuration.md)
* [Structure pages](structure-pages.md)
* [Adding a custom controller](adding-a-custom-controller.md)
* [Using a custom filesystem for the media bundle](using-a-custom-filesystem-for-the-media-bundle.md)
* [Enabling google login](enabling-google-auth-login.md)
* [Using the cache bundle](using-the-cache-bundle.md)
* [Using anacrontab](using-anacrontab.md)

> Have some cool insight or thing you did with the CMS? Please share it with us and other developers by [sending a pull request](../contributing/pull-requests.md)!

repository: Kunstmaan/KunstmaanBundlesCMS

gha_language: PHP

repo_name: Kunstmaan/KunstmaanBundlesCMS


text:
---
title: Custom Windows Workflow activity for dependency resolution–Part 2
categories: .Net
tags: Unity, WF
date: 2010-09-29 10:08:25 +10:00
---

My [previous post][0] described the design goals for creating a custom WF4 activity that provides dependency resolution functionality. This post will look at the underlying support for making this happen.

The main issue with dependency resolution/injection in WF is supporting persistence. An exception will be thrown when a workflow is persisted when it holds onto a dependency that is not serializable. The previous post indicated that the solution to this issue is to have the workflow persist the resolution description and explicitly prevent serialization of the resolved instance itself.

The way this is done is via an InstanceHandler<T> class.

<!--more-->

```csharp
namespace Neovolve.Toolkit.Workflow
{
    using System;
    using Neovolve.Toolkit.Workflow.Activities;
    using Neovolve.Toolkit.Workflow.Extensions;

    [Serializable]
    public class InstanceHandler<T>
    {
        [NonSerialized]
        private Boolean _resolveAttemptMade;

        [NonSerialized]
        private T _resolvedInstance;

        internal InstanceHandler(String resolutionName)
        {
            InstanceHandlerId = Guid.NewGuid();
            ResolutionName = resolutionName;
        }

        public T Instance
        {
            get
            {
                if (_resolveAttemptMade)
                {
                    return _resolvedInstance;
                }

                _resolveAttemptMade = true;

                _resolvedInstance = InstanceManagerExtension.Resolve(this);

                return _resolvedInstance;
            }
        }

        public Guid InstanceHandlerId
        {
            get;
            private set;
        }

        public String ResolutionName
        {
            get;
            private set;
        }
    }
}
```

The InstanceHandler<T> class contains the description of the resolution. This identifies the type of resolution (being <T>) and the name for the resolution. This may by null for default resolutions in Unity. The class also creates a GUID value that identifies a particular instance of this class. This is needed so that instances can be resolved from a cache when the owning activity is either persisted or finalised (completed, aborted or cancelled).

The InstanceHandler also exposes a property for the instance being resolved. It is strongly typed to the generic type argument of T. The serialization of this instance is specifically denied via the NonSerialized attribute on the backing field. The other field used here is a flag that indicates whether the instance resolution has already occurred. This is used in order to support null resolution values.

This class can be serialized at any point and only the definition of how to resolve an instance will be stored. The instance is resolved when the Instance property is referenced rather than when the activity starts. This is done for two reasons.

1. Lazy loading the instance – resolutions only occur when they are referenced
1. Supporting resolutions after workflow has persisted and been resumed.

The first reason is merely a beneficial side effect. The second reason listed is a technical restriction that comes into play when a persisted workflow resumes and the Instance property of the handler is invoked. There is no reference to an activity context at this point and no prior code can execute in which the dependency can be resolved.

This class makes a static call out to an InstanceManagerExtension to resolve the instance. The InstanceManagerExtension class is used to abstract the resolution, management and clean up logic for instances requested by the handler class.

```csharp
namespace Neovolve.Toolkit.Workflow.Extensions
{
    using System;
    using System.Activities.Persistence;
    using System.Collections.Generic;
    using System.Diagnostics.Contracts;
    using System.Threading;
    using System.Xml.Linq;
    using Microsoft.Practices.Unity;
    using Neovolve.Toolkit.Threading;
    using Neovolve.Toolkit.Unity;

    public class InstanceManagerExtension : PersistenceParticipant, IDisposable
    {
        private static readonly Dictionary<Guid, Object> _instanceCache = new Dictionary<Guid, Object>();

        private static readonly ReaderWriterLockSlim _instanceSyncLock = new ReaderWriterLockSlim();

        private readonly List<Guid> _handlerIdCache = new List<Guid>();

        private readonly ReaderWriterLockSlim _handlerSyncLock = new ReaderWriterLockSlim();

        private static IUnityContainer _container;

        public static T Resolve<T>(InstanceHandler<T> handler)
        {
            Contract.Requires<ArgumentNullException>(handler != null);

            T resolvedInstance = Container.Resolve<T>(handler.ResolutionName);

            using (new LockWriter(_instanceSyncLock))
            {
                if (_instanceCache.ContainsKey(handler.InstanceHandlerId))
                {
                    throw new InvalidOperationException("InstanceHandler cache is corrupted with a stale instance");
                }

                _instanceCache.Add(handler.InstanceHandlerId, resolvedInstance);

                return resolvedInstance;
            }
        }

        public void DestroyHandler(Guid instanceHandlerId)
        {
            Contract.Requires<ArgumentException>(instanceHandlerId.Equals(Guid.Empty) == false);

            DestroyHandlerByHandlerInstanceId(instanceHandlerId);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        internal InstanceHandler<T> CreateInstanceHandler<T>(String resolutionName)
        {
            Contract.Requires<ObjectDisposedException>(Disposed == false);

            InstanceHandler<T> handler = new InstanceHandler<T>(resolutionName);

            // Store this created handler so that it can be destroyed when the workflow is persisted
            using (new LockWriter(_handlerSyncLock))
            {
                _handlerIdCache.Add(handler.InstanceHandlerId);
            }

            return handler;
        }

        protected virtual void Dispose(Boolean disposing)
        {
            if (disposing)
            {
                // Free managed resources
                if (Disposed == false)
                {
                    Disposed = true;

                    DestroyLocalHandles();

                    _handlerSyncLock.Dispose();
                }
            }

            // Free native resources if there are any.
        }

        protected override IDictionary<XName, Object> MapValues(
            IDictionary<XName, Object> readWriteValues, IDictionary<XName, Object> writeOnlyValues)
        {
            // This method is used to detect when the activity is being persisted
            DestroyLocalHandles();

            return base.MapValues(readWriteValues, writeOnlyValues);
        }

        private void DestroyHandlerByHandlerInstanceId(Guid instanceHandlerId)
        {
            using (new LockWriter(_handlerSyncLock))
            {
                _handlerIdCache.Remove(instanceHandlerId);
            }

            // Get this handler
            using (new LockReader(_instanceSyncLock))
            {
                if (_instanceCache.ContainsKey(instanceHandlerId) == false)
                {
                    return;
                }
            }

            Object instance = null;

            using (new LockWriter(_instanceSyncLock))
            {
                if (_instanceCache.ContainsKey(instanceHandlerId))
                {
                    instance = _instanceCache[instanceHandlerId];

                    _instanceCache.Remove(instanceHandlerId);
                }
            }

            if (instance != null)
            {
                Container.Teardown(instance);
            }
        }

        private void DestroyLocalHandles()
        {
            List<Guid> handleIdList;

            using (new LockReader(_handlerSyncLock))
            {
                handleIdList = new List<Guid>(_handlerIdCache);
            }

            handleIdList.ForEach(DestroyHandlerByHandlerInstanceId);
        }

        public static IUnityContainer Container
        {
            get
            {
                if (_container == null)
                {
                    _container = UnityContainerResolver.Resolve();
                }

                return _container;
            }

            set
            {
                _container = value;
            }
        }

        protected Boolean Disposed
        {
            get;
            set;
        }
    }
}
```

The InstanceManagerExtension creates InstanceHandler instances, resolve dependencies and tear down dependencies. The extension will resolve a Unity container from configuration if a container has not already been assigned prior to the first dependency being resolved. This allows for a custom container to be provided if that is required but also falls back on a default behaviour.

The extension will first be used by an activity to create an InstanceHandler<T>. This is done so that the handler GUID can be tracked by the extension. Each InstanceHandlerId created is cached in a list stored against the extension instance.

When an activity execution makes a call to the Instance property of the handler, the handler then comes back to the extension to resolve the dependency using the static method. The reason for the static method is that the handler does not have a reference to the activity context from which the extension instance is obtained. The resolved instance is then cached in a dictionary object. Because the resolution process is static, the cache of instances is also static.

The last function of the extension is the ability to tear down the instances it has resolved.

The extension has exposes a public DestroyHandler method that tears down the instance for a specified InstanceHandlerId. The tear down logic will remove the InstanceHandlerId from the instance handler Id cache and then obtain a reference to the resolved instance from the static dictionary cache. This instance is then removed from the cache and torn down using the container.

Tearing down a resolved instance occurs in any of the following circumstances:

* The workflow completes
* The workflow is cancelled
* The workflow is aborted
* The workflow is persisted
* The extension is disposed

The custom activity will notify the extension when any of the first three events occur. The custom activity will request the extension to tear down all the InstanceHandlerId values for which it has a reference.

The extension supports persistence by inheriting from PersistenceParticipant and overriding the MapValues method. This method gets invoked as part of a persistence operation. This extension does not provide any custom persistence support, but uses this method as a notification that persistence is executing. At this point the extension instance looks at the instance cache of InstanceHandlerId values that it has created and tears down all the resolved instances.

Finally, the extension implements IDisposable. This will ensure that any resolved instances that are not torn down in any of the above events are correctly disposed when the extension is disposed by the workflow engine.

The InstanceHandler<T> and InstanceManagerExtension classes provide the base framework for resolving and tearing down instances in a workflow execution. The next post will look at a simple custom activity that will leverage these to provide a resolved instance to a workflow execution.

[0]: /2010/09/16/custom-windows-workflow-activity-for-dependency-resolutione28093part-1/

license: MIT,Unlicense

detected_licenses: MIT Unlicense


text:
# MNIST_Digit_Recognition
CNN Model to recognize Digits from Images from MNIST Data with accuracy of **99.46%**.
MNIST Digit Recognition dataset is a great dataset with 60000 training examples and 10000 testing examples.

## CNN Model
I have used a sequential model with following layers in order:
1. 2D Convolution Layer with 32 filters and 3x3 kernal size.
2. 2D Maximum Pooling Layer with 2x2 kernal size.
3. 2D Convolution Layer with 64 filters and 2x2 kernal size.
4. 2D Maximum Pooling Layer with 2x2 kernal size.
5. 2D Convolution Layer with 256 filters and 2x2 kernal size.
6. Flatten Layer.
7. Dense Layer with 1024 neurons (activation units).
8. Dense Layer with 256 neurons (activation units).
9. Dense Layer with 10 neurons (activation units). This is the output layer.

The optimizer used is Stochastic Gradient Descent (SGD) with learning rate of 0.01 and momentum of 0.9.
I have trained it on Google Colab for 30 epochs with a batch size of 32.

## Conclusions
1. CNN Model is good to start with, for image recognition.
2. Keras is great, easy-to-use library for implementing neural networks.
3. Since the training accuracy is 1.0000 but test accuracy is 0.99460, so the model can be inproved by increasing its depth/ adding more layers. The little problem is high variance. (I will try to improve it.)
4. I have trained the model using both GPU and TPU, and found that, TPU is faster for higher batch sizes(>256) whereas GPU is faster for lower batch sizes.


text:
Roll is a simple template rendering utility geared towards random text
generation.

# Usage

Roll provides extensive help on invocation:

```sh
> roll -h
Usage:
  roll FILE [flags]

Flags:
  -h, --help        help for roll
  -s, --seed SEED   random number generator SEED (default<PHONE_NUMBER>)
```

## Example Input

```toml
template = """
1D100: {{roll "1d100"}}
Coin: {{random .coin}}

AW move
  1D{{.aw.Total}}: {{random .aw}}
  2d6: {{roll "2d6" | pick .aw}}
"""

[tables]
coin = [
    "head",
    "tail",
    ]

aw = [
    "6:miss",
    "3:hit",
    "3:strong hit",
    ]
```

## Example Result

```sh
> roll example.toml
1D100: 73
Coin: tail

AW move
  1D12: miss
  2d6: hit
```

repository: illotum/roll

repo_name: illotum/roll


text:
---
layout: post
title:  XAP Community
categories: FAQ
weight: 200
parent: none
---

{% wbr %}

{%panel%}
- [What is GigaSpaces XAP-Community?](#1)

- [Why was it launched?](#2)

- [How does the XAP-Community compare to other freeware JavaSpaces implementations?](#3)

- [Can I use the XAP-Community in production?](#4)

- [I am an ISV, Can I embed the XAP-Community in a commercial product?](#5)

- [What is the difference between the XAP-Community and XAP?](#6)

- [What are the terms for using the XAP-Community?](#7)

- [What if I need support for the XAP-Community?](#8)

- [What are my upgrade options from the XAP-Community?](#9)
{%endpanel%}

{%anchor 1%}

### What is GigaSpaces XAP-Community?

The GigaSpaces eXtreme Application Platform - Community enables application developers to use a full, mature implementation of GigaSpaces XAP free of charge, both in development and in production environments. While GigaSpaces XAP-Community is limited to a single server node, it allows unlimited number of clients with local caches (Master/Local cache) which makes it ideal for small-scale applications that are not data-intensive.(read more at: [www.gigaspaces.com](http://www.gigaspaces.com).

{%anchor 2%}

### Why was it launched?

We hope that this initiative will help accelerate the adoption of JavaSpaces as the de-facto programming model for building grid-based applications, as well as offer developers a simple yet powerful tool to develop distributed, grid-based applications quickly.

{%anchor 3%}

### How does the XAP-Community compare to other freeware JavaSpaces implementations?

GigaSpaces users will benefit from the enhanced capabilities provided by the XAP-Community such as caching, indexing, SQL and RegExp query support, support for FIFO as well as superior performance.

{%anchor 4%}

### Can I use the XAP-Community in production?

Yes. The XAP-Community is available for use in production environments. (Please refer to the XAP-Community Licensing agreement for more information)

{%anchor 5%}

### I am an ISV, Can I embed the XAP-Community in a commercial product?

Yes. The XAP-Community is available for embedding within a commercial product. (Please refer to the XAP-Community Licensing agreement for more information)

{%anchor 6%}

### What is the difference between the XAP-Community and XAP?

GigaSpaces XAP offers a complete middleware platform (read more at: [http://www.gigaspaces.com](http://www.gigaspaces.com)) and is not free. The XAP-Community enables application developers to use a full, mature implementation of GigaSpaces XAP free of charge, both in development and in production environments. While GigaSpaces XAP-Community is limited to a single server node, it allows unlimited number of clients with local caches (Master/Local cache) which makes it ideal for small-scale applications that are not data-intensive. For more information about GigaSpaces XAP please contact sales at: [sales<EMAIL_ADDRESS>
{%anchor 7%}

### What are the terms for using the XAP-Community?

You can use the XAP-Community free of charge in both development and production environments. (Please refer to the XAP-Community Licensing agreement for more information)

{%anchor 8%}

### What if I need support for the XAP-Community?

Support for production environments or OEM is available at an annual flat-fee of $5,000.
Please contact<EMAIL_ADDRESS>for further details.

{%anchor 9%}

### What are my upgrade options from the XAP-Community?

If your needs necessitate more than what the XAP-Community has to offer, please contact [support<EMAIL_ADDRESS>and we will provide you with the key that will enable you to upgrade to the complete XAP solution for a free 30 day trial period.

Please note that upgrading involves only a simple license change, there is no need to reinstall or change your existing XAP-Community version.

repository: barakb/gigaspaces-wiki-jekyll

repo_name: barakb/gigaspaces-wiki-jekyll


text:
#MovieTweetings statistics

Here are some MovieTweetings statistics. Note that these are autocalculated and may not be completely up to date. Any interesting stats missing here? Ping me, and I'll add them!

Metric | Value
--- | ---
Total number of ratings                 | 816,536
Number of unique users                  | 60,446
Number of unique items                  | 34,508
Minimum rating value                    | 0.0
Maximum rating value                    | 10.0
Earliest rating time                    | 2013-02-28 15:38:27
Last rating time                        | 2019-11-18 00:53:47
Maximum number of ratings per user      | 2,840
Maximum number of ratings per item      | 3,067
Number of users with minimum 50 ratings | 3,603
Number of users with minimum 40 ratings | 4,495
Number of users with minimum 30 ratings | 5,864
Number of users with minimum 20 ratings | 8,141
Number of users with minimum 10 ratings | 13,171
Average number of ratings per user      | 14
Average number of ratings per item      | 24
Stats calculation time                  | Mon Nov 18 01:36:36 2019


text:
String Formatting Arguments       {#StringFormattingArguments}
=====================

This page documents string formatting arguments that affect ParaView behavior at
runtime. These arguments can be used to format formattable strings.

The class that is responsible for handling the pushing/popping of scopes (set of arguments) is `vtkPVStringFormatter`.
`vtkPVStringFormatter` uses the `{fmt}` library to format strings that utilize named arguments.

The following arguments are part of the `initial argument scope`. This scope is
pushed and popped inside `vtkInitializerHelper`, therefore the values of those
arguments do NOT change at runtime. The arguments of this scope can be used in all formattable strings.

Argument | Type | Description
---------|------|---------------------------------------------------------
`{ENV_username}` | std::string | The computer's username. Extracted from vtksys::SystemInformation.
`{username}` | std::string | The computer's username. Extracted from vtksys::SystemInformation.
`{ENV_hostname}` | std::string | The computer's hostname. Extracted from vtksys::SystemInformation.
`{hostname}` | std::string | The computer's hostname. Extracted from vtksys::SystemInformation.
`{ENV_os}` | std::string | The computer's operating system. Extracted from vtksys::SystemInformation.
`{os}` | std::string | The computer's operating system. Extracted from vtksys::SystemInformation.
`{GLOBAL_date}` | std::chrono::time_point | The date that ParaView started its execution. Extracted from std::chrono::system_clock::now(). For further formatting options see [fmt/chrono.h](https://gitlab.kitware.com/third-party/fmt/-/blob/master/include/fmt/chrono.h).
`{date}` | std::chrono::time_point | The date that ParaView started its execution. Extracted from std::chrono::system_clock::now(). For further formatting options see [fmt/chrono.h](https://gitlab.kitware.com/third-party/fmt/-/blob/master/include/fmt/chrono.h).
`{GLOBAL_appname}` | std::string | The application name. Extracted from vtkInitializationHelper::ApplicationName.
`{appname}` | std::string | The application name. Extracted from vtkInitializationHelper::ApplicationName.
`{GLOBAL_appversion}` | std::string | The application version. Extracted from PARAVIEW_VERSION_FULL.
`{appversion}` | std::string | The application version. Extracted from PARAVIEW_VERSION_FULL.

The following arguments are part of a scope that is used in `Views`. `vtkPVXYChartView` and `vtkPVPlotMatrixView`
are responsible for pushing and popping the scope.

Argument | Type | Description
---------|------|---------------------------------------------------------
`{VIEW_time}` | double | The time of the VIEW.
`{time}` | double | The time of the VIEW.

The following arguments are part of a scope that is used in `Views` also. `vtkPVBagPlotMatrixView` is responsible
for pushing and popping the scope. `vtkPVBagPlotMatrixView` can also use the scope that is pushed by
its superclass, `vtkPVPlotMatrixView`.

Argument | Type | Description
---------|------|---------------------------------------------------------
`{VIEW_variance}` | int | The explained variance. Extracted from `vtkPVBagPlotMatrixRepresentation`.
`{variance}` | int | The explained variance. Extracted from `vtkPVBagPlotMatrixRepresentation`.

The following arguments are part of a scope that is used in `vtkTimeToTextConvertor`. This class is responsible
for pushing and popping the scope.

Argument | Type | Description
---------|------|---------------------------------------------------------
`{TEXT_time}` | double | The time. Extracted from vtkDataObject::DATA_TIME_STEP() / vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP().
`{time}` | double | The time. Extracted from vtkDataObject::DATA_TIME_STEP() / vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP().

The following arguments are part of a scope that is used in `extract_writers`. `vtkSMExtractsController` is
responsible for pushing and popping the scope.

Argument | Type | Description
---------|------|---------------------------------------------------------
`{EXTRACT_timestep}` | int | The time-step of the extraction. Extracted from GetTimeStep().
`{timestep}` | int | The time-step of the extraction. Extracted from GetTimeStep().
`{EXTRACT_time}` | double | The time of the extraction. Extracted from GetTime().
`{time}` | double | The time of the extraction. Extracted from GetTime().

The following arguments are part of a scope that is used also in `extract_writers`. `vtkSMImageExtractWriterProxy` is
responsible for pushing and popping the scope. `vtkSMImageExtractWriterProxy` can also utilize the scope pushed by
`vtkSMExtractsController`.

Argument | Type | Description
---------|------|---------------------------------------------------------
`{EXTRACT_camera}` | std::string | The camera parameters. Extracted from GetActiveCamera().
`{camera}` | std::string | The camera parameters. Extracted from GetActiveCamera().

The following arguments are part of a scope that is used in `PythonAnnotation`. `vtkPythonAnnotationFilter` is
responsible for pushing and popping the scope.

Argument | Type | Description
---------|------|---------------------------------------------------------
`{ANNOTATE_timevalue}` | double | The time-value of the information. Extracted from vtkDataObject::DATA_TIME_STEP().
`{timestep}` | double | The time-value of the information. Extracted from vtkDataObject::DATA_TIME_STEP().
`{ANNOTATE_timesteps}` | std::vector<double> | The time-step values. Extracted from vtkStreamingDemandDrivenPipeline::TIME_STEPS().
`{timesteps}` | std::vector<double> | The time-step values. Extracted from vtkStreamingDemandDrivenPipeline::TIME_STEPS().
`{ANNOTATE_timerange}` | std::vector<double> | The time-range of time-steps. Extracted from vtkStreamingDemandDrivenPipeline::TIME_RANGE().
`{timerange}` | std::vector<double> | The time-range of time-steps. Extracted from vtkStreamingDemandDrivenPipeline::TIME_RANGE().
`{ANNOTATE_timeindex}` | int | The index of the time-steps element which is equal to time-value.
`{timeindex}` | int | The index of the time-steps element which is equal to time-value.

The following arguments are part of a scope that is used in `PythonCalculator`. `vtkPythonCalculator` is
responsible for pushing and popping the scope.

Argument | Type | Description
---------|------|---------------------------------------------------------
`{CALCULATOR_timevalue}` | double | The time-value of the information. Extracted from vtkDataObject::DATA_TIME_STEP().
`{timevalue}` | double | The time-value of the information. Extracted from vtkDataObject::DATA_TIME_STEP().
`{CALCULATOR_timeindex}` | int | The index of the time-steps element which is equal to time-value. time-steps are extracted from vtkStreamingDemandDrivenPipeline::TIME_STEPS().
`{timeindex}` | int | The index of the time-steps element which is equal to time-value. time-steps are extracted from vtkStreamingDemandDrivenPipeline::TIME_STEPS().

All the aforementioned arguments can be used in appropriate ParaView use cases to format formattable strings.
If a user wants to see which are the available arguments that he can use, he can try to type a wrong argument in the
formattable field, e.g. `{test123}`. In output messages of ParaView, the user will see a message like below:

```
ERROR: In ~/ParaView/VTKExtensions/Core/vtkPVStringFormatter.cxx, line 73
vtkPVStringFormatter (0x55984453b2a0):
Invalid format specified '{test123}'
Details: argument not found

This argument scope includes the following arguments:
    Name: ENV_username
    Name: ENV_hostname
    Name: ENV_os
    Name: GLOBAL_date
    Name: GLOBAL_appname
    Name: GLOBAL_appversion
    Name: time
    Name: TEXT_time
```

repository: nagyist/ParaView

repo_name: nagyist/ParaView


text:
---
title: Battery Indicator
subtitle: Remaining battery time in your menu bar
description: Battery Indicator lets you quickly glance the remaining battery time or percentage right in your menu bar.
type: macOS
date: 2017-02-18
app_store_url: https://apps.apple.com/app/id1206020918
links:
  'Product Hunt post': https://www.producthunt.com/posts/battery-indicator
---

### Older versions

- [Last macOS 10.14 compatible version (free).](https://github.com/sindresorhus/meta/files/4127047/Battery-Indicator-2.1.0-Mojave.zip)

*(This build will not run on newer macOS versions)*

Frequently Asked Questions

#### I have a feature request, bug report, or some feedback

[Send it here.](https://sindresorhus.com/feedback/?product=Battery%20Indicator&referrer=Website-FAQ)

#### Where can I find the changelog?

Go [here](https://apps.apple.com/app/id1206020918) and click “Version History”.

#### Can you localize the app into my language?

I don't have any immediate plans to localize the app.


text:
### Usage Instructions

#### To run the app,
1. Make sure `mongodb` is running in the background.
2. Install global dependencies with `npm install -g gulp bower react-tools browserify`
3. Install dependencies with `npm install; bower install`
4. Run app with `gulp serve`

### Glossary

## Dispatcher
A simple emitter. Object register with the emitter to listen for an event, and when the event occurs, the objects are notified.

## Store
A utility that listens for particular kind of dispatcher events and is responsible for the handling of one element.

## State
A React component's state. A component can change it's own state, but not the state of other components. In order to change the state of another component, an app must make the appropriate request to a store.

## Props
The properties of a React component. A component cannot change its own properties. The properties of a React component can only be set by its parent. In order to change the props of a component which is not the child of the caller, a request must be passed to the appropriate store.

## JSX
A React-specific variant of JavaScript. JSX can be compiled into JavaScript code containing React components. JSX must be compiled as it cannot be read by web browsers.

### JSX Transformer
A tool used to transform JSX without any backend. Can be used in the browser. Not used for production.

### Reactify
A useful Browserify plugin which compiles JSX in to JavaScript as it is being browserified.

repository: msurgihalli/reactGroceryStore

repo_name: msurgihalli/reactGroceryStore