text:
# MDMS: Molecular Dynamics Made Simple

Perform Molecular Dynamics (MD) Simulations from scratch within minutes. This program is an interface to one of the most popular MD codes ([Amber](http://ambermd.org/)), aiding users in preparing and running their own simulations.

The idea behind MDMS design is that the beginnings should be easy - not exhausting. That is why this program accommodates everything that is required for getting realistic insights about protein/protein-ligand complexes through MD simulations.

Program's execution has four distinct steps:
- establishing protein/protein-ligand complex structure
- preparing topology and coordinate files for Amber
- preparing input files for Amber
- running MD simulations

MDMS is aimed both to newcomers to the field as well as mature scientists. Newcomers will mostly benefit from the ease of starting MD simulations and the guarantee that the systems are constructed correctly (if user will carefully follow on-screen prompts). Mature scientists should mostly appreciate time savings - with MDMS, MD simulations of the proteins might be initiated as quickly as in 2 minutes from the start of the program.

### Prerequisites

- Linux distribution with Bash shell
- Ambertools or Amber distribution
- pdb-tools, biopython, numpy, pandas packages

### Optional prerequisites

- Openbabel distribution along with Pybel package
- pdbfixer python package (part of Omnia software suite)
- Propka3.1 python package

### Installation

MDMS can be installed directly on your machine with either pip or conda.

Installing with pip:

`pip install mdms`

Installing with conda:

`conda install -c szymonzaczek mdms`

### Installing dependencies

Depending on which installation you will use, not all of the dependancies might have been installed.

For instance, neither installations automatically install Amber Tools - it is assumed that you already have it on your machine (this is due to the fact that there are a lot of ways to customly install Amber Tools).

If you do not have required dependancies installed yet (and they were not installed along with MDMS installation), use conda or pip to download them:

`conda install ambertools -c ambermd`

`pip install pdb-tools`

`pip install pandas`

`pip install numpy`

`pip install biopython`

### Optional dependancies

Following dependancies enable following functionalities:
- Open Babel is used for adding hydrogen atoms to ligands
- Propka is used to establish protonation states of residues within the structure
- Pdbfixer program is used for modelling missing residues in proteins

They might be installed by running following commands in the console:

`conda install -c openbabel openbabel`

`pip install PROPKA`

`conda install -c omnia pdbfixer `

### Getting Started

Change to the desired directory. All of the files will be stored there. Then simply type:

`mdms_menu`

Follow on-screen prompts to run your MD simulations!

### Features
- establishing initial protein (or protein-ligand complex) structure
  - downloading a protein structure directly from Protein Data Bank
  - using a protein structure that was earlier downloaded and/or somehow modified
  - choosing protein chains (if multiple chains are found in the structure)
  - checking if there are any missing atoms in amino acid residues
  - checking if there are any missing residues in the protein
  - adding missing residues with pdbfixer
  - reminding user that he should use functional oligomeric structure of the protein
  - establishing protonation states of titrable residues using Propka3.1
  - general formatting of PDB files
  - optional removal of residues, which are common leftovers after experiments
  - choosing which ligands are to be included for MD simulations
  - adding hydrogen atoms to ligands
  - choosing if metal ions are to be retained for MD (if they are present in the crystal structure)
  - choosing if crystal waters are to be retained for MD (if they are present in the crystal structure
  - adding hydrogen atoms to crystal waters
- preparing topology and coordinate files for Amber
  - checking if there are hydrogen present in the ligand - if not, user is asked if this is on purpose
  - determining charges and force field parameters for ligands
  - processing chosen ligands and protein with pdb4amber
  - preparing input files for MCPB.py in order to obtain metal force field parameters
  - choosing protein force field
  - choosing water force field
  - choosing size of a solvation shell
  - creating topology and coordinate files
- preparing input files for Amber
  - choosing routine for simulations (full simulations - minimization, heating, equilibration and production or only a single step-simulation)
   - choosing QM/MM parameters
    - option to provide premade QM/MM namelist file
     - choosing basic QM/MM parameters (QM atoms, spin, charge, QM Hamiltonian)
     - changing current and/or adding custom parameters
  - choosing MD parameters
     - default MD parameters for each step are provided
     - changing values of current MD parameters and the ability to add custom ones (though they must work with Amber codes)
- running MD Simulations
  - choosing how simulations should be run - in queue or in terminal
    - if a queue was chosen, user must provide the appropriate script
  - choosing Amber code which will be run - Sander or PMEMD
  - choosing running mode - serial or parallel codes

### Contributing

If you are interested in contributing to MDMS, please either contact me at [szymon.zaczek<EMAIL_ADDRESS>or create pull request on Github.

### License

[MIT](https://github.com/szymonzaczek/MDMS/blob/master/LICENSE)

### Authors

* **Szymon Zaczek**

repository: TosinFrancis/MDMS

repo_name: TosinFrancis/MDMS


text:
dsum
====

dsum is an early prototype for a universal hash integrity checker with an automatic file name parser for commonly checked things.

INFO
====

Currently supports MD5, CRC32, SHA1, SHA224, SHA256, SHA384, SHA512 as well as MD4, MDC2 and RIPEMD160 algorithms.

Classic make (make gcc if you want to use the GCC) ; sudo make install. sudo make uninstall to remove.

Usage is simple, dsum \<Optional hashing method | defaults to MD5\> filename

Licensed under Apache 2.0 so feel free to fork. (Maybe you can make it not garbage. *wink*)

TODO
====

Ability to accept multiple files.

Add the file name parser, currently planned: Videos with CRC data defaulting to CRC32 with an auto "Everything checks out" alert.

Option to embed CRC32 data into the filename of the video.

Pretty the code and docs up.

Coloured output would be nice.

Fix mixed case with OpenSSL related stuff.

repository: DaemonPlus/dsum

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: DaemonPlus/dsum


text:
<img src="https://images.techhive.com/images/article/2013/09/clear-for-ios-7-icon-580-100054611-large.jpg" height="150" width="auto">

# Todoey

A fun color gradient to do list app

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Prerequisites

Have Xcode 9 and above

## Built With

* [Coredata]() - Persisting Data
* [Realm]() - Another Method For Persisting Data
* [SwipeCellKit](https://cocoapods.org/pods/SwipeCellKit) - Cell Animations

## Contributing

Please read [CONTRIBUTING.md]() for details on our code of conduct, and the process for submitting pull requests to us.

## Authors

* **Johnathan Chen** - *Initial work* - [Github](https://github.com/johnathanachen)

## License

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

## Acknowledgments

* Supreme Pizza

license: MIT

repository: johnathanachen/Todoey

repo_name: johnathanachen/Todoey


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# lump.split.pool.ENM

The goal of lump.split.pool.ENM is to facilitate running simulations to
compare different approaches for ecological niche modelling: lumping,
splitting taxa, and fit models that perform partial pooling (GLMM and
PGLMM). See [this paper](https://doi.org/10.1016/j.tree.2018.10.012) or
[these slides](https://doi.org/10.6084/m9.figshare.12479750.v1) for more
information.

## Installation

``` r
remotes::install_github("lump.split.pool.ENM")
```


text:
---
page_title: "Junos: junos_security_ipsec_policy"
---

# junos_security_ipsec_policy

Provides a security IPSec policy resource.

## Example Usage

```hcl
# Add an IPSec policy
resource "junos_security_ipsec_policy" "demo_vpn_policy" {
  name      = "ipsec-policy"
  proposals = ["ipsec-proposal"]
  pfs_keys  = "group2"
}
```

## Argument Reference

The following arguments are supported:

- **name** (Required, String, Forces new resource)
  The name of IPSec policy.
- **description** (Optional, String)
  Text description of IPSec policy.
- **pfs_keys** (Optional, String)
  Diffie-Hellman Group.
- **proposals** (Optional, List of String)
  IPSec proposal list.
- **proposal_set** (Optional, String)
  Types of default IPSec proposal-set.
  Need to be `basic`, `compatible`, `prime-128`, `prime-256`, `standard`, `suiteb-gcm-128` or `suiteb-gcm-256`.

## Attributes Reference

The following attributes are exported:

- **id** (String)
  An identifier for the resource with format `<name>`.

## Import

Junos security IPSec policy can be imported using an id made up of `<name>`, e.g.

```shell
$ terraform import junos_security_ipsec_policy.demo_vpn_policy ipsec-policy
```

repository: jeremmfr/terraform-provider-junos

branch_name: refs/heads/main

gha_language: Go

gha_license_id: MIT

repo_name: jeremmfr/terraform-provider-junos


text:
# Geoo metadata

Model definitions of databases and indexes used across in the Geoo project code-base.

## Usage

Add the following line to `requirements.txt`:

    -e git+https://github.com/deniskolokol/geoo-meta.git#egg=geoometa

repository: deniskolokol/geoo-meta

repo_name: deniskolokol/geoo-meta


text:
# DocuTube Viewer - Addon for Google Docs

---

## Why DocuTube Viewer?

DocuTube Viewer reads your document and finds links to YouTube videos.

DocuTube Viewer loads any linked YouTube video in the document in the sidebar.
You can watch videos without leaving your document! It even includes videos
linked in comments, which is great for student feedback.

![Videos load in a sidebar so you can watch or listen without leaving the document.](img/docutubeWatch1.png)

## What happend to the search tool?

Search caused several issues, specifically when a user tried to open the Addon
without having edit access to the doc. DocuTube Search will be run as a separate
project on GitHub and released as a separate Addon.

## I'm in. Where can I get it?

DocuTube is currently under review for the Google Apps Marketplace, so you can't
install it from there yet. In the meantime, you can copy this repo into your own
script editor and try it yourself.

[Homepage](https://ohheybrian.com/docutube)

[Privacy and Terms](https://dev.ohheybrian.com/privacy/docutube.html)


text:
# GitHub Management

The Kubernetes project uses Github extensively to store and organize code,
manage issues and documentation, and provide a consistent contributor flow.

With the size and growth of the Kubernetes project, management of our GitHub
footprint has historically been a challenge. We have created a number of
policies to reduce friction and ease administration of our GitHub repositories
and organizations. We have also created a number of tools to automate setup and
enforcement of these policies.

These polices are overseen by the
[GitHub Management subproject](subproject-responsibilities.md) of the Contributor
Experience Special Interest Group.

## Guides
- [Opening a request for assistance with GitHub](opening-a-request.md)
- [Organization Owners Guide](org-owners-guide.md)
- [Repository Creation Guidelines](kubernetes-repositories.md)
- [Setting up the CNCF CLA Check](setting-up-cla-check.md)
- [GitHub Permissions](permissions.md)

## GitHub Administration Team

In order to manage the various organizations that the Kubernetes project owns,
we have a GitHub Administration team that is responsible for carrying out the
various tasks.

This team (**[@kubernetes/owners](https://github.com/orgs/kubernetes/teams/owners)**) is as follows:
* Bob Killen (**[@mrbobbytables](https://github.com/mrbobbytables)**, US Eastern)
* Christoph Blecker (**[@cblecker](https://github.com/cblecker)**, CA Pacific)
* Madhav Jivrajani (**[@MadhavJivrajani](https://github.com/MadhavJivrajani)**, Indian Standard Time)
* Nabarun Pal (**[@palnabarun](https://github.com/palnabarun)**, Indian Standard Time)
* Nikhita Raghunath (**[@nikhita](https://github.com/nikhita)**, Indian Standard Time)
* Priyanka Saggu (**[@Priyankasaggu11929](https://github.com/Priyankasaggu11929)**, Indian Standard Time)

This team is responsible for holding Org Owner privileges over all the active
Kubernetes orgs, and will take action in accordance with our polices and
procedures. All members of this team are subject to the Kubernetes
[security embargo policy].

Nominations to this team will come from the Contributor Experience SIG, and
require confirmation by the Steering Committee before taking effect. Time zones
and country of origin should be considered when selecting membership, to ensure
sufficient after North American business hours and holiday coverage.

### Other roles

#### New Membership Coordinator

New Membership Coordinators help serve as a friendly face to newer, prospective
community members, guiding them through the
[process](new-membership-procedure.md) to request membership to a Kubernetes
GitHub organization.

They also have approval privileges for adding new members to the GitHub config.

Our current coordinators are:
TBD

## Project Owned Organizations

The following organizations are currently known to be part of the Kubernetes
project

### Actively used GitHub Organizations

| Name | Description |
| :--: | :---------: |
| [kubernetes](https://github.com/kubernetes) | Core |
| [kubernetes-client](https://github.com/kubernetes-client) | API Client Libraries |
| [kubernetes-csi](https://github.com/kubernetes-csi) | Container Storage Interface Components |
| [kubernetes-nightly](https://github.com/kubernetes-nightly) | Testing org for [publishing-bot](https://github.com/kubernetes/publishing-bot) tooling |
| [kubernetes-retired](https://github.com/kubernetes-retired) | Retired/Archived Projects |
| [kubernetes-security](https://github.com/kubernetes-security) | Private Security Fix Mirror |
| [kubernetes-sigs](https://github.com/kubernetes-sigs) | SIG-related Projects |

### Non-actively used GitHub Organizations

| Name | Description |
| :--: | :---------: |
| [kubernetes-addons](https://github.com/kubernetes-addons) |  |
| [kubernetes-charts](https://github.com/kubernetes-charts) |  |
| [kubernetes-extensions](https://github.com/kubernetes-extensions) |  |
| [kubernetes-federation](https://github.com/kubernetes-federation) |  |
| [kubernetes-graveyard](https://github.com/kubernetes-graveyard) | kubernetes-retired should be used instead going forward |
| [kubernetes-incubator](https://github.com/kubernetes-incubator) | Earlier used for legacy incubator projects |
| [kubernetes-incubator-retired](https://github.com/kubernetes-incubator-retired) | kubernetes-retired should be used instead going forward |
| [kubernetes-providers](https://github.com/kubernetes-providers) |  |
| [kubernetes-sidecars](https://github.com/kubernetes-sidecars) |  |
| [kubernetes-sig-testing](https://github.com/kubernetes-sig-testing) |  |
| [kubernetes-test](https://github.com/kubernetes-test) |  |
| [kubernetes-tools](https://github.com/kubernetes-tools) |  |

Note, this list is subject to change.

There are more organization names that we are squatting on with possible future
intentions. [For more details please see community issue #1407](https://github.com/kubernetes/community/issues/1407).

## Tooling

We have created a number of tools to help with the management of or Github
repositories and organizations:
- [prow](https://git.k8s.io/test-infra/prow): Prow is our system for handling
  GitHub events and commands for Kubernetes. It is comprised of a number of
  modules/plugins. A couple key ones for GitHub management are below, but a full
  list of commands is available [here](https://go.k8s.io/bot-commands)
  - [branchprotector](https://git.k8s.io/test-infra/prow/cmd/branchprotector):
    enforce branch protection settings across an organization
  - [peribolos](https://git.k8s.io/test-infra/prow/cmd/peribolos): Manage Github
    organization and team membership based on a defined YAML configuration
- [label_sync](https://git.k8s.io/test-infra/label_sync): Add, modify, delete,
  and migrate labels across an entire organization based on a defined YAML
  configuration

[security embargo policy]: https://git.k8s.io/security/private-distributors-list.md#embargo-policy

repository: kubernetes/community

gha_language: Jupyter Notebook

repo_name: kubernetes/community


text:
# PyScript Demonstrator

A simple webapp to demonstrate the capabilities of PyScript.

## Getting started

1. If you don't already have Node.js, install it. The official installer for the
   LTS version of Node is available from [nodejs.org](https://nodejs.org/).

2. If you don't already have Rollup, install it. Rollup can be installed as a
   global resource using:

       $ npm install --global rollup

3. Install the demo apps requirements:

       $ npm install

4. Start the server:

       $ npm run dev

   This will compile the resources for the app, and start the development server.

5. When the compilation completes, it will display something like:

         Your application is ready~! 🚀

         - Local:      http://localhost:8080
         - Network:    Add `--host` to expose

       ────────────────── LOGS ──────────────────

   Once this is visible, open a browser at
   [http://localhost:8080](http://localhost:8080). This will provide a list of
   demos that you can run.

## More information

There is a forum PyScript where you can discuss the project or ask questions at [https://community.anaconda.cloud/c/pyscript](https://community.anaconda.cloud/c/pyscript)

gha_language: HTML


text:
---
key: 4
title: Deep Learning
permalink: /deeplearning/
excerpt: As a subset of Machine Learning, Deep learning includes some complex topics which you can learn more about here.
image: deeplearning.jpg
background-image: deeplearning.jpg
---

[![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome)

A collection of awesome Machine Learning and Deep Learning resources.

Contributions are always welcome!

# Resources

- [Resources](#resources)
    - [Courses](#courses)
    - [Tutorials](#tutorials)
    - [Jupyter Notebooks](#jupyter-notebooks)
    - [Books](#books)
    - [Videos](#videos)
    - [Blogs](#blogs)

## Courses

Courses that can you take alongside PyTorch scholarship course both Python and Machine Learning

* [Coursera' Machine Learning Course by Stanford](https://www.coursera.org/learn/machine-learning)

* [Coursera' Deep learning Specialization taught by Andrew Ng](https://www.coursera.org/learn/machine-learning)

* [Introductory courses(few hours each) about Python, ML, Pandas Data Visualisation, SQL, R, Deep Learning, Embeddings, and ML Explainability](https://www.kaggle.com/learn/overview)

* [A Practical Introduction to deep learning](https://www.datacamp.com/courses/deep-learning-in-python)

* [Intro To machine learning by MIT professors.](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-0002-introduction-to-computational-thinking-and-data-science-fall-2016/lecture-videos/lecture-11-introduction-to-machine-learning/)

* [Practical deep learning course. For later on in the challenge, when everyone is comfortable with PyTorch](https://course-v3.fast.ai/)

* [mlcourse.ai is an open Machine Learning course by OpenDataScience. The course is designed to perfectly balance theory and practice; therefore, each topic is followed by an assignment with a deadline in a week. ](https://mlcourse.ai/)

* [François Fleuret course on DL with Pytorch at EPFL](https://documents.epfl.ch/users/f/fl/fleuret/www/dlc/)

* [EDX - Deep Learning with Python and PyTorch](https://courses.edx.org/courses/course-v1:IBM+DL0110EN+3T2018/course/)

* [Udemy - Machine Learning MasterClass](https://www.udemy.com/machine-learning-masterclass/)

## Tutorials

Walkthroughs and tutorials that help you learn ML and PyTorch.

* [Chintala's 60 Minute PyTorch Blitz](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)

* [Pytorch Official List of Tutorials](https://pytorch.org/tutorials/)

* [PyTorch tutorial for beginners](https://github.com/Lplenka/PyTorch-Tutorial)

* [Contains code based tutorial for Pytorch](https://github.com/AyushExel/DeepTorch)

* [An introduction to PyTorch Tensors](https://github.com/TheDataSpartan/PyTorch/blob/master/PyTorch%20Tensor%20Notebook.ipynb)

* [Deep Learning Tutorial - LISA lab, University of Montreal](http://deeplearning.net/tutorial/deeplearning.pdf )

* [Numpy Tutorial - Stanford CS231n](https://cs231n.github.io/python-numpy-tutorial)

* [Kaggle tutorial for deep learning beginners](https://kaggle.com/kanncaa1/deep-learning-tutorial-for-beginners)

## Jupyter Notebooks

* [From basics to building CNN in PyTorch ](https://github.com/Lplenka/PyTorch-Tutorial)

## Books

Books - free and commercial

* [Interactive textbook on Neural Network Fundamentals. Beginner resource](http://cs231n.stanford.edu/)
* [Deep Learning book from Ian Goodfellow and Yoshua Bengio and Aaron Courville](https://www.deeplearningbook.org/)

## Videos

An assortment of conference and training videos.

* [3blue1brown's Channel (Intuitive refreshers in neural networks and linear Algebra))](https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw/playlists)

* [Siraj's Channel (Topics and courses in AI, machine learning, decentralized apps, etc.)](https://www.youtube.com/channel/UCWN3xxRkmTPmbKwht9FuE5A/playlists)

* [But what is a Neural Network? Deep learning, chapter 1](https://www.youtube.com/watch?v=aircAruvnKk&list=PLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi)

* [How to Learn Deep Learning (when you’re not a computer science Ph.D.)](https://vimeo.com/214233053)

* [ML concepts in plain language.](https://www.youtube.com/user/joshstarmer)

* [Deep Learning with PyTorch](https://www.youtube.com/watch?v=v5cngxo4mIg&list=PLZbbT5o_s2xrfNyHZsM6ufI0iZENK9xgG)

* [Deep Learning with PyTorch](https://www.youtube.com/watch?v=v5cngxo4mIg&list=PLZbbT5o_s2xrfNyHZsM6ufI0iZENK9xgG)

* [Introduction to PyTorch. Uses regression, classification and image recognition for teaching concepts such CNNs, FCNs, AutoGrad etc](https://www.youtube.com/playlist?list=PLbMqOoYQ3Mxw1Sl5iAAV4SJmvnAGAhFvK)

* [Intro to Neural Networks](https://www.youtube.com/watch?v=aircAruvnKk)

* [Deep Neural Networks with PyTorch](https://www.youtube.com/watch?v=_H3aw6wkCv0)

## Blogs

* [Neural Network for beginners blog](https://blog.statsbot.co/neural-networks-for-beginners-d99f2235efca)


text:
# PREDICTAD
A machine leaning based tool to identify Transactivation domains

Types of Classifiers: support vector machines, Random forest

Step 1: Cut input sequences (in which prediction is to be done) into same length with an offset of 1 (single amino acid shift forward)
Length in our case: 9 amino acids
Folder name: 1_cut_seq
Program to cut seq into 9aa: prog.pl
NOTE: make sure the input sequences dont have new line characters

Step2: Generate descriptors for the 9 amino acid sequences
Directory name: 2_make_decriptors
Descriptors used: Pseudo amino acid composition (PAAC) & CTDC
R Package used to generate decriptors: PROTR
Scripts in this directory:
	-script.sh 	# this is the MAIN script to run all three scripts below.
		- PAAC.R #to generate PAAC, change input_file name (9aa file) inside.
		- CTDC.R # to generate CTDC, change input_file name (9aa file) inside.
			 # CTDC.R outputs several psysicochemical properteis decriotors. we only use hydrophobicity decriptors from CTDC.tsv file
		- merge_descriptors.pl # merge different discriptors into single file which will be used for classification in step 3.

Running script.sh will generate a file called svm_in.txt. this is the main input file for SVM light package
Note that svm_in.txt has headers of input 9amino acid sequences as the last column. This will help in tracking the results.

IMPORTANT: svm_in.txt file can also be used as input for WEKA as svm_in.dat

Step3: Run svm_classify (PREDICTION)

Directory name: 3_prediction
Essential files: descriptor file in which prediction has to be done: svm_in.txt
				 Trained model file: model.txt (genrated from training sequences)
				 Script to classify: svm_classify (from svm-light)
				 script2.sh: MAIN script to run svm classification. Running this script will generate a result file (result.txt) which will contain the svm scores wrt each input sequence.

		OUTPUT:
		SVM_out: Output of svm_classify. Contains SVM scores with a + or - sign which denotes class label.
		Result.txt : Contains svm result
		Positive_hits.txt : Contains positive hits that were detected

repository: Archanayd/PREDICTAD

repo_name: Archanayd/PREDICTAD


text:
# Gomphidius ochraceus subsp. muscigenus Singer SUBSPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Pap. Mich. Acad. Sci. 32: 149 (1946)

#### Original name
Gomphidius ochraceus subsp. muscigenus Singer

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# windowsgac

#### Table of Contents

1. [Description](#description)
2. [Usage](#usage)

## Description
Adds and removes assemblies in the .NET Framework Global Assembly Cache (GAC)

## Usage
Ensures assembly at path $assemblypath is installed into the GAC

```puppet
windowsgac::gacassembly { $assemblypath:
    ensure => present,
}
```

Ensures assembly at path $assemblypath is not installed into the GAC

```puppet
windowsgac::gacassembly { $assemblypath:
    ensure => absent,
}
```

repository: zappy-shu/puppet-windowsgac

repo_name: zappy-shu/puppet-windowsgac


text:
# ESP32 with I2T Sensors Stack  --  Bluetooth Low Energy - BLE

**ESP32** is one of the microcontrollers for *IoT applications* par excellence. Created and manufactured by *Espressif*, it is currently the microcontroller of this compañy most used by the community, it is widely used for both educational and industrial development due to its great versatility, reliability and very low cost.

This Repository contains the source code and the steps to follow to be able to make ***ESP32 Microcontroller*** read sensor data and send it, in an organized way, to the **[Tangle](https://www.youtube.com/watch?v=ESF8UZM70wU) (DLT)** of the **[IOTA Network](https://www.iota.org/)** through the **[Streams](https://www.iota.org/solutions/streams)** layer.

# Setting up your ESP32 with the I2T Sensors Stack

This is the list of Sensors/Modules that you can connect and it will be recognized immediately.
- ***BME280*** (*Bosch*) - Temperature, Humidity and Pressure sensor. -> Connected by *I2C Bus* via: *GPIO33/SDA* and *GPIO32/SCL* --- Be careful with the supply of this sensor, the BM280 is powered with 3.3V, if your module does not have a voltage regulator (some modules do not have it) the sensor can be damaged if you supply 5V.
- ***MPU6050*** (*InvenSense-TDK*) - Acelerometer and Gyroscope 6-axis. -> Connected by *I2C Bus* via: *GPIO33/SDA* and *GPIO32/SCL*.
- ***BH1750*** (*ROHM*) - Ambient Light Sensor. -> Connected by *I2C Bus* via: *GPIO33/SDA* and *GPIO32/SCL*.
- ***Generic Adjustable Sound Sensor with digital output*** (like *KY038 Module*) - -> Digital Signal on *GPIO21*, *GPIO22* to GND (to enable sound data collection).
- Also, you can connect a ***Green LED*** in *GPIO2* that blink when the data is sent to the Tangle, and a ***Red LED*** in *GPIO15* that will Blink in a certain way when it detects certain errors (totally optional)

## Connecting the sensors

The following diagram explains how each sensor of our stack must be connected to the ESP32 pins. The "NodeMCU-32s" development board has been used in this diagram, which contains the ESP32 microcontroller. However, any development board that contains the ESP32 microcontroller can be used.

![I2T Sensors Stack on ESP32](https://iot2tangle.io/assets/screenshots/ESP32-I2T.png)

**It is not necessary to have all the sensors listed here**, the code is able to detect which sensors were connected. In the case of not connecting any sensor, the only real data that will be displayed on the Tangle will be the Internal Temperature of *ESP32*.

***IMPORTANT NOTE:*** *Espressif has deprecated the ESP32's internal temperature sensor a few years ago, as it has proven not to be a very accurate measurement. However we will use it as a minimum unit of information to be able to send data to the Tangle without having sensors connected. Please keep this in mind, so this value should not be taken into account for critical applications.*

# Download Firmware on ESP32
This repository uses the ***Iot2Tangle C Core devices*** adapted for ***ESP32-FreeRTOS*** offered in the official *Espressif Toolchain ESP-IDF SDK*. Once the SDK is installed you will have all the tools to compile and download the program on your ESP32.

## 1) Install ESP-IDF SDK:
### Windows:
The easiest way to install ESP-IDF and their prerequisites is to download the ***ESP-IDF Tools Installer*** from this URL:
<https://dl.espressif.com/dl/esp-idf-tools-setup-2.3.exe>

Just follow the steps and you will have the official *Espressif SDK Toolchain* installed on your computer.

To check other methods, the following page is suggested:
<https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/windows-setup.html>

### Linux and macOS:
Prerequisites of ESP-IDF SDK:
```
sudo apt update
sudo apt install git wget flex bison gperf python python-pip python-setuptools cmake ninja-build ccache libffi-dev libssl-dev
```
It is recommended to install the stable version: ESP-IDF v4.1, you can download it from here:
```
git clone -b v4.1 --recursive https://github.com/espressif/esp-idf.git
```
Now install the SDK, this may take a while:
```
cd ~/esp-idf
./install.sh
. ./export.sh
```
After doing this last step do not close the shell, as we will compile and flash from here. If you close the shell you will have to do the previous step again.

## 2) Download the Iot2Tangle ESP32 Repository and go to the 'BLE-sender' folder:
You can download the repository directly from Github, or from shell or Command Prompt with the following command:
```
git clone https://github.com/iot2tangle/ESP32.git
cd ESP32/BLE-sender
```
## 3) Edit the file config.h (Optional)
The *config.h* file is in the directory *'ESP32/BLE-sender/main'* of the repository.

This step is not as important as in projects that use WiFi, since in this case we must not connect to any network, the same device is a BLE server and the Gateway will have to READ the device data.

In this file we can configure the NAME of the device with which the BLE server will be named, enable or disable Sensors and finally set the local data update interval, unlike HTTP or MQTT senders, this interval only updates the data locally (therefore it can be smaller than in the named cases), since the sending data interval to the Tangle is determined by the BLE Gateway, not by the ESP32).
```
/* Device */
const char* id_name = "ESP32-BLE-I2T";

/* Enable Sensors */
bool isEnable_Environmental = true;
bool isEnable_Acoustic = true;	/*                     true: Enable  --  false: Disable                            */
bool isEnable_Light = true;		/* If the sensor is disabled the data about it will not be displayed in the Tangle */
bool isEnable_Accelerometer = true;
bool isEnable_Gyroscope = true;

/* Interval of time for Data Update */
long interval = 6;    /* Time in seconds */
```

## 4) Compile and Download the Firmware:
Remembering to have the ***ESP-IDF Toolchain*** open, and you make sure you are at the root of the *BLE-sender* folder run the following command:
```
idf.py build
```
If the compilation was correct it should read: *Project build complete*.

Now make sure you have ESP32 connected to your computer, and know what COM port it is connected to. (You can see this in 'Device Manager').

Then run the following command that will start flashing the firmware. (You will probably have to press the reset button on your ESP32 development board, even several times for it to recognize the board.)
```
idf.py -p COM1 flash    # COM1 is an Windows port example, you must put your port. In Linux /dev/ttyUSB0 is an example, and in macOS: '/dev/cu'
```

Upon completion, the firmware is downloaded to your ESP32. If the *I2T Streams BLE Gateway* is configured correctly (we will explain this next), ***you will be sending data to Tangle via Streams***.

# Debugging
If configured correctly, *ESP32* will create a BLE Server to which the BLE Gateway can connect to READ the data every time interval set in the Gateway configuration. However, you may want to verify that it is running on *ESP32*.

## Serial Port
The code continuously sends information out the **serial port**, so it can read the serial port to see what is happening and detect errors.

You can use the 'Arduino Serial Monitor' for this, but we recommend using the following software:
### Windows:
Open *Command Prompt*.

Configure the Baud Rate of the port to 115200 bps:
```
mode COM1: baud=115200
```
Read the serial port:
```
copy COM1: con:
```
### Linux and macOS:
Install *cu Monitor*. It is an excellent shell monitor and very useful.
```
sudo apt install cu
```
Run *cu Monitor*:
```
cu -l /dev/ttyUSB0 -s 115200
```

The following screenshot is a reading of the *Serial Port*, you should see something like this:

![Raspberry with BME280 sending data to the Tangle](https://i.postimg.cc/cH6TWpXP/Screenshot-from-2020-10-16-11-33-05.png)

## Read BLE Services and Characteristics
You may also want to read the data directly from the *BLE Server*. For this there are Free OpenSource software.

We recommend ***nRF Connect*** (free OpenSource software) of *NordicSemiconductor* available in [Desktop](https://www.nordicsemi.com/Software-and-tools/Development-Tools/nRF-Connect-for-desktop): on Windows, macOS and Linux. And in [Mobile](https://www.nordicsemi.com/Software-and-tools/Development-Tools/nRF-Connect-for-mobile): on Android and iOS (The mobile version is very simple and more comfortable to debug).
It only needs to be connected to the *ESP32 BLE Server* and it will be able to read the data from the sensors found in the Characteristics Values

Note that when you have a device connected to ESP32 BLE the Gateway will not be able to read the data.

## Set Harcoded Data
In the event that you do not have any *I2T Stack Sensors* sensor, you will only see the *Internal Temperature* data of the *ESP32*. If you like, you can compile with a **'flag'** that assigns hardcoded values to all available data. This way you can see numerically more complete outputs on the Tangle.
You just need to modify the file ```ESP32/BLE-sender/main/CMakeLists.txt``` and add the ```-DTEST``` flag.
```
add_definitions (-DESP32 -DMICROCONTROLLER -DSHELLPRINT -DTEST)
```
This way, you can see data in the Tangle as if you had all the sensors.

# Setting up the Streams BLE Gateway

## Preparation

Install Rust if you don't have it already. More info about Rust here https://www.rust-lang.org/tools/install

```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

Make sure you also have the build dependencies installed, if not run:

```
sudo apt update
sudo apt install build-essential pkg-config libssl-dev libdbus-glib-1-dev
```

## Installing the Streams BLE Gateway
### Clone the repository
Get the Streams MQTT Gateway repository
https://github.com/iot2tangle/Streams-BLE-gateway
```
git clone https://github.com/iot2tangle/Streams-BLE-gateway
cd Streams-BLE-gateway
```
## Scan the BLE Server (ESP32 BLE Server in our case)
Here you will get the address of your *ESP32 BLE device* (similar to the MAC address). You should make a note of it, as we'll put that address in the *config.json* file later in the next step.

Run the following to scan and get the address of your ESP32.
```
cargo run --release --bin scan
```

## Edit *config.json* file
Navigate to the root of **Streams-MQTT-gateway** directory and edit the **config.json** and copy the *address* obtained in the previous step.

Here you can also configure the time interval with which the GW will read the data to the BLE Devices and send the data to the Tangle, also the node, amoung other settings.
```
{
    "device_ids": [
        "XX:XX:XX:XX:XX:XX"
    ],
    "reading_interval": 30,
    "node": "https://nodes.iota.cafe:443",
    "mwm": 14,
    "local_pow": false
}
```
## Start the Streams BLE Server

### Sending messages to the Tangle

Run the Streams BLE Gateway:

```
cargo run --release --bin ble-gateway
```

This will compile and start the *Streams BLE Gateway*. Note that the compilation process may take from 3 to 25 minutes (Pi3 took us around 15/25 mins, Pi4 8 mins and VPS or desktop machines will generally compile under the 5 mins) depending on the device you are using as host.
You will only go through the compilation process once and any restart done later will take a few seconds to have the Gateway working.

Once started, the ***Channel Id*** will be displayed, and the gateway will be open waiting for data to send to the Tangle.

![Streams Gateway receiving data](https://i.postimg.cc/pVmbty9s/Screenshot-from-2020-10-16-19-05-09.png)
*The Channel Id that will allow subscribers to access the channel data.*
### Reading messages from the Tangle

You can read the received messages directly from the **I2T Explorer**: https://explorer.iot2tangle.io/ using the Channel Id printed by the Gateway in shell.

![I2T Explorer](https://i.postimg.cc/wTNf7dgp/Screenshot-from-2020-10-16-11-46-16.png)

*For inquiries, improvements or errors detected, please start an issue in this repository.*

gha_language: C


text:
Some textures provided in this resource pack are from the Minecraft Java Edition client jar. GeyserMC does not claim ownership of these textures -
these are all created and owned by Mojang.

The Minecraft EULA (https://account.mojang.com/documents/minecraft_eula) cites:

> If you've bought the Game, you may play around with it and modify it by adding modifications, tools, or plugins,
which we will refer to collectively as "Mods." By "Mods," we mean something original that you or someone else created
that doesn't contain a substantial part of our copyrightable code or content. When you combine your Mod with the Minecraft software,
we will call that combination a "Modded Version" of the Game. We have the final say on what constitutes a Mod and what doesn't.
You may not distribute any Modded Versions of our Game or software, and we’d appreciate it if you didn’t use Mods for griefing.
Basically, Mods are okay to distribute; hacked versions or Modded Versions of the Game client or server software are not okay to distribute.

Any textures included in this resource pack are contingent on the "substantial" part. As only a fraction of the content here revolves around Mojang property,
we consider it not "substantial".

repository: Kas-tle/imaginefun-bedrock-rp

repo_name: Kas-tle/imaginefun-bedrock-rp


text:
---
layout: default
---

# 1995-09-19 - Re: "Hackers"-- brief review and anecdote...

## Header Data

From: "Rev. Mark Grant"<EMAIL_ADDRESS>To: Brian Davis<EMAIL_ADDRESS>Message Hash: c30ca267895407344d3555680bc58dd9fba2002ce0c271fa8a3c041cec705ed9

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-09-19 17:14:30 UTC

Raw Date: Tue, 19 Sep 95 10:14:30 PDT

## Raw message

```
{% raw  %}From: "Rev. Mark Grant"<EMAIL_ADDRESS>Date: Tue, 19 Sep 95 10:14:30 PDT
To: Brian Davis<EMAIL_ADDRESS>Subject: Re: "Hackers"-- brief review and anecdote...
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

On Sun, 17 Sep 1995, Brian Davis wrote:

> Phill obviously presents one point of view, vigorously and well.  What do
> the rest of you think about a teen who, say, busts into a .edu site,
> plays with the files, and ultimately brings the system down entirely for
> 36 hours?  Fun and games?  Send him to his room, sans modem? Prosecute
> him?  Have a TLA hire him???

If it wasn't for ITAR the Net would already have secure encryption and
authentication, and most such hacker attacks would be impossible (or at
least impractical).

		Mark

{% endraw %}
```

## Thread

+ Return to [September 1995](/archive/1995/09)

+ Return to "[Brian Davis <bdavis@thepoint.net>](/authors/brian_davis_bdavis_at_thepoint_net_)"
+ Return to "["Daniel C. Cotey" <dccotey@eclat.uccs.edu>](/authors/daniel_c_cotey_dccotey_at_eclat_uccs_edu_)"
+ Return to "["Rev. Mark Grant" <mark@unicorn.com>](/authors/rev_mark_grant_mark_at_unicorn_com_)"
+ Return to "[sameer <sameer@c2.org>](/authors/sameer_sameer_at_c2_org_)"

+ 1995-09-19 (Tue, 19 Sep 95 10:14:30 PDT) - Re: "Hackers"-- brief review and anecdote... - _"Rev. Mark Grant"<EMAIL_ADDRESS>  + 1995-09-19 (Tue, 19 Sep 95 10:54:27 PDT) - [Re: "Hackers"-- brief review and anecdote...](/archive/1995/09/0b51cb206179791022206fd3d1838ec7150add90195e6059c2d5573b0b4b34bd) - _Brian Davis<EMAIL_ADDRESS>    + 1995-09-19 (Tue, 19 Sep 95 11:34:23 PDT) - [Re: "Hackers"-- brief review and anecdote...](/archive/1995/09/e450b101b31b2cf3e18dbdc07c1bc2d9e77e8f3e168ae9a700097bc8a36fd2b3) - _sameer<EMAIL_ADDRESS>  + 1995-09-19 (Tue, 19 Sep 95 13:50:03 PDT) - [Re: "Hackers"-- brief review and anecdote...](/archive/1995/09/b769551de9fe51345ebe6a361d73a4b152b8980b440433bdaa22f2c8a61c1ebb) - _"Daniel C. Cotey"<EMAIL_ADDRESS>


text:
---
layout: post
title: "React Native: How to implement a simple input form"
desc: "Learn how to implement a simple input form in React Native. We are going to cover a text input component and how to build our own custom button."
keywords: "React Native, Submit form, Input Form, TextInput, TouchableOpacity, Keyboard dismiss, Mobile development, iOS, Android, JavaScript"
tags: [ReactNative, BlitzReading]
excerpt_separator:
---

Sooner or later we need to get a custom input from a user.
In that case, we need to render one or several fields and allow the user to provide us with the data.
Then, we need to process that data.

Today I would like to see how can we implement the simplest possible input form.
We are going to ask the user's name and save it.

As a playground, I would use a mobile application we've been started to build [in the previous articles](http://whatdidilearn.info/tags#BlitzReading).

In that application, we have a settings screen which is blank at the moment.
We are going to add items in there.

Here is the source of the current implementation of that screen.

```jsx
// src/screens/SettingsScreen.js
import React, { Component } from 'react';
import { Button, StyleSheet, Text, View } from 'react-native';

export default class SettingsScreen extends React.Component {
  render() {
    return (
      <View style={styles.container}>
        <View>
          <Text style={styles.header}>Settings</Text>
        </View>
      </View>
    );
  }
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    paddingTop: 45,
    backgroundColor: '#F5FCFF',
  },
  header: {
    fontSize: 25,
    textAlign: 'center',
    margin: 10,
    fontWeight: 'bold'
  }
});
```

Let's start by rendering a text input on the screen.

## TextInput

The `TextInput` is a basic element which allows users to input some text.

Right next to our "Settings" header, let's add the following code.

```jsx
<ScrollView>
  <View style={styles.inputContainer}>
    <TextInput
      style={styles.textInput}
      placeholder="Your name"
      maxLength={20}
    />
  </View>
</ScrollView>
```

We are going to use `ScrollView` as a container for our future input components.
That will make a content scrollable, in case the form gets bigger than a screen.

To learn more about `ScrollView` you can review [the previous article](http://whatdidilearn.info/2018/12/09/react-native-how-to-use-flatlist.html#scrollview) article.

Inside the `ScrollView` we use a `View` component. It will play a role of wrapper around our form inputs.
We will be able to specify the common styles for all the input components, such as padding between them etc.

The container contains a `TextInput` component to capture the user's input.
We also provide a placeholder text and maximum text length properties.

To make it work, we need to import `TextInput` and `ScrollView` at the top of the file.

```jsx
import {
  // ...
  ScrollView,
  TextInput
} from 'react-native';
```

Currently, the input has no styles. Let's add a bunch of them into the existing `StyleSheet.create`.

```jsx
inputContainer: {
  paddingTop: 15
},
textInput: {
  borderColor: '#CCCCCC',
  borderTopWidth: 1,
  borderBottomWidth: 1,
  height: 50,
  fontSize: 25,
  paddingLeft: 20,
  paddingRight: 20
}
```

The result of those changes you can see in the screenshot below.

Before we move to the implementation of the submit button, let's do a small improvement.

Once a text input gets focused, the mobile application displays a keyboard to enter data into the input.
When the keyboard is shown, it stays open and the user cannot get rid of it.
Sometimes, that can be annoying.

The user should be able to hide a keyboard when it's not needed.
For example, we can dismiss the keyboard when the user clicks somewhere outside the text input.

How do we know that the user clicks outside?
When the user clicks outside, the input field will lose its focus.

An `onBlur` callback can help us in that case.
To hide a keyboard we need to call the `dismiss()` function of the [`Keyboard`](https://facebook.github.io/react-native/docs/keyboard) module.

```jsx
import {
  // ...
  Keyboard
} from 'react-native';

// ...

<TextInput
  style={styles.textInput}
  placeholder="Your name"
  maxLength={20}
  onBlur={Keyboard.dismiss}
/>
```

Now, we can hide a keyboard every time we don't need it.

Now, we have a text input. The user can provide a name.
As the next step, the user should be able to save the name.
We are going to save the value when the user taps on a "Save" button.

You are probably familiar with [a `Button` component](https://facebook.github.io/react-native/docs/button).
We were using it in previous articles.

The issue with the button component is that it doesn't provide too much options to customize itself.
When we want buttons to look different, we can build our custom buttons using a [`TouchableOpacity`](https://facebook.github.io/react-native/docs/touchableopacity) component.

## TouchableOpacity

By using a [`TouchableOpacity`](https://facebook.github.io/react-native/docs/touchableopacity) component, we can define an area with custom children.

Let's implement our "Save" button using that approach.

As usual, we need to import the component we are about to use.

```jsx
import {
  // ...
  TouchableOpacity
} from 'react-native';
```

Then we add our future button right next to the text input

```jsx
<View style={styles.inputContainer}>
  <TouchableOpacity
    style={styles.saveButton}
  >
    <Text style={styles.saveButtonText}>Save</Text>
  </TouchableOpacity>
</View>
```

and its styles

```jsx
saveButton: {
  borderWidth: 1,
  borderColor: '#007BFF',
  backgroundColor: '#007BFF',
  padding: 15,
  margin: 5
},
saveButtonText: {
  color: '#FFFFFF',
  fontSize: 20,
  textAlign: 'center'
}
```

That's how the button should look.

We have a button and a text input.
Now we need to grab the value of text input and save it when the users click the button.

In HTML, form inputs maintain their own state.
React components need to keep that state in the state property and update it using `setState()`.

Before we can grab the input's value, we need to store it in the state property.

We can do that by updating the state every time the user changes the value of that input.

Let's update our `TextInput` to read the value from the state and call `onChangeText` callback.

```jsx
<TextInput
  style={styles.textInput}
  placeholder="Your name"
  maxLength={20}
  onBlur={Keyboard.dismiss}
  value={this.state.name}
  onChangeText={this.handleNameChange}
/>
```

Then, we need to define the callback function.

```jsx
handleNameChange(name) {
  this.setState({ name });
}
```

Then, define the constructor with the initial state and bind `this` context to the `handleNameChange()` function.

```jsx
constructor(props) {
  super(props);

  this.state = { name: '' }

  this.handleNameChange = this.handleNameChange.bind(this);
}
```

After these changes, our input will update its state every time we change the text inside.

Now, we know the value of the text input, let's grab it and store when the user clicks on the button.

Add an `onPress` callback.

```jsx
<TouchableOpacity
  style={styles.saveButton}
  onPress={this.handleSubmit}
>
  <Text style={styles.saveButtonText}>Save</Text>
</TouchableOpacity>
```

Then, bind the `this` context in the constructor body

```jsx
constructor(props) {
  // ...
  this.handleSubmit = this.handleSubmit.bind(this);
}
```

and define the callback itself.

```jsx
handleSubmit() {
  saveSettings(this.state);
}
```

What we wanna do, is to grab the state and persist it in the local storage.
When the user submits the form, we call a `saveSettings` function and pass the current state as an argument.

The `saveSettings` function doesn't exist yet.
Let's define it.

Create a `src/storage/settingsStorage.js` file with the following content.

```jsx
import { AsyncStorage } from 'react-native';

const STORAGE_KEY = 'SETTINGS';

export const saveSettings = (settings) => {
  AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
}
```

If you want to get more familiar with the `AsyncStorage` you can review the ["Local data persistence using AsyncStorage"](http://whatdidilearn.info/2018/11/25/local-data-persistence-in-react-native-using-asyncstorage.html) article.

That function receives an object and store the serialized version of it on a mobile device.

To make it work, we need to import the `saveSettings` function from the `settingsStorage` file.

```jsx
import { saveSettings } from '../storage/settingsStorage';
```

Now, every time the user touches the button, we are updating the local storage with the user's name.

That implementation wouldn't be complete without loading stored data.

Let's add another function to the `settingsStorage.js` file.

```jsx
const DEFAULT_SETTINGS = {
  name: ''
};

export const loadSettings = async () => {
  try {
    let settings = await AsyncStorage.getItem(STORAGE_KEY);

    if (settings === null) { return DEFAULT_SETTINGS; }

    return JSON.parse(settings);
  } catch (error) {
    console.log('Error loading settings', error);
  }
}
```

This time, we are loading the settings data. We also return empty settings when data doesn't exist.

Now, back to the `src/screens/SettingsScreen.js` file. Let's import that function

```jsx
import {
  loadSettings,
  saveSettings
} from '../storage/settingsStorage';
```

and call it in the `componentDidMount()` callback, so it will update the state of the component:

```jsx
async componentDidMount() {
  const initialState = await loadSettings();

  this.setState(initialState);
}
```

Once we did all these changes, our settings page loads the data from the local storage and saves it back when we click the "Save" button.

## Wrapping up

We've just covered the fundamentals of creating a simple form in React Native.
Of course, there is a room for improvement.
For the sake of example, we described the form with the single input.
Usually, input forms contain more fields as well as input validation.
We will cover these parts in one of the next articles.

You can find the complete implementation on [the GitHub page](https://github.com/ck3g/BlitzReading/pull/6) of the project.

See you next time.


text:
# For the Win #

This project is a small set of Rake tasks to automate the process of building
MSI packages for Puppet on Windows systems.

# Screen Shots #

The following screen shots show the current state of the graphical installer.
These screen shots are generated automatically.

![Screen 0](http://dl.dropbox.com/u/17169007/img/screenshot_1330473784_1.png)
![Screen 1](http://dl.dropbox.com/u/17169007/img/screenshot_1330385269_1.png)
![Screen 2](http://dl.dropbox.com/u/17169007/img/screenshot_1330385269_2.png)
![Screen 3](http://dl.dropbox.com/u/17169007/img/screenshot_1330385269_3.png)
![Screen 4](http://dl.dropbox.com/u/17169007/img/screenshot_1330385269_4.png)

## Shortcut Icons ##

The current icon being used looks like this:

![Icons](http://dl.dropbox.com/u/17169007/img/screenshoot_1331337674_0_icons.png)

## UAC Integration ##

When running Puppet and Facter interactively using the Start Menu shortcuts,
the process will automatically request Administrator rights using UAC:

![UAC Prompt](http://dl.dropbox.com/u/17169007/img/screenshot_1330369084_0_UAC.png)

## Command Prompt ##

A shortcut named "Start Command Prompt with Puppet" will be created in the
Start Menu.  This shortcut automates the process of starting `cmd.exe` and
manually setting the `PATH` and `RUBYLIB` environment variables.

This command windows looks like this:

![Start Command Prompt with Puppet](http://dl.dropbox.com/u/17169007/img/screenshot_1330411423_shell.png)

# Overview #

This is a separate repository because it is meant to build MSI packages for
arbitrary versions of Puppet, Facter and other related tools.

This project is meant to be checked out into a special Puppet Windows Dev Kit
directory structure.  This Dev Kit will provide the tooling necessary to
actually build the packages.

This project requires these tools from the `puppetbuilder` Dev Kit for Windows
systems.

 * Ruby
 * Rake
 * Git
 * 7zip
 * WiX

# Desktop Integration #

Puppet and Facter can be run directly from the Explorer desktop by double
clicking on `run_puppet_interactive.bat` and `run_facter_interactive.bat`.
Shortcuts in the Start Menu will be added for these batch files.

These batch files are not meant to be run from other scripts or the Task
Scheduler because they explicitly pause at the end to give the user a chance to
review the output without `cmd.exe` vanishing on them.  This looks like:

![Run Facter Interactive](http://links.puppetlabs.com/ftw_msi_facter_interactive_1a.png)

# Getting Started #

Given a basic Windows 2003 R2 x64 system with the [Puppet Win
Builder](http://links.puppetlabs.com/puppetwinbuilder) archive unpacked into
`C:/puppetwinbuilder/` the following are all that is required to build the MSI
packages.

    REM Not found "build.bat"? make a copy of "build_example.bat" yourself.
    C:\>cd puppetwinbuilder
    C:\puppetwinbuilder\> build
    ...

 **`build` will use 'config.yaml' in 'src/puppet_for_the_win' as default configuration, you can use the following command to choose your configuration file, we use 'foss-stable.yaml' in this case**

    C:\cd puppet_for_the_win\src\puppet_for_the_win
    C:\puppetwinbuilder\src\puppet_for_the_win> rake windows:build config=foss-stable.yaml

Use [build.bat](build.bat), you can specify certern configuration file as below

    C:\puppetwinbuilder\> build config=foss-stable.yaml

(REVISIT - This is the thing we're working to.  Make sure this is accurate once
implemented)

### Note ###

The version of Git included in this toolchain may be older than the one that is
locally configured.  The initial bootstrap of Git repositories may fail due to
newer configuration in the local `.gitconfig` file.  For example, if Git is
configured with `simple` for the `push` configuration option, `BUILD.cmd` may fail.
Adjust the users `.gitconfig` accordingly.

# Making Changes #

The [Puppet Win Builder](http://links.puppetlabs.com/puppetwinbuilder) archive
should remain relatively static.  The purpose of this archive is simply to
bootstrap the tools required for the build process.

Changes to the build process itself should happen in the [Puppet For the
Win](https://github.com/puppetlabs/puppet_for_the_win) repository on Github.

# Continuous Integration #

The `BUILD.cmd` build script _should_ work just fine with a build system like
Jenkins.  If it does not, please let us know.

# Building from Specific Repositories and Branches #

The build system can be used to build a specific branch or repository of Puppet
and Facter.  To customize the Git reference to build you can first specific the
repositories to clone with the `windows:clone` task and then specify the
reference to checkout using the `windows:checkout` task.

This example builds a package given the latest development heads of the 2.7.x
and 1.6.x integration branches.

    rake clean
    rake "windows:clone[git://github.com/puppetlabs/puppet.git,git://github.com/puppetlabs/facter.git]"
    rake "windows:checkout[refs/remotes/origin/2.7.x,refs/remotes/origin/1.6.x]"
    rake windows:build

# User Facing Customizations #

## Installation Directory CLI ##

The command line installation UX is implemented using the public `INSTALLDIR`
property.

The installation directory may be specified on the command line by passing the
property.  This example logs verbosely to the `install.txt` file and performs a
silent installation to `C:\test\puppet` which is not the default.

    msiexec /qn /l*v install.txt /i puppet.msi INSTALLDIR="C:\puppet" PUPPET_MASTER_SERVER="puppetmaster.lan"

# Public Properties #

All of these are optional and their default values are in parentheses.

 * `INSTALLDIR` (`"%PROGRAMFILES%\Puppet Labs\Puppet"`)
 * `PUPPET_AGENT_CERTNAME` (Unset, Puppet will default to using `facter fqdn`)
 * `PUPPET_MASTER_SERVER` ("puppet")
 * `PUPPET_CA_SERVER` (Unset, Puppet will default to using
   `PUPPET_MASTER_SERVER`)

If the `PUPPET_AGENT_CERTNAME` property is not set on the command line when
installing the package, then no `certname` setting will be written to
`puppet.conf`.  There is no ability provided to configure the certificate name
using the graphical installer, `puppet.conf` must be configured
post-installation.  Please see [Ticket
12640](http://projects.puppetlabs.com/issues/12640) for information about why.

The value of `PUPPET_AGENT_CERTNAME` must be lower case as per [Ticket
1168](http://projects.puppetlabs.com/issues/1168)

# Add Remove Programs #

The installer is integrated well with the Add or Remove Programs feature of
Microsoft Windows.  The following screen shots show the current look:

![Add Remove Programs 1](http://dl.dropbox.com/u/17169007/img/screenshot_1329854437_5.png)
![Add Remove Programs 2](http://dl.dropbox.com/u/17169007/img/screenshot_1329854437_6.png)
![Add Remove Programs 3](http://dl.dropbox.com/u/17169007/img/screenshot_1329854437_7.png)

# Puppet Enterprise Facts #

Facts required to connect a Windows Puppet agent to a Puppet Enterprise master
are automatically written to Puppet's confdir.  The facts will be stored in
`%COMMON_APPDATA%/PuppetLabs/facter/facts.d/puppet_installer.txt`

These facts are written for both the Puppet FOSS and Puppet Enterprise branded
installation package.  The following entries are written by default by the
installer and may be changed after the package has been installed.

    fact_stomp_port=61613
    fact_is_puppetagent=true
    fact_is_puppetmaster=false
    fact_is_puppetconsole=false

The stomp server fact defaults to the puppet master hostname specified in the
graphical installer, or using the `PUPPET_MASTER_SERVER` property in the
command line installer.

    fact_stomp_server=puppet

The stomp server and stomp port facts are put in place for future support of
MCollective on Windows.  These facts will not be used until MCollective support
has been added to the Windows packages.

# Remembered Properties #

The Puppet and Puppet Enterprise installers will write the values of user
specified public properties into the following registry paths:

    HKLM\Software\Puppet Labs\PuppetInstaller
      RememberedInstallDir          = INSTALLDIR
      RememberedPuppetMasterServer  = PUPPET_MASTER_SERVER
      RememberedPuppetAgentCertname = PUPPET_AGENT_CERTNAME
      RememberedPuppetCaServer      = PUPPET_CA_SERVER

When the Puppet Enterprise MSI is in an upgrade scenario and is replacing
Puppet FOSS these properties will be "recalled" and filled in as the default
settings in the GUI.  If you are running `puppetenterprise.msi` and you notice
it's automatically filled in the value you previously used for Puppet, this is
how it's getting that information.

# Puppet Configuration Settings #

The MSI package will configure the `archive_files` and `archive_file_server`
settings for Puppet Enterprise.  These configuration settings enable `puppet
inspect` to save files centrally on the Puppet Master to enable the diff view
in the Puppet Enterprise Console.  These two settings are not set when
installing the Puppet FOSS package to match the behavior of Puppet FOSS on
other platforms.

The Puppet Enterprise MSI package also configures `graph=true` to help
visualize the configuration catalog.  This is not set for Puppet FOSS to be
consistent with other platforms.

    C:\ProgramData\PuppetLabs\puppet\etc>more puppet.conf
    [main]
    server=puppetmaster.vm
    pluginsync=true
    autoflush=true
    archive_files=true
    archive_file_server=puppetmaster.vm
    graph=true

# Troubleshooting #

## Missing .NET Framework ##

If you receive exit code 128 when running rake build tasks and it looks like
`candle` and `light` don't actually do anything, it's likely because the
Microsoft .NET Framework is not installed.

If you try to run `candle.exe` or `light.exe` from Explorer, you might receive
"Application Error" - The application failed to initialize properly
(0xC0000135). Click on OK to terminate the application.  This is the same
symptom and .NET should be installed.

In order to resolve this, please use Windows Update to install the .NET
Framework 3.5 (Service Pack 1).

EOF

extension: markdown


text:
---
added: 2017-01-29 17:39:38+00:00
creators:
- email<EMAIL_ADDRESS>  name: Nick Ruest
dates:
- end: '2017-01-28'
  start: '2017-01-12'
published: 2017-01-29
repository: Scholars Portal Dataverse
subjects:
- Women
- Activism
- Politics
title: '#WomensMarch tweets January 12-28, 2017'
tweets: 14478518
url: http://dx.doi.org/10.5683/SP/ZEL1Q6
---

14,478,518 tweet ids for #WomensMarch collected with Documenting the Now's twarc from January 21-28, 2017. Tweets can be "rehydrated" with Documenting the Now's twarc (https://github.com/DocNow/twarc). twarc.py –hydrate WomensMarch_tweet_ids.txt > WomensMarch.json Also included are the logs files for the Filter API and Search API queries. The Filter API query captures the cumulative number of dropped tweets.

repository: remagio/catalog

repo_name: remagio/catalog


text:
\page lightmap Creating and using light maps

This example shows how to bake light maps in Blender and apply the light map texture in Ignition.

## Light maps

What is baked lighting?

  * Baked lighting is pre-calculated/rendered lighting information from realtime lighting. These bakes are often called light maps.

Why are light maps useful?

  * Light maps allow you to add global illumination, shadows, and ambient lighting at a relatively low computational cost.

## Baking Light maps in Blender

In Blender you can bake light map information fast and efficiently with its built in renderers. For this workflow we will be using cycles renderer.

### Step 1: Create or import model for your scene

To import a model go to `file` > `import` > (choose file type of model)

@image html img/lightmap_import.png

### Step 2: UV Mapping

The next step is to create UV unwraps for your model. In Blender usually the first UVmap for any mesh created is for PBR textures and the second UV channel is for light map information. This secondary UV set is different from the UVs used to map things like color maps or normal maps because each polygon surface is receiving different lighting from all other polygons so each UV coordinate also needs to be unique.

For a fast automatic light map unwrap hit F3 and then search for “Lightmap pack”.
Make sure to the “margin” is set to 1 for max distance between faces (reduces shadow bleeding during bake)

@image html img/lightmap_unwrap.png

### Step 3: Creating texture for model

With the model selected in “Object Mode” select the “Texture Paint” tab at the top of the tool bar and create a “new texture” for the model (make sure the Alpha is checked off).

This new texture should be applied to the Light Map specific UV island that was created in step 2

If the texture is black use the color picker and select the UV island and it should turn white (easier to see the baked shadows).

@image html img/lightmap_new_texture.png

### Step 4: Material setup / Baking

In order to have the texture show the baked lighting we must assign it to a new material. With your model selected open the Shader tab and select `Add` > `Image` > `Image texture`. This will create a new image texture node.
* Add an image texture
* Connect the color from the image node to the base color of the material color (principled BSDF)

After this step add another image texture in the shader editor
* Give this one a new name (ex: MeshLightBake)

@image html img/lightmap_material_shader.png

@image html img/lightmap_bake.jpg

Now that the material node is set up, open the render properties and make sure that the cycles renderer active in the render engines drop down.
Scroll down to where it says bake, and then with the second image node selected (MeshLightBake) hit bake. Blender should now start baking the light map for the model.

### Step 5: Show Baked Lighting

After the bake is finished you should have a separate light map of your model.
* To see it applied real time in your scene, go back to the hypershade / materials editor. Click on the Image texture that has the baked light map information and connect it to the base color.

@image html img/lightmap_material_connection.jpg

Model with baked in lighting (Blender Viewport Shading turned on):

@image html img/lightmap_rendered.png

### Step 6: Test/Export

Light maps are great for working with bigger scenes. With baked-in lighting, complex meshes can show realistic lighting without using heavy computation (the [Depot](https://app.ignitionrobotics.org/OpenRobotics/fuel/models/Depot) model below is a good example of complex scene with a baked light map).

To export light map image go to `UV editor` > `Image` > `Save as`

@image html img/lightmap_depot_saved.jpg

Light map baking applied to a more complex scene:

@image html img/lightmap_depot_render.png

## Using the light map in Ignition

When baking we have the option to either bake in all the lighting, both indirect and direct, or just the indirect lighting, also known as global illumination or bounced lighting, and use real time lights in Ignition for the direct lighting and shadows. With the latter method we get sharper lighting and shadow detail as well as more accurate lighting on our dynamic objects however performance will be impacted by having more real time lights. Even with all the lighting baked it’s still a good idea to have one real time light such as a large point light or directional light works particularly well in order to enhance the effects of the physically based materials.

Lightmaps can be applied to a mesh in Ignition the same way as other texture maps. Create an `ignition::rendering::Material` and specify a light map texture by calling
[SetLightMap](https://ignitionrobotics.org/api/rendering/5.0/classignition_1_1rendering_1_1Material.html#addc6eb6206e0a17ab82aeaea543e8c71). Recall that when creating the light map UV texture in Step 2, we typically use a secondary UV set for light maps. Make sure to specify the index of the light map UV set as the second argument to this function.

There are existing example models on Ignition Fuel that use light maps. The [Depot](https://app.ignitionrobotics.org/OpenRobotics/fuel/models/Depot) model mentioned earlier is one such example, and another one is the [Indoor Lightmap](https://app.ignitionrobotics.org/OpenRobotics/fuel/models/Indoor%20light map) model. To see the Indoor Lightmap model with [Ignition Gazebo](https://ignitionrobotics.org/docs/all/getstarted), you can run the following command (requires Ignition Edifice or above):

```
ign gazebo -v lightmap.sdf
```

repository: Pandinosaurus/ign-rendering

gha_license_id: NOASSERTION

repo_name: Pandinosaurus/ign-rendering


text:
# Wiki.Net

[![License](https://img.shields.io/github/license/Voltstro-Studios/Wiki.Net?label=License)](https://github.com/Voltstro-Studios/Wiki.Net/blob/master/LICENSE.md)
[![NuGet](https://img.shields.io/nuget/v/Wiki.Net?label=NuGet)](https://www.nuget.org/packages/Wiki.Net/)
[![NuGet Download Count](https://img.shields.io/nuget/dt/Wiki.Net?label=Downloads&logo=nuget&color=blue&logoColor=blue)](https://www.nuget.org/packages/Wiki.Net/)
[![Build Status)](https://img.shields.io/azure-devops/build/Voltstro-Studios/c4df32aa-4dfd-4b92-bf94-fe6c31c47b03/4/master?label=Build&logo=azure-pipelines)](https://dev.azure.com/Voltstro-Studios/Wiki.Net/_build/latest?definitionId=4&branchName=master)
[![Discord](https://img.shields.io/badge/Discord-Voltstro-7289da.svg?logo=discord)](https://discord.voltstro.dev)

Wiki.Net – An unofficial C# Wikipedia API

## Features

Searches Wikipedia (duh!) in multiple defined languages and returns (per result):
* Title
* Page ID
* Word Count
* Size (bytes?)
* Text Preview
* URL of page
* Time of last edit

## Getting Started

### Installation

You can install via NuGet using the package manager command:

```
Install-Package Wiki.Net
```

You can also download the binaries from the [releases](https://github.com/Voltstro-Studios/Wiki.Net/releases).

### Example

```csharp
string searchString = "Computer";
WikiSearchSettings searchSettings = new WikiSearchSettings
	{RequestId = "Request ID", ResultLimit = 5, ResultOffset = 2, Language = "en"};

WikiSearchResponse response = WikiSearcher.Search(searchString, searchSettings);

Console.WriteLine($"\nResults found ({searchString}):\n");
foreach (WikiSearchResult result in response.Query.SearchResults)
{
	Console.WriteLine(
		$"\t{result.Title} ({result.WordCount} words, {result.Size} bytes, id {result.PageId}):\t{result.Preview}...\n\tAt {result.Url(searchSettings.Language)}\n\tLast edited at {result.LastEdited}\n");
}

Console.ReadLine();
```

**Output**
```
Results found (Computer):

    Information technology (2836 words, 27146 bytes, id 36674345):  Information technology (IT) is the use of computers to store, retrieve, transmit, and manipulate data, or information, often in the context of a business...
    At https://en.wikipedia.org/?curid=36674345
    Last edited at 24/10/2019 11:53:39 AM

    Computer graphics (computer science) (1632 words, 18720 bytes, id 18567168):    Computer graphics is a sub-field of Computer Science which studies methods for digitally synthesizing and manipulating visual content. Although the term...
    At https://en.wikipedia.org/?curid=18567168
    Last edited at 17/09/2019 12:21:21 AM

    Computer hardware (2479 words, 22776 bytes, id 21808348):       Computer hardware includes the physical, tangible parts or components of a computer, such as the cabinet, central processing unit, monitor, keyboard,...
    At https://en.wikipedia.org/?curid=21808348
    Last edited at 16/10/2019 4:00:29 PM

    *More results*
```

### Upgrading from 2.x to 3.x

In 3.0, we simplified the namespace of Wiki.Net to `WikiDotNet`.

To upgrade from 2.x version of Wiki.Net to 3.x, you need to change all of the `using CreepysinStudios.WikiDotNet` to `using WikiDotNet` in your projects. The easiest way would just be to do a replace all in your entire solution.

## Authors

**EternalClickbait** - *Initial work* - [EternalClickbait](https://github.com/EternalClickbait)

**Voltstro** - *Current Maintainer / Initial Docs Writer* - [Voltstro](https://github.com/Voltstro)

## License

This project is licensed under the MIT license – see the [LICENSE.md](https://github.com/Voltstro-Studios/Wiki.Net/blob/Development/LICENSE.md) file for details.


text:
# Angular Google Static Maps Directive

An [AngularJS](http://angularjs.org/) directive to quickly insert [Google Static
Maps](https://developers.google.com/maps/documentation/staticmaps/).

I was inspired by [angular-google-staticmaps](https://github.com/passy/angular-google-staticmaps) that seems is no longer mantained.

[See it in action](https://thebatclaudio.github.io/ng-google-static-maps/)

## Usage

1. `bower install --save ng-google-static-maps`
2. Include dependencies in your HTML.
3. Load the `tbc.ngGoogleStaticMaps` module for your Angular app.
4. Use the `static-google-map` directive.

## Example

```html
<static-google-map size="137x137" markers="markers" sensor="false" zoom="14"></static-google-map>
```

The `markers` attribute can contain one or multiple markers.
Markers have the following format:

```javascript
$scope.markers = [{
    color: 'blue',
    label: 'S',
    coords: [lat, lng],
    icon: YOUR_ICON_URL
}];
```

If markers change, the directive will refresh itself automatically.

## Attributes

Any attribute is directly passed to the generated URL the image is loaded from,
except for `markers`, which gets formatted according to the specification.

### `size` (required)

The size attribute is required and must be specified as `WIDTHxHEIGHT` whereby `WIDTH`
denotes the width and pixels and `HEIGHT` the height.

### `sensor` (required)

The sensor attribute must explicitly be set to either `true` or `false`.

## License

MIT

repository: thebatclaudio/ng-google-static-maps

repo_name: thebatclaudio/ng-google-static-maps


text:
---
title: Crash Reports
author: Bennyboy1695
tags: ["modded Minecraft commands", "Modded Minecraft", "Minecraft Network", "ShadowNode", "ShadowNode Modded", "Modded
MC", "Modded MC Network", "get crash reports", "MC crash reports"]
---

{{% notice note %}}
This page is still a work in progress and has yet to be finished!
{{% /notice %}}

Here you will find how to get your crash report for your specific launcher of choice.

FTB Launcher
============

1. Open the Launcher
2. Select the Modpack, click on ``Edit Modpack`` and on ``Open Folder``.
3. Now you are in the ``mods`` folder, go back to the ``minecraft`` folder.
4. Open the ``crash-reports`` folder.
5. Paste the content of the latest crash-report MCLo.gs.
6. Click on the ``Save`` button and copy the web link.
7. Paste the link in the Discord ticket or support channel.

Technic Launcher
================

1. Open the Launcher
2. Select the Modpack and click on the small gearwheel below the Modpack on the right site
3. Now you click on ``OpenFolder`` and open the ``crash-reports`` folder.
4. Paste the content of the latest crash-report on MCLo.gs.
5. Click on the ``Save`` button and copy the web link.
6. Paste the link in the Discord ticket or support channel.

ATLauncher
==========

1. Open the Launcher
2. Select ``instances``, and locate your pack. and
3. Click ``Open Folder``and locate the ``crash-report`` folder.
4. Paste the content of the latest crash-report on MCLo.gs.
5. Click on the ``Save`` button and copy the web link.
6. Paste the link in the Discord ticket or support channel.

Curseforge Launcher
===================

1. Open the launcher.
2. Select ``Minecraft`` on the left bar, and locate your modpack.
3. Right click it and select ``Open folder``, then locate the ``crash-reports`` folder.
4. Paste the contents of the latest crash-report on MCLo.gs.
5. Click on the ``Save`` button and copy the web link.
6. Paste the link in the Discord ticket or support channel.

branch_name: refs/heads/site

gha_language: JavaScript


text:
---
layout: default
---

# 1994-12-01 - More on ASIS...

Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I was told this morning that the ASIS post had been reposted
to several other lists, including several social ones.  Interesting...

Anyway, there was a followup to the incident on the radio this
morning (2BL, is anyone was listenning):

Gareth Evans (Minister for Foreign Affairs) has announced that no
documents were irretrievably lost in the fire, as everything which was
lost in the fire was also duplicated elsewhere.  In addition to this,
the fire is being referred to the ACT coroner's office, as despite
the original claim by the Federal Government that there were no suspicious
circumstances, the Australian Federal Police have decided to do pursue this
action.  It is not clear yet whether this is a matter of proceedure,
or whether suspicious circumstances are suspected.  The government's
original claim was produced with surprisingly little time for investigation,
it has been noted.

						Ian.

{% endraw %}
```

## Thread

+ Return to [December 1994](/archive/1994/12)

+ Return to "["Ian Farquhar" <ianf<span>@</span>sydney.sgi.com>](/authors/ian_farquhar_ianf_at_sydney_sgi_com_)"

+ 1994-12-01 (Thu, 1 Dec 94 14:53:53 PST) - More on ASIS... - _"Ian Farquhar"<EMAIL_ADDRESS>


text:
# Git Extensions for VS Code

This extension provides a command to browse the current project using GitExtensions, from the Explorer.

## Features

From the Explorer, when you right-click (anywhere; a file or not) and then select the `Browse with Git Extensions`, Git Extensions will open in `Browse` mode for your current project.

![Browse with Git Extensions](images/BrowseContextMenuOpen.png)

## Requirements

1. You need to have Git Extensions installed
1. Git Extensions must be available globally (for windows users: registered in the `PATH` environment variable)

## Extension Settings

There are no settings at this point.

## Known Issues

There are no known issues.

## Release Notes

### 1.1.1-1.1.2

-   Update the `vscode` dependency to `^1.1.33` to remove a `tar` vulnerability; see [CVE-2018-20834](https://nvd.nist.gov/vuln/detail/CVE-2018-20834).

### 1.1.0

#### Explorer context menu

-   Added support for workspace; the right-clicked context menu item is now taken into consideration, opening GitExt based on that file or directory.
-   Moved the `Browse with Git Extensions` option up, right under the navigation section.

#### Editor context menu

-   Added the `Browse with Git Extensions` command to the context menu of the editor, allowing to open GitExt from an opened file.

### 1.0.1

Update the `vscode` dependency to `^1.1.22` to remove the `event-stream` vulnerability.

### 1.0.0

The initial release of _Git Extensions for VS Code_, it contributes the `Browse with Git Extensions` command to the explorer's context menu.

repository: myhololens/git-extensions-for-vs-code

repo_name: myhololens/git-extensions-for-vs-code


text:
[![Unix Build Status](https://img.shields.io/travis/NiaOrg/NiaPy/master.svg)](https://travis-ci.org/NiaOrg/NiaPy)
[![Windows Build status](https://ci.appveyor.com/api/projects/status/l5c0rp04mp04mbtq?svg=true)](https://ci.appveyor.com/project/GregaVrbancic/niapy)
[![Coverage Status](https://img.shields.io/coveralls/NiaOrg/NiaPy/master.svg)](https://coveralls.io/r/NiaOrg/NiaPy) [![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/g/NiaOrg/NiaPy.svg)](https://scrutinizer-ci.com/g/NiaOrg/NiaPy/?branch=master)
[![PyPI Version](https://img.shields.io/pypi/v/NiaPy.svg)](https://pypi.python.org/pypi/NiaPy)
[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/NiaOrg/NiaPy.svg)](http://isitmaintained.com/project/NiaOrg/NiaPy "Average time to resolve an issue")
[![Percentage of issues still open](http://isitmaintained.com/badge/open/NiaOrg/NiaPy.svg)](http://isitmaintained.com/project/NiaOrg/NiaPy "Percentage of issues still open")

## About
Nature-inspired algorithms are a very popular tool for solving optimization problems. Since the beginning of their era, numerous variants of [nature-inspired algorithms were developed](https://arxiv.org/abs/1307.4186). To prove their versatility, those were tested in various domains on various applications, especially when they are hybridized, modified or adapted. However, implementation of nature-inspired algorithms is sometimes difficult, complex and tedious task. In order to break this wall, NiaPy is intended for simple and quick use, without spending a time for implementing algorithms from scratch.

## Mission
Our mission is to build a collection of nature-inspired algorithms and create a simple interface for managing the optimization process along with statistical evaluation. NiaPy will offer:

- numerous benchmark functions implementations,
- use of various nature-inspired algorithms without struggle and effort with a simple interface,
- easy comparison between nature-inspired algorithms and
- statistical tests.

# Overview

Python micro framework for building nature-inspired algorithms.

The micro framework features following algorithms:

- basic:
  - Bat algorithm ([see example](examples/run_ba.py))
  - Firefly algorithm ([see example](examples/run_fa.py))
  - Differential evolution algorithm ([see example](examples/run_de.py))
  - Flower pollination algorithm ([see example](examples/run_fpa.py))
  - Grey wolf optimizer ([see example](examples/run_gwo.py))
- modified:
  - Hybrid bat algorithm ([see example](examples/run_hba.py))

The following benchmark functions are included in NiaPy:

- Ackley
- Griewank
- Rastrigin
- Rosenbrock
- Schwefel
- Sphere

Engineering problems

# Setup

## Requirements

* Python 3.6+ (backward compatibility with 2.7.14)

## Installation

Install NiaPy with pip (will be available soon):

```sh
$ pip install NiaPy
```

or directly from the source code:

```sh
$ git clone https://github.com/NiaOrg/NiaPy.git
$ cd NiaPy
$ python setup.py install
```

# Usage

After installation, the package can imported:

```sh
$ python
>>> import NiaPy
>>> NiaPy.__version__
```

For more usage examples please look at **examples** folder.

## Contributing

[![Open Source Helpers](https://www.codetriage.com/niaorg/niapy/badges/users.svg)](https://www.codetriage.com/niaorg/niapy)

We encourage you to contribute to NiaPy! Please check out the [Contributing to NiaPy guide](CONTRIBUTING.md) for guidelines about how to proceed.

Everyone interacting in NiaPy's codebases, issue trackers, chat rooms and mailing lists is expected to follow the NiaPy [code of conduct](CODE_OF_CONDUCT.md).

## Contributors

[](https://github.com/GregaVrbancic) |[](https://github.com/firefly-cpp) |[](https://github.com/lucijabrezocnik) |[](https://github.com/mlaky88) |[](https://github.com/rhododendrom) |
:---: |:---: |:---: |:---: |:---: |
[GregaVrbancic](https://github.com/GregaVrbancic) |[firefly-cpp](https://github.com/firefly-cpp) |[lucijabrezocnik](https://github.com/lucijabrezocnik) |[mlaky88](https://github.com/mlaky88) |[rhododendrom](https://github.com/rhododendrom) |
## Licence
This package is distributed under the MIT License. This license can be found online at http://www.opensource.org/licenses/MIT.

## Disclaimer
This framework is provided as-is, and there are no guarantees that it fits your purposes or that it is bug-free. Use it at your own risk!

repository: matejakocbek/NiaPy

repo_name: matejakocbek/NiaPy


text:
# Catala english token proposals

## FIELD

Current proposal: "application field".

The logical context in which the text of the law will apply. Examples are
"computation of family benefits", "determination of child credit eligibility".

```
application field FamilyBenefitsComputation:
  ...
```

## DATA

Current proposal: "data".

When declaring a data structure, introduces a data field :

```
structure Foo:
  data bar ...
```

## CONTENT

Current proposal: "content".

Introduces type annotation for data.

```
data bar content boolean
```

## DEPENDS

Current proposal : "depends"

Introduces a dependency on a parameter for a piece of data when declaring
a structure.

```
  data bar depends on Foo
```

## DECLARATION

Current proposal : "declaration"

Declares a structure or a enumeration in the metadata section.

## INCLUDES

Current proposal "includes"

A FIELD can include another FIELD, building up code modularity which is also
present in statutes.

```
declaration application field FamilyBenefitsComputation:
   ...
includes application field HouseholdIncomeComputation
```

## CONTEXT

Current proposal : "context"

A FIELD has several parameters, which are the data in the logical context of the
FIELD. CONTEXT introduces these data.

```
declaration application field FamilyBenefitsComputation:
   context foo content FOO
```

Also introduces context matching when including another field:

```
  ...
includes application field HouseholdIncomeComputation:
   HouseholdIncomeComputation.household = FamilyBenefitsComputation.household
   ...
```

## VARIES_WITH DECREASING INCREASING

Current proposal : "varies with" "decreasing" "increasing"

Way in which a numeric function can vary.

```
foo varies with bar decreasing
```

## OF

Current proposal: "of"

Used as function application token with a single parameter (foo of bar)

```
income of household
```

## COLLECTION

Current proposal: "collection"

Annotation for data that are collection of other data.

```
data children content collection Child
```

## ENUM

Current proposal : "enumeration".

An enumeration is a sum type modelling an alternative.

```
declaration enumeration Foo:
  -- ChoiceA
  -- ChoiceB content Bar
```

## STRUCT

Current proposal: "structure".

Introduces a structure data type (product type).

```
declaration structure Foo:
  fieldA content integer
  fieldB content boolean
  ...
```

## INTEGER

Current proposal : "integer".

The base integer data type.

```
data foo content integer
```

## MONEY

Current proposal : "amount".

The base data type for representing amounts of money.

```
data foo content money
```

## TEXT

Current proposal : "text".

The base data type for representing strings.

```
data foo content text
```

## DECIMAL

Current proposal : "decimal".

The base data type for representing fixed- or floating-point numbers.

```
data foo content decimal
```

## DATE

Current proposal : "date".

The base data type for representing dates.

```
data foo content date
```

## BOOLEAN

Current proposal : "boolean".

The base data type for representing booleans. Apparently lawyers don't know what
it is but I haven't found a better word.

```
data foo content boolean
```

## SUM

Current proposal: "sum".

Function for doing the sum of a quantity over a collection of data.

```
sum for child in children of child.income
```

## CARDINAL

Current proposal: "number".

Function for counting the number of data in a collection that satisfy a predicate.

```
number for child in children of child.age > 15 year
```

## CONDITION

Current proposal: "condition"

A condition is a special kind of DATA used to represent logical and juridical
conditions. In default logic, it is a boolean whose default value is false.

```
structure ArticleFoo:
  condition eligible_for_credit
```

## FILLED

Current proposal: "fulfilled"

Action TOKEN to declare a CONDITION valid in a rule.

```
eligible_for_credit fulfilled
```

## RULE

Current proposal: "rule"

Inside a FIELD, introduces a rules that sets a CONDITION to FILLED or not FILLED

```
application field FamilyBenefitsComputation:
  rule under condition
    number of household.children > 2
  consequence eligible filled
```

## DEFINITION

Current proposal: "definition".

Same thing as RULE but for data that is not a condition.

```
application field FamilyBenefitsComputation:
  definition income defined as
    sum for child in household.children of child.income
```

## DEFINED_AS

Current proposal: "defined as".

Introduces the expression of a data in a DEFINITION.

See above for example.

## MATCH

Current proposal: "match".

Allows to case on an enumeration.

```
match matrimonial_status with pattern
-- Married
-- Single
```

## WITH

Current proposal: "with pattern".

Complement of MATCH. See above.

## UNDER_CONDITION

Current proposa: "under condition".

Soft if-then-else for default logic.

```
definition credit
  under condition eligible_for_credit
  consequence defined as $10
```

## CONSEQUENCE

Current proposal: "consequence"

Counterpart of UNDER_CONDITION. See above.

## IF THEN ELSE

Current proposal: "if" "then" "else"

The hard if/then/else of traditional programming.

```
if child.age > 15 then Eligible else NotEligible
```

## OPTIONAL

Current proposal: "optional".

Syntax shorthand for a Absent/Present enumeration.

```
data husband optional
```

## ASSERTION

Current proposal: "assertion".

Introduces inside a FIELD a thing that should always be true.

```
assertion for each child in children we have child.age >= 0
```

## FOR ALL WE_HAVE

Current proposal: "for" "all" "we have"

Introduces a forall predicate or aggregation over a collection of data.

See above.

### EXISTS IN SUCH THAT

Current proposal: "exists" "in" "such" "that"

Introduces an existential predicate over a collection of data.

```
exists child in children such that child.age > 20 year
```

## FIXED BY

Current proposal: "fixed" "by"

Asserts that a particular variable is defined in a particular category of
legislative text.

```
assertion foo.bar fixed by executive order
```

## NOW

Current proposal "now".

Builtin function returning the date of today when executing the code.

## AND OR NOT

Current proposal: "and" "or" "not".

Logical connectives.

```
(age > 15) and (eligible or special_thing)
```

### YEAR MONTH DAY

Current proposal: "year" "month" "day"

Units of time for duration specification.

```
15 months + 1 year
```

repository: CatalaLang/catala

gha_language: OCaml

repo_name: CatalaLang/catala


text:
{{{
  "title": "Simple Backup Monitoring",
  "date": "10-30-2019",
  "author": "John Gerger",
  "keywords": ["backup", "clc", "cloud", "monitoring", "sbs", "webhook"],
  "attachments": [],
  "related-products" : [],
  "contentIsHTML": false,
  "sticky": false
}}}

The Simple Backup Service has monitoring functionality now available through email notifications. Email notifications are available for either failed or successful backups, as well as a nightly backup email report of all activity.

To get started simply navigate to the Monitoring tab in the Simple Backup UI, add an email address to receive the notifications, and check the boxes for the notifications you would like.

![](../images/backup/monitoring/monitoring_email.png)

We also have realtime monitoring available through Webhooks. Please see our [Webhooks KB article](webhooks.md) for more information.

repository: AnthonyHakim/PublicKB

repo_name: AnthonyHakim/PublicKB


text:
## OpenCV: Open Source Computer Vision Library

### Resources

* Homepage: <http://opencv.org>
* Docs: <http://docs.opencv.org/master/>
* Q&A forum: <http://answers.opencv.org>
* Issue tracking: <https://github.com/opencv/opencv/issues>

### Contributing

Please read the [contribution guidelines](https://github.com/opencv/opencv/wiki/How_to_contribute) before starting work on a pull request.

#### Summary of the guidelines:

* One pull request per issue;
* Choose the right base branch;
* Include tests and documentation;
* Clean up "oops" commits before submitting;
* Follow the [coding style guide](https://github.com/opencv/opencv/wiki/Coding_Style_Guide).

depends

yum groupinstall "Development Tools"
yum install ncurses-devel zlib-devel texinfo gtk+-devel gtk2-devel qt-devel tcl-devel tk-devel kernel-headers kernel-devel

build

1.
mkdir build
cd build

2.
cmake –D CMAKE_BUILD_TYPE=Release –D CMAKE_INSTALL_PREFIX=/usr/local/opencv ..

3.
make

4.
make install

repository: suzuren/opencv

repo_name: suzuren/opencv


text:
---
title: School (Term)
---

# Term: School
 Back to Terminology

## Metadata

Associated Table

sam_primary_access.group

Associated Table

sam_primary_access.group_type

## Summary

A school is an educational institution.  The C2C system, being an athletic management platform,
only tracks schools that have [teams](/projects/c2cschools/terms/team.html) that compete against other teams in competitions.

## Database Representation

A "School" is a [group](/projects/c2cschools/terms/group.html) with a [group type](/projects/c2cschools/terms/group-type.html) of `E77456B627558A0071B9F28353D03B06`.

## Group Relationships

Schools have multiple types of [group relationships](/projects/c2cschools/terms/group-relationship.html) with other [groups](/projects/c2cschools/terms/group.html).

### Child Relationship: "[Teams](/projects/c2cschools/terms/team.html)"

#### Metadata

Parent Group Type

School

Parent Group Type Id

E77456B627558A0071B9F28353D03B06

Child Group Type

Team

Child Group Type Id

4BA633511D3230FD1EABB907FA5C10FE

Relationship Type

Team

Relationship Type Id

1E8FAE7576BC1940B0E5C2FBEC5FB3DA

#### Relationship Summary

Schools can have one or more [team](/projects/c2cschools/terms/team.html) children that compete against other teams.

In certain contexts, the school will be referred to as the "owner" of its team children.

#### Relationship Diagram

{@yuml style="plain" direction="TB"}
[School (Group)]<>1-n>[Group Relationship],
[Group Relationship]<>1-n>[Team (Group)]
{/yuml}

repository: Dasix/grits-plugin-docs

repo_name: Dasix/grits-plugin-docs


text:
# Terraform::Alicloud::DatahubProject

The project is the basic unit of resource management in Datahub Service and is used to isolate and control resources. It contains a set of Topics. You can manage the datahub sources of an application by using projects. [Refer to details](https://help.aliyun.com/document_detail/47440.html).

-> **NOTE:** Currently Datahub service only can be supported in the regions: cn-beijing, cn-hangzhou, cn-shanghai, cn-shenzhen,  ap-southeast-1.

## Properties

`Name` - (Required, ForceNew) The name of the datahub project. Its length is limited to 3-32 and only characters such as letters, digits and '_' are allowed. It is case-insensitive.

`Comment` - (Optional) Comment of the datahub project. It cannot be longer than 255 characters.

## Return Values

### Fn::GetAtt

`Id` - The ID of the datahub project. It is the same as its name.

`CreateTime` - Create time of the datahub project. It is a human-readable string rather than 64-bits UTC.

`LastModifyTime` - Last modify time of the datahub project. It is the same as *create_time* at the beginning. It is also a human-readable string rather than 64-bits UTC.

## See Also

* [alicloud_datahub_project](https://www.terraform.io/docs/providers/alicloud/r/datahub_project.html) in the _Terraform Provider Documentation_


text:
# Analysis.NET #

Control-flow and data-flow analysis framework for .NET programs.

+ Static analysis framework for .NET
    * Bytecode level
    * No need for source code
    * Can analyze standard libraries
    + Intermediate representation
        * Three address code
        * Static single assignment
        * Visitor pattern
    + Control-flow analysis
        * Dominance
        * Dominance frontier
        * Natural loops
    + Data-flow analysis
        * Def-Use and Use-Def chains
        * Copy propagation
        * Points-to analysis
    * Type inference
    * Web analysis
    + Serialization
        * DOT
        * DGML

repository: garbervetsky/analysis-net

branch_name: refs/heads/cci-decoupling

gha_language: C#

repo_name: garbervetsky/analysis-net


text:
---
layout: tool
title: VCF Plotein
developer_github_account:
paper: https://academic.oup.com/bioinformatics/article/35/22/4803/5510555
paper_title: "VCF/Plotein: visualization and prioritization of genomic variants from human exome sequencing projects"
doi: 10.1093/bioinformatics/btz458
browser: https://vcfplotein.liigh.unam.mx/#/
abstract: "Identifying disease-causing variants from exome sequencing projects remains a challenging task that often requires bioinformatics expertise. Here we describe a user-friendly graphical application that allows medical professionals and bench biologists to prioritize and visualize genetic variants from human exome sequencing data. We have implemented VCF/Plotein, a graphical, fully interactive web application able to display exome sequencing data in VCF format. Gene and variant information is extracted from Ensembl. Cross-referencing with external databases and application-based gene and variant filtering have also been implemented. All data processing is done locally by the user’s CPU to ensure the security of patient data."
citation: "Raul Ossio, O Isaac Garcia-Salinas, Diego Said Anaya-Mancilla, Jair S Garcia-Sotelo, Luis A Aguilar, David J Adams, Carla Daniela Robles-Espinoza, VCF/Plotein: visualization and prioritization of genomic variants from human exome sequencing projects, Bioinformatics, Volume 35, Issue 22, 15 November 2019, Pages 4803–4805, https://doi.org/10.1093/bioinformatics/btz458"
citation_count: 26
feature_type: ['point sparse']
interconnection_type: ['no']
genome_layout: ['linear']
partition: ['contiguous']
abstraction: ['no']
arrangement: ['linear parallel']
view: single
scale: single
focus: single
coordinate_systems: single
access_format: [web application]
user_documentation_availability: yes
user_documentation: https://vcfplotein.liigh.unam.mx/#/
pub_year: 2019
license: Creative Commons Attribution License
license_form: open source
supported_files: ['vcf']
image: /assets/vcfplotein.png
image_location: https://www.google.com/url?sa=i&url=https%3A%2F%2Fvcfplotein.liigh.unam.mx%2F&psig=AOvVaw3htrc4bxvrx2J7J8ZkHbXp&ust=1605582770728000&source=images&cd=vfe&ved=0CAIQjRxqFwoTCPinlpmMhu0CFQAAAAAdAAAAABAK
notes:
---

repository: hms-dbmi/genocat

repo_name: hms-dbmi/genocat