text:
## **TLDR;** Issues will be closed unless they are accompanied by a test case using one of our [CodePen templates](#codepen-templates).

# Contributing

Looking to contribute something to bootstrap-material-design? **Here's how you can help.**

Please take a moment to review this document in order to make the contribution process easy and effective for everyone involved.

Following these guidelines helps to communicate that you **respect the time of the developers** managing and developing this open source project. In return, they should reciprocate that respect in addressing your issue or assessing patches and features.

## Using the issue tracker
The [issue tracker](https://github.com/FezVrasta/bootstrap-material-design/issues) is the preferred channel for [bug reports](#bug-reports), [features requests](#feature-requests) and [submitting pull requests](#pull-requests), but please respect the following restrictions:

* Please **do not** use the issue tracker for personal support requests. [Stack Overflow `bootstrap-material-design`](https://stackoverflow.com/questions/tagged/bootstrap-material-design) tag) is the best place to get help.

* Please **do not** derail or troll issues. Keep the discussion on topic and respect the opinions of others.

* Please **do not** post comments consisting solely of "+1" or ":thumbsup:". Use [GitHub's "reactions" feature](https://github.com/blog/2119-add-reactions-to-pull-requests-issues-and-comments)  instead. We reserve the right to delete comments which violate this rule.

* Please **do not** open issues or pull requests regarding the code in dependencies such as: [`Bootstrap`](https://github.com/twbs/bootstrap) (open them in their respective repositories).

* Please **do not** open issues without clearly stating the problem and desired result. [See the bug reports section](#bug-reports) for more information on creating effective issues.

* Please **close your own issue** once it is resolved.

## Bug reports
A bug is a _demonstrable problem_ that is caused by the code in the repository. Good bug reports are extremely helpful, so thanks!

Guidelines for bug reports:

1. **Use the GitHub issue search** — check if the issue has already been reported.

2. **Check if the issue has been fixed** — try to reproduce it using the latest `master` or development branch in the repository.

3. **Isolate the problem** — create a [reduced test case](https://css-tricks.com/reduced-test-cases/) using one of **our** [Codepen templates](#codepen-templates).

A good bug report shouldn't leave others needing to chase you up for more information. Please try to be as detailed as possible in your report. What is your environment? What steps will reproduce the issue? What browser(s) and OS experience the problem? Do other browsers show the bug differently? What would you expect to be the outcome? All these details will help people to fix any potential bugs.

## Codepen templates
When submitting an issue, you must submit a Codepen demonstrating your issue.  Please be sure to use the template below that is specific for your version:

- [`v4` Codepen template](http://codepen.io/rosskevin/pen/eJMMVB)
- [`v3` Codepen template](http://codepen.io/rosskevin/pen/VvRgrN)

## Why was my issue summarily closed?
Please don't take this the wrong way, but we receive a lot of issues and in order to effectively help, we need you to follow the guidelines.

We try our best to maintain a great project, and do so with a considerable amount of our personal time and effort.  Following these guidelines facilitates an efficient way to communicate about bugs or simply help. Failure to follow these guidelines leads to confusion and wasted time.

Many times, we find that the process of creating the [Codepen test case](#codepen-templates) solves the user's problem, and shows that an interaction with code outside this library are causing undesirable side effects.

If you do not take the time to read and follow these guidelines (including submitting a reduced test case with _**our** Codepen template_), then why should we take more time to help you?

## Feature requests
Feature requests are welcome, but take a moment to find out whether your idea fits with the scope and aims of the project and the [Google Material Design specification itself](http://www.google.com/design/spec/material-design/introduction.html). It's up to *you* to make a strong case to convince the project's developers of the merits of this feature. Please provide as much detail and context as possible.

## Pull requests
Good pull requests—patches, improvements, new features—are a fantastic help. They should remain focused in scope and avoid containing unrelated commits.

**Please ask first** before embarking on any significant pull request (e.g. implementing features, refactoring code, porting to a different language), otherwise you risk spending a lot of time working on something that the project's developers might not want to merge into the project.

Please adhere to the [coding guidelines](#code-guidelines) used throughout the project (indentation, accurate comments, etc.) and any other requirements (such as test coverage).

**In general, do not edit `dist` or `gh-pages` files directly!** Those files are automatically generated.

Similarly, when contributing to the documentation, you should edit the documentation source files in the docs directory.

Adhering to the following process is the best way to get your work included in the project:

1. [Fork](https://help.github.com/fork-a-repo/) the project, clone your fork,
   and configure the remotes:

   ```bash
   # Clone your fork of the repo into the current directory
   git clone https://github.com/<your-username>/bootstrap-material-design.git
   # Navigate to the newly cloned directory
   cd bootstrap-material-design
   # Assign the original repo to a remote called "upstream"
   git remote add upstream https://github.com/FezVrasta/bootstrap-material-design.git
   ```

2. If you cloned a while ago, get the latest changes from upstream:

   ```bash
   git checkout master
   git pull upstream master
   ```

3. Create a new topic branch (off the main project development branch) to contain your feature, change, or fix:

   ```bash
   git checkout -b <topic-branch-name>
   ```

4. Commit your changes in logical chunks with messages written in english. Please adhere to these [git commit message guidelines](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html) or your code is unlikely be merged into the main project.

5. Locally merge (or rebase) the upstream development branch into your topic branch:

   ```bash
   git pull [--rebase] upstream master
   ```

6. Push your topic branch up to your fork:

   ```bash
   git push origin <topic-branch-name>
   ```

7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/) with a clear title and description against the `master` branch.  Referenc any open issue in the description so it is automatically linked.

**IMPORTANT**: By submitting a patch, you agree to allow the project owners to license your work under the terms of the [MIT License](LICENSE) (if it includes code changes) and under the terms of the [Creative Commons Attribution 3.0 Unported License](docs/LICENSE) (if it includes documentation changes).

## Code guidelines

### HTML
[Adhere to the Code Guide.](http://codeguide.co/#html)

- Use tags and elements appropriate for an HTML5 doctype (e.g., self-closing tags).
- Use CDNs and HTTPS for third-party JS when possible. We don't use protocol-relative URLs in this case because they break when viewing the page locally via `file://`.
- Use [WAI-ARIA](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA) attributes in documentation examples to promote accessibility.

### Coding styles
Before committing ensure your changes follow our coding standards by running `gulp` for `v4` or `grunt dist docs` for `v3`.  This will run the various code style check tools and provide feedback.

repository: mdbootstrap/bootstrap-material-design

gha_language: CSS

repo_name: mdbootstrap/bootstrap-material-design


text:
# deephub
General purpose experimentation framework using Tensorflow and Keras

### Install
The code base works is compatible with >= Python 3.6 but it is *highly* proposed to stick on Python 3.6
and something bigger. It is expected that interpreter is installed before continuing with this guide.

It is proposed to use python virtual virtual environments to handle different projects. To create and activate a
virtual environment for python 3 you need to run:

```
$ python3.6 -m venv venv
$ source venv/bin/activate
```
Make sure you have updated your setuptools and pip versions using:
```
$ pip install --upgrade setuptools pip
```
Next you have to install package dependencies, cli tool using the pip command. If you work on development environment
it is prefered to use `-e` option:
```
$ pip install -e .
```

### Code Base Usage

#### Code Base Entry Points
DeepResearch framework provides different cli entry points in order to be able to use different modules from the
framework. These entry points are `{resources, trainer, hpt, utils}` with the prefix of `deep` command which is the
entry point for the whole framework.

### Resources
[Resources System](docs/Resources.md)
### Training
[Training Procedure](docs/Training.md)
### Testing
[Testing Procedure](docs/Testing.md)

### Important notes ###
#### NLTK models
Some functionality related with text processing depends on NLTK's external resources to work properly. After
installation of requirements you need to manually download these resources:

```
$ python -m nltk.downloader punkt
```

#### GPU experiments
In order to be able to use this framework on DeepLab's servers with GPUJ support you have to add these lines:
```
export LD_LIBRARY_PATH=/usr/local/cuda-9.0/lib64
export PATH=/usr/local/cuda-9.0/bin:$PATH
```
in the end of your `.bashrc` and then run `source ~/.bashrc`.

repository: deeplab-ai/deephub

branch_name: refs/heads/master

extension: md

gha_language: Python

license_type: permissive

repo_name: deeplab-ai/deephub


text:
---
title: 'AnyPyTools: A Python package for reproducible research with the AnyBody Modeling System'
tags:
  - Python
  - Musculoskeletal Modeling
  - Batch processing
  - Parameter studies
  - Reproducible workflows
  - AnyBody Modeling System
authors:
  - name: Morten Enemark Lund
    orcid: 0000-0001-9920-4051
    affiliation: "1, 2"
  - name: John Rasmussen
    orcid: 0000-0003-3257-5653
    affiliation: 2
  - name: Michael Skipper Andersen
    orcid: 0000-0001-8275-9472
    affiliation: 2
affiliations:
 - name: AnyBody Technology A/S, Denmark
   index: 1
 - name: Department of Materials and Production, Aalborg University, Denmark
   index: 2
date: 09 October 2018
bibliography: paper.bib
---

# Summary

The AnyPyTools package provides a Python interface to automate multibody
musculoskeletal model simulations in the AnyBody Modeling System. The main
advantage of AnyPyTools is that it enables reproducible research for the
AnyBody Modeling System, and bridges the gap to the whole ecosystem of open
source scientific Python packages.

As musculoskeletal simulations become increasingly important in decision making
processes in a range of applications, so does the requirement for model
verification and validation (V&V) [@Lund2012-ty]. Successful V&V will often
require running large numbers of simulations (batch processing) or investigating
parameters systematically (sensitivity or parameter studies). The stand-alone
AnyBody Modeling System is not very suited for this kind of meta-analysis. The
modeling system is essentially an IDE/compiler for scripting single multibody
musculoskeletal models in the AnyScript modeling language.

The AnyPyTools Python package enables batch processing, parallelization of model
simulations, model sensitivity studies, and parameter studies, using either
Monte-Carlo (random sampling) or Latin hypercube sampling. It makes reproducible
research much easier and replaces the tedious process of manually automating the
musculoskeletal simulations and aggregating the results.

The AnyPyTools library was developed at Aalborg University to
help in the effort to validate musculoskeletal models created within the AnyBody
Modeling System [@Lund2015-ix, @Lund2012-ty]. In this work AnyPyTools was
used to orchestrate large number of model simulations and distribute the load over
multiple processors, as well as collect the results directly in Python and
investigate the sensitivity of the model predictions. The library has
evolved over time to also include a pytest plugin for running unit tests on
AnyScript files (`test_*.any`) similar to how unit-tests are used for Python.

The AnyPyTools library is available on both PyPI and conda. It has been
downloaded more than 20.000 times from the conda-forge channel and has been used in a large
number of scientific publications over the last 5 years [@De_Pieri2018-py, @Stensgaard_Stoltze2018-hi,
@Richards2018-oj, @Theodorakos2018-jv, Rasmussen2018-nq, @DellIsola2017-ac, @Eltoukhy2017-ut,
@Skals2017-if, @Oliveira2017-by, @Skipper_Andersen2017-cw, @Skals2017-sg,
@Vanheule2017-sh, @Theodorakos2016-jx, @Lund2015-ix, @Oliveira2014-vd,
@Oliveira2013-xi, @Oliveira2013-ec]

The source code for AnyPyTools is available on [GitHub](https://github.com/AnyBody-Research-Group/AnyPyTools) and releases are archived
to Zenodo with the linked DOI: [@Lund2018-jm]

# Acknowledgements

We acknowledge contributions from AnyBody Technology A/S who have used the package extensively
for their verification and validation work. Also, thanks to to the numerous academic users of the
AnyBody Modeling System from all over the world, who have contributed feedback and feature requests.

# References

license: MIT

repository: AnyBody-Research-Group/AnyPyTools

gha_license_id: MIT

repo_name: AnyBody-Research-Group/AnyPyTools


text:
Curly
=======

Free your views!

Curly is a template language that completely separates structure and logic.
Instead of interspersing your HTML with snippets of Ruby, all logic is moved
to a presenter class, with only simple placeholders in the HTML.

While the basic concepts are very similar to [Mustache](http://mustache.github.com/)
or [Handlebars](http://handlebarsjs.com/), Curly is different in some key ways:

- Instead of the template controlling the variable scope and looping through
  data, all logic is left to the presenter object. This means that untrusted
  templates can safely be executed, making Curly a possible alternative to
  languages like [Liquid](http://liquidmarkup.org/).
- Instead of implementing its own template resolution mechanism, Curly hooks
  directly into Rails, leveraging the existing resolvers.
- Because of the way it integrates with Rails, it is very easy to use partial
  Curly templates to split out logic from a presenter. With Mustache, at least,
  when integrating with Rails, it is common to return Hash objects from view
  object methods that are in turn used by the template.

Installing
----------

Installing Curly is as simple as running `gem install curly-templates`. If you're
using Bundler to manage your dependencies, add this to your Gemfile

```ruby
gem 'curly-templates'
```

How to use Curly
----------------

In order to use Curly for a view or partial, use the suffix `.curly` instead of
`.erb`, e.g. `app/views/posts/_comment.html.curly`. Curly will look for a
corresponding presenter class named `Posts::CommentPresenter`. By convention,
these are placed in `app/presenters/`, so in this case the presenter would
reside in `app/presenters/posts/comment_presenter.rb`. Note that presenters
for partials are not prepended with an underscore.

Add some HTML to the partial template along with some Curly variables:

```html
<!-- app/views/posts/_comment.html.curly -->
<div class="comment">
  <p>
    {{author_link}} posted {{time_ago}} ago.
  </p>

  {{body}}
</div>
```

The presenter will be responsible for filling in the variables. Add the necessary
Ruby code to the presenter:

```ruby
# app/presenters/posts/comment_presenter.rb
class Posts::CommentPresenter < Curly::Presenter
  presents :comment

  def body
    BlueCloth.new(@comment.body).to_html
  end

  def author_link
<EMAIL_ADDRESS>@comment.author, rel: "author")
  end

  def time_ago
<EMAIL_ADDRESS>  end
end
```

The partial can now be rendered like any other, e.g. by calling

```ruby
render 'comment', comment: comment
render comment
render collection: post.comments
```

Examples
--------

Here is a simple Curly template -- it will be looked up by Rails automatically.

```html
<!-- app/views/posts/show.html.curly -->
<h1>{{title}}<h1>
<p class="author">{{author}}</p>
<p>{{description}}</p>

{{comment_form}}

<div class="comments">
  {{comments}}
</div>
```

When rendering the template, a presenter is automatically instantiated with the
variables assigned in the controller or the `render` call. The presenter declares
the variables it expects with `presents`, which takes a list of variables names.

```ruby
# app/presenters/posts/show_presenter.rb
class Posts::ShowPresenter < Curly::Presenter
  presents :post

  def title
    @post.title
  end

  def author
<EMAIL_ADDRESS>@post.author, rel: "author")
  end

  def description
    Markdown.new(@post.description).to_html.html_safe
  end

  def comments
    render 'comment', collection: @post.comments
  end

  def comment_form
    if @post.comments_allowed?
      render 'comment_form', post: @post
    else
      content_tag(:p, "Comments are disabled for this post")
    end
  end
end
```

Caching
-------

Because of the way logic is contained in presenters, caching entire views or partials
becomes exceedingly straightforward. Simply define a `#cache_key` method that returns
a non-nil object, and the return value will be used to cache the template.

Whereas in ERB your would include the `cache` call in the template itself:

```erb
<% cache([@post, signed_in?]) do %>
  ...
<% end %>
```

In Curly you would instead declare it in the presenter:

```ruby
class Posts::ShowPresenter < Curly::Presenter
  presents :post

  def cache_key
    [@post, signed_in?]
  end
end
```

Likewise, you can add a `#cache_duration` method if you wish to automatically expire
the fragment cache:

```ruby
class Posts::ShowPresenter < Curly::Presenter
  ...

  def cache_duration
    30.minutes
  end
end
```

Thanks
------

Thanks to [Zendesk](http://zendesk.com/) for sponsoring the work on Curly.

Copyright and License
---------------------

Copyright (c) 2013 Daniel Schierbeck (@dasch), Zendesk Inc.

Licensed under the [Apache License Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).

repository: bquorning/curly

repo_name: bquorning/curly


text:
# Kodi-Kwik-Kontrol
### Control Kodi/XBMC from our Apple Watch and Notification Center

Kwik Kontrol allows you control your Kodi or XBMC device quickly and easily both from your Apple Watch and your iPhone's Notification Center.

Kwik Control will soon be available in the Apple App Store and will shortly after be released under the MIT license.

## Watch App

###Glance view:
![Glance screenshot](http://i.imgur.com/btRutgQ.jpg)

###Control view:
![Control screenshot](http://i.imgur.com/1XEiCDa.jpg)

###Now-Playing view:
![Now playing screenshot](http://i.imgur.com/AKK7qh8.jpg)

## Notification Center

###View when item is playing
![NC screenshot](http://i.imgur.com/pxDjmeT.jpg)

For support, please contact me on Twitter: [@cmdshiftn](http://twitter.com/cmdshiftn)


text:
[Week 2 Home](../)

 Please reference the [Phase 0 Handbook](https://github.com/Devbootcamp/phase-0-handbook/) for more details as to what this entails.

## Learning Competencies
- Use wireframes to construct a website
- Use HTML tags to present content on a website
- Position HTML elements using CSS padding, borders, and margins
- Use CSS to add and format colors, fonts, icons, images, etc.

## Summary

In this challenge, you will make your [USERNAME].github.io site using the principles of design, site map, wireframe, and HTML and CSS you've learned this far. You may not use Bootstrap or any other design framework for your site.

Get creative. Have fun. But be conscious of time. This site will be a work in progress, so you should timebox how much time you want to spend on each part. You will be able to make improvements each week or unit if you dedicate the time to it. Make an MVP (Minimum Viable Product) for this version. Designing and building a site can take a **LONG TIME**, so just get your site "good enough" for your MVP. You can always make it better later!

Pomodoro is a common and effective timeboxing and productivity technique that we can use in this exercise. Basically you do 25 minutes of work, 5 minutes of break. You can use your own timer or this web application [moosti](http://www.moosti.com). Take a second and estimate how many units you want to work on each section, and see where you are by the end. Then you can decide if you want to continue adding more time. You will be improving your website as you go through the program.

## Releases

## Release 0: Reconsider your Wireframes
Reconsider the wireframes you created for your index.html and blog/index.html pages in [3-wireframing](../3-wireframing). Do you need to make any changes based on what you've learned so far? If so, make the changes and upload your new wireframes to this directory.

## Release 1: Design
Now is the time to consider the colors, fonts, icons/logos, images and overall look and feel of your site. You may want to use some of the following resources:

- [Adobe Color CC](https://kuler.adobe.com/create/color-wheel/) to create a color theme for your site
- [Google Fonts](https://www.google.com/fonts) to consider fonts

You also may want to complete the bonus challenge, [Make a Mood Board](../13-BONUS-challenges/mood-board), to help you solidify your design.

Again, don't get bogged down in your research trying to make your site perfect. Make it acceptable. You should make it a goal to revisit your site each week to add to it.

## Release 2: Development

#### Add Content using HTML
Using your wireframes and design ideas as references, add content to your index.html page in your [USERNAME].github.io site using HTML. You may want to focus on using HTML5 semantic elements instead of `<div>`s. Take a moment to look through the [HTML5 Document Outlines](http://html5doctor.com/outlines/). You can also use the [HTML5 Tutorial](http://www.w3schools.com/html/html5_intro.asp) on w3schools.

Once you have all of the content on your index, make sure your HTML passes validation by running it in through a [validator](http://validator.w3.org/#validate_by_input). When it passes validation, you are ready to create your blog/index.html file. Be sure to add links to your week 1 blog posts! Be sure this HTML passes validation as well.

Remember, your website is a work in progress. Do not deviate from your wireframes until you've built your MVP. As we often say at DBC, "Done is better than perfect."

#### Apply CSS
Now you can truly begin to appreciate CSS, which stands for Cascading Style Sheets. Each page can have a similar look if you use the same classes to format them.

In your stylesheets directory, add a `default.css` sheet. Using [this document](http://www.basictips.com/using-multiple-external-style-sheets.shtml) as a reference, add the default.css stylesheet to your blog-template.html (and week 1 blogs) so the default.css will be the first stylesheet referenced and will be supplemented by your `blog-stylesheet.css`

In your `default.css` stylesheet:
- Add styling to your header and footer
- Style and position the content to match your wireframes
- Incorporate the colors and fonts you want on your site
- Format any images you've selected

In your `blog-stylesheet.css` file:
- Add any CSS to personalize your blog posts

Don't forget about Chrome Devtools for testing out your style changes and figuring out if you are selecting elements properly.

REMINDER: Are you being true to your MVP or are you working on new features? Don't deviate from your original wireframes until AFTER you've built your MVP.

## Release 3: More Pages! (OPTIONAL)
If you want to add more to your site, consider adding a sections for:

- Projects
- About me (or Contact)
- Anything else you want to share

## Release 4: Publish
When you feel ready to publish your new site, add your files to the stage, commit your changes, and push to master. Post your site on Twitter using **#DBCmysite** to ask for feedback from your peers.

## Release 5: Reflect
On your local `phase-0-unit-1` repo, edit the [my_reflection.md](my_reflection.md) file associated with this challenge. Commit your changes and push them to GitHub.

## Release 6: Review (optional)
Check out your peers websites and leave comments as issues. Search for them using the **#DBCmysite** hashtag!

## Additional Resources:
- [An Advanced Guide to HTML and CSS](http://learn.shayhowe.com/)
- Awesome List of links: [Design resources for developers](https://gist.github.com/jenmyers/7354863)
- Great List of tutorials: [10 tutorials for beginning web designers](http://code.tutsplus.com/articles/10-hand-picked-tutorials-for-beginning-web-designers--net-9341)


text:
# Datacenter fa19-516-162

## E.Datacenter.2: Carbon footprint of data centers

### E.Datacenter.2.a:

The yearly cost and CO2 footprint of Google's data center at Singapore have been
added to the [file](https://docs.google.com/spreadsheets/d/1gh869zfjA4sVxL8-ga0af2_HLTTuOoD1IReuRSrbq4I/edit#gid=0).

### E.Datacenter.2.b:

The 230,455 sq. ft. [1] Google data center in Singapore is the first Google
data center in South East Asia [2]. It came online in December 2013. Google is
developing two more data centers at the same location.

This data center uses an estimated 25 MW of power with a PUE of 1.15 [3].

Then the IT Load of the center can be calculated as

PUE = Total Load / IT Load [4]

IT Load = Total Load / PUE

IT Load = 25 * 1000/1.15 =  21740 kW

On putting these values in the [Schneider Electric Data Center Carbon
Footprint Calculator](https://www.schneider-electric.com/en/work/solutions/system/s1/data-center-and-network-systems/trade-off-tools/data-center-carbon-footprint-comparison-calculator/),
the yearly cost and carbon footprint of the data center were calculated as follows:

| Data center |	Electricity Cost ($/kW) |	IT Load (kW) |	Yearly Cost ($) | Yearly CO2 Footprint (tons) |	CO2 equivalent in cars |
| --- | --- | --- | --- | --- | --- |
| Google Singapore Jurong West | 0.13 |	21,740 |	29.6M |	160,089 |	35,293 |

## E.Datacenter.3: My Carbon footprint

My carbon footprint has been added to the
[file](https://docs.google.com/spreadsheets/d/1gh869zfjA4sVxL8-ga0af2_HLTTuOoD1IReuRSrbq4I/edit#gid=314181983).

## E.Datacenter.4: Hydro Power

Hydro power is energy in moving water[5]. It is one of the oldest sources for
producing electricity. It is generated by rotating big turbines in heavy flowing
streams or rivers or using a dam that releases water when necessary. The
turbines then spin a generator that produces electricity.

Hydro electricity accounts for nearly 7% of the total electricity produced and
23% of the electricity produced using renewable resources in the US.

![Hydro Power Consumption [Source](https://www.eia.gov/energyexplained/us-energy-facts/)](images/hydro.png)

### Data centers that run on hydro power

* Near the Linth river in Switzerland, Data Center Light has established one of
a kind of data center that boasts of an in-house hydro-power plant. It uses
electricity generated by 100% renewable resources. It produces over 8000 MW/h
of energy per year[6].
* Facebook opened a data center in Lulea, Sweden that is mostly powered by
locally generated hydroelectric power. The center has an excellent PUE rating
due to factors such as using natural air to cool the systems and using efficient
hardware[7].
* Hydro66, a British corporation, has opened a 1000 sq. m. data center in North
Sweden close to the Facebook's data center. This facility also uses the hydro
electric power generated by the local plant.

## E.Datacenter.5: California

* In September 2018, California passed a bill to move the entire power grid to
renewable energy [11].
* California also has an issued order to remove as much carbon dioxide from the
atmosphere as it emits [12].
* "The California Energy Commission estimates that 32 percent of retail energy
sales were powered by renewable sources last year" [Camila Domonoske, 2018][12].
* "California has abundant energy resources, being among the top producers of
oil, hydroelectricity, solar, biomass, and geothermal energy in the United
States" [13].
* Due to strict emission laws, no coal-fired power plants operate in California.
* California leads the nation in electricity generation from non-hydroelectric
renewable energy sources, including geothermal power, wind power, and solar
power.
* The site <https://www.dsireusa.org/> has several state incentives for
residential to big corporations to promote the use of renewable energy.

## E.Datacenter.8:

In August 2019, a power outage at Nissan data center in Denver, Colorado led
to four days of shut down of most of the Nissan and Infiniti dealerships
across North America, Canada and Mexico [10].

**Reason for data center outage**

Extreme heat in Colorado led to multiple
power outages in the Denver area. The Nissan data center was also affected
by this power outage. The power outage disabled the backup systems and made
the recovery even more difficult [8].

**Effects of data center outage**

* The power breakdown resulted in their communication system called NNANet to
shut down. This resulted in the dealers not being able to order new cars
, parts, file warranty claims, check the inventory of other dealers or customer
payoff information [9].
* The dealers couldn't make any sales [9].
* The data crash also brought down production at Nissan's factories in
Tennessee and Mississippi [10].

**How it could have been avoided**

It took four days for the data center to recover from this outage. This was
because the backup systems were co-located and were affected by the same power
outage. If there are multiple data centers for a big corporation, a backup of
data, applications, and systems should be kept in a different region because
it has a very less chance of affecting different locations [8].

## References:

[1] <https://baxtel.com/data-center/google-singapore-jurong-west>

[2] <https://www.google.com/about/datacenters/inside/locations/singapore/>

[3] <https://www.google.com/about/datacenters/efficiency/internal/#measuring-efficiency>

[4] <https://en.wikipedia.org/wiki/Power_usage_effectiveness>

[5] <https://www.eia.gov/energyexplained/hydropower/>

[6] <https://datacenterlight.ch/en-us/cms/hydropower/>

[7] <https://www.greenbiz.com/blog/2013/06/13/facebook-flicks-hydropowered-data-center-sweden>

[8] <https://www.autonews.com/retail/computer-glitch-crashed-nissan>

[9] <https://carbuzz.com/news/nissan-and-infiniti-dealers-are-going-crazy-right-now>

[10] <https://www.automotiveit.com/cyber-security/data-center-power-outage-shuts-down-nissan-and-infiniti-dealer-and-production-systems-in-north-america/38945.article>

[11] <https://thehill.com/policy/energy-environment/405903-california-passes-law-committing-state-to-100-renewable-energy-use>

[12] <https://www.npr.org/2018/09/10/646373423/california-sets-goal-of-100-percent-renewable-electric-power-by-2045>

[13] <https://en.m.wikipedia.org/wiki/Energy_in_California>


text:
# Contributing guidelines

The Haskell tooling dream is near, we need your help!

## How to contact the haskell ide team

- Join [our IRC channel](https://web.libera.chat/?channels=#haskell-language-server) at `#haskell-language-server` on [`libera`](https://libera.chat/).
- Follow the [Haskell IDE team twitter account](https://twitter.com/IdeHaskell) for updates and help.
- Join the [#haskell-tooling channel](https://discord.com/channels/280033776820813825/505370075402862594/808027763868827659) in the Functional Programming discord server. You can join the server via [this invitation](https://discord.gg/9spEdTNGrD).
- Join the [haskell-tooling channel](https://matrix.to/#/#haskell-tooling:matrix.org) in [matrix](https://matrix.org/).
- Visit [the project GitHub repo](https://github.com/haskell/haskell-language-server) to view the source code, or open issues or pull requests.

## Building

Clone the repository:
```shell
$ git clone https://github.com/haskell/haskell-language-server
```

The project can then be built with both `cabal build` and `stack build`.

### Using Cabal

```shell
# If you have not run `cabal update` in a while
$ cabal update
# Then
$ cabal build
```

### Using Stack

```shell
$ stack build
```

### Using Nix

The instructions below show how to set up a Cachix binary cache and open a nix shell for local development.

```shell
$ cachix use haskell-language-server
$ nix-shell
$ cabal update
$ cabal build
```

#### Flakes support

If you are using nix 2.4 style command (enabled by `experimental-features = nix-command`),
you can use `nix develop` instead of `nix-shell` to enter the development shell. To enter the shell with specific GHC versions:

* `nix develop` or `nix develop .#haskell-language-server-dev` - default GHC version
* `nix develop .#haskell-language-server-901-dev` - GHC 9.0.1 (substitute GHC version as appropriate)

If you are looking for a Nix expression to create haskell-language-server binaries, see https://github.com/haskell/haskell-language-server/issues/122

To create binaries:

* `nix build` or `nix build .#haskell-language-server` - default GHC version
* `nix build .#haskell-language-server-901` - GHC 9.0.1 (substitute GHC version as appropriate)

## Testing

The tests make use of the [Tasty](https://github.com/feuerbach/tasty) test framework.

There are two test suites in the main haskell-language-server package, functional tests, and wrapper tests.
Some of the wrapper tests expect `stack` to be present on the system, or else they fail.
Other project packages, like the core library or plugins, can have their own test suite.

### Testing with Cabal

Running all the tests

```bash
$ cabal test
```

Running just the functional tests

```bash
$ cabal test func-test
```

Running just the wrapper tests

```bash
$ cabal test wrapper-test
```

Running a subset of tests

Tasty supports providing
[Patterns](https://github.com/feuerbach/tasty#patterns) as command
line arguments, to select the specific tests to run.

```bash
$ cabal test func-test --test-option "-p hlint"
```

The above recompiles everything every time you use a different test option though.

An alternative, which only recompiles when tests (or dependencies) change:

```bash
$ cabal run haskell-language-server:func-test -- -p "hlint enables"
```

## Using HLS on HLS code

Refer to the [HLS project configuration guidelines](../configuration.md#configuring-your-project-build) as they also apply to the HLS project itself.

Note: HLS implicitly detects the HLS codebase as a Stack project (since there is a `stack.yaml` file).
If you want HLS to use Cabal, create this `hie.yaml` file at the root of the project:

```yaml
cradle:
  cabal:
```

## Manually testing your hacked HLS
If you want to test HLS while hacking on it (you can even test it on HLS codebase itself, see previous section), you need to:

1. (Once) Find the path to the hacked HLS you build
2. (Once) Configure your editor to use it
3. (Every time you change the HLS code) Rebuild HLS
4. (Every time you change the HLS code) Restart the LSP workspace

### Find the path to the hacked HLS you build
Note that unless you change the GHC version or the HLS version between builds, the path should remain the same, this is why you need to set it only once.

#### Using Cabal
Run:
```shell
$ cabal build exe:haskell-language-server && cabal list-bin exe:haskell-language-server
[..]
<some long path>/haskell-language-server
```

#### Using Stack
Run:
```shell
$ echo $(pwd)/$(stack path --dist-dir)/build/haskell-language-server/haskell-language-server
[..]
<some long path>/haskell-language-server
```

### Configure your editor to use it

#### VS Code
When using VS Code you can set up each project to use a specific HLS executable:

- If it doesn't already exist in your project directory, create a directory called `.vscode`.
- In the `.vscode` directory create a file called `settings.json` with the below contents.
```json
{
    "haskell.serverExecutablePath": "/path/to/your/hacked/haskell-language-server"
}
```

#### Emacs
There are several ways to configure the HLS server path:
- `M-x customize-group<RET>lsp-haskell<RET>Lsp Haskell Server Path`
- Evaluate `(setq lsp-haskell-server-path "/path/to/your/hacked/haskell-language-server")`
- Create a file `.dir-locals.el` with the following content:
```lisp
((haskell-mode . ((lsp-haskell-server-path . "/path/to/your/hacked/haskell-language-server"))))
```

### Rebuild HLS
- With Stack: `stack build haskell-language-server:exe:haskell-language-server`
- With Cabal: `cabal build exe:haskell-language-server`

### Restart the LSP workspace

- With VS Code: Press `Ctrl + Shift + p` and type `Haskell: Restart Haskell LSP Server`
- With Emacs: `M-x lsp-workspace-restart`

## Style guidelines

The project includes a [`.editorconfig`](https://editorconfig.org) [file](https://github.com/haskell/haskell-language-server/blob/master/.editorconfig) with the editor basic settings used by the project.
However, most editors will need some action to honour those settings automatically.
For example vscode needs to have installed a specific [extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig).
Please, try to follow those basic settings to keep the codebase as uniform as possible.

### Formatter pre-commit hook

We are using [pre-commit](https://pre-commit.com/) to configure git pre-commit hook for formatting. Although it is possible to run formatting manually, we recommend you to use it to set pre-commit hook as our CI checks pre-commit hook is applied or not.

If you are using Nix or Gitpod, pre-commit hook is automatically installed. Otherwise, follow instructions on
[https://pre-commit.com/](https://pre-commit.com/) to install the `pre-commit` tool, then run the following command:

```sh
pre-commit install
```

#### Why some components are excluded from automatic formatting?

- `test/testdata` and `test/data` are there as we want to test formatting plugins.
- `hie-compat` is there as we want to keep its code as close to GHC as possible.

## Introduction tutorial

See the [tutorial](./plugin-tutorial.md) on writing a plugin in HLS.

## Measuring, benchmarking and tracing

### Metrics

When ghcide is built with the `ekg` flag, HLS opens a metrics server on port 8999 exposing GC and ghcide metrics. The ghcide metrics currently exposed are:

- `ghcide.values_count` - count of build results in the store
- `ghcide.database_count` - count of build keys in the store (these two would be the same in the absence of GC)
- `ghcide.build_count` - build count. A key is GC'ed if it is dirty and older than 100 builds
- `ghcide.dirty_keys_count` - non transitive count of dirty build keys
- `ghcide.indexing_pending_count` - count of items in the indexing queue
- `ghcide.exports_map_count` - count of identifiers in the exports map.

### Benchmarks

If you are touching performance sensitive code, take the time to run a differential
benchmark between HEAD and master using the benchHist script. This assumes that
"master" points to the upstream master.

Run the benchmarks with `cabal bench`.

It should take around 25 minutes and the results will be stored in the `bench-results` folder. To interpret the results, see the comments in the `bench/Main.hs` module.

More details in [bench/README](../../bench/README.md)

### Tracing

HLS records opentelemetry [eventlog traces](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/runtime_control.html#rts-eventlog) via [opentelemetry](https://hackage.haskell.org/package/opentelemetry). To generate the traces, build with `-eventlog` and run with `+RTS -l`. To visualize the traces, install [Tracy](https://github.com/wolfpld/tracy) and use [eventlog-to-tracy](https://hackage.haskell.org/package/opentelemetry-extra) to open the generated eventlog.

## Adding support for a new editor

Adding support for new editors is fairly easy if the editor already has good support for generic LSP-based extensions.
In that case, there will likely be an editor-specific support system for this (like `lsp-mode` for Emacs).
This will typically provide instructions for how to support new languages.

In some cases you may need to write a small bit of additional client support, or expose a way for the user to set the server's [configuration options](#configuring-haskell-language-server) and
for them to configure how the server is started.

## Building the docs

The docs are built with [Sphinx](https://www.sphinx-doc.org/en/master/) and [ReadTheDocs](https://docs.readthedocs.io/en/stable/index.html), the documentation for both is helpful.

To build the docs you need to install some Python prerequisites. You can either `pip install -r docs/requirements.txt`, or simply enter a `nix-shell`.

Then to build and preview the docs:

```
cd docs
make html
firefox _build/html/index.html
```

Alternatively, you can build the entire thing as a Nix derivation from the flake with `nix build .#docs`.

The docs are also built and previewed on every PR, so you can check them from the PR status.

## Working on code actions

To make HLS easier to maintain, please follow these design guidelines when adding or modifying code actions:

1. Prefer `ghc-exactprint` to manual text parsing.
2. Prefer `ghc-exactprint` to manual code generation.
3. Code generating actions should not try to format the generated code. Assume that the user is also leveraging HLS for automated code formatting.
4. Put new code actions in their own plugin unless they are very closely aligned with an existing ghcide code action.

## Sponsorship

If you want to contribute financially you can do so via [open-collective](https://opencollective.com/haskell-language-server). In the past the funding has been used to sponsor [summer student projects](https://mpickering.github.io/ide/posts/2021-07-22-summer-of-hls.html).

repository: haskell/haskell-language-server

gha_language: Haskell

repo_name: haskell/haskell-language-server


text:
---
title: Neckline drop
pattern: wahid
option: necklineDrop
---

This options allows you to lower your neckline below the defalt.

> This option also allows negative values, they will raise the neckline higher than the default.

repository: eleonoremilbou/markdown

repo_name: eleonoremilbou/markdown


text:
# Findings

# UX Design

UX design is a human-centered approach to creating products and services. It takes into account how the user perceives the overall experience. UX is concerned with how this overall interaction feels. The UX designers use wireframes to communicate their initial design ideas and to demonstrate how the design will function. Wireframes can be hand-drawn or created on a computer, and are often used when designing digital products.

UX Designer conduct user research and usability tests, determine information architecture and collaborate with the UI designers,developers and other key stakeholders.

# UI Design

UI design is a human-centered approach to creating all of the visual and interactive elements of a digital product. UI is what you use to interact with a product (buttons, screens, scrollbars,etc). They put it into a real life.

UI designers design button, icons and animations, chooses typograph and color palettes and ensure the design is responsive.

A good UI Design must be

* Valuable
* Accessible
* Beautiful
* Invisible
* Intuitive

A UX designer should always keep this five(5) main thing in mind throughout the process: Psychology, Usability, Design, Analysis and Copywritting. To become a better UX/UI designer you have to be able to solve challenges and real life problems to improve your skills.

#  UI/UX Fundamentals

* Useful
* Usable
* Findable
* Credible
* Accessible
* Desirable
* Valuable

**Useful:** Your content should be original and fulfill a need.

**Usable:** Site must be easy to use.

**Desirable:** Image, identity, brand, and other design elements are used to evoke emotion and appreciation.

**Findable:** Content needs to be navigable and locatable onsite and offsite.

**Accessible:** Content needs to be accessible to people with disabilities.

**Credible:** Users must trust and believe what you tell them

repository: TOBECHI-GH/rename-fork

branch_name: refs/heads/main

repo_name: TOBECHI-GH/rename-fork


text:
## Library Sample

This example is used in the [MongoDB blog posts](http://sculptorgenerator.org/tags.html#MongoDB-ref) (e.g. [MongoDB with Sculptor - Introduction](http://sculptorgenerator.org/2010/04/27/mongodb-with-sculptor---introduction/)).

repository: sculptor/sculptor

branch_name: refs/heads/develop

gha_language: Java

repo_name: sculptor/sculptor


text:
[![codecov](https://codecov.io/gh/odahu/odahu-flow/branch/develop/graph/badge.svg)](https://codecov.io/gh/odahu/odahu-flow)

## Documentation

Latest version of [documentation](https://docs.odahu.org/about.html)

## Changelog
Latest updates in [CHANGELOG](https://docs.odahu.org/ref_changelog.html)

## Backlog and Kanban Board
* [Backlog](https://github.com/odahu/odahu/issues)
* [Kanban Board](https://github.com/orgs/odahu/projects/1)

## License
[Apache 2.0](LICENSE)

## Contribution
If you are interested in contribution to project feel free to create an issue in [backlog](https://github.com/odahu/odahu/issues), create a pull request.

repository: odahu/odahu-flow

gha_language: Go

repo_name: odahu/odahu-flow


text:
# User Installation
Simply send the libraries in the root directory of the zip file to your calculator using TI Connect CE or TILP.

See below for the download link.

# Developer Installation

*Note to developers:* Because of versioning for these libraries, it is highly recommended you do not include these libraries with your programs. You can simply link the release in so that way users have an ability to download the latest version: https://github.com/CE-Programming/libraries/releases/latest

To use this libraries in development, simply navigate to the `\dev` directory, and copy all the files and folders inside to `CEdev\lib\ce`.

Once copied, you can simply `#include <lib/ce/libname.h>` to use the library's functions within your program.


text:
# mercury-redux-entity-service

Create an entity definition capable of loading resources as a list or by ID with smart caching

## Installation
`yarn add @leadhome/entity`

repository: leadhomesa/mercury-redux-entity-service

repo_name: leadhomesa/mercury-redux-entity-service


text:
---
author: guidedmissile
comments: true
date: 2014-05-26 08:21:23+00:00
excerpt: Python Introduction, Quick Start, Data Types, Loops, Functions, File Operations
layout: page
link: https://inlovewithcode.wordpress.com/learnpython/python-i-introduction/
slug: python-i-introduction
title: Introduction - Quick Start
wordpress_id: 163
---

#### Introduction

Python is a well-designed language with a reasonably clean syntax, a comprehensive standard library, excellent included and third-party documentation, widespread deployment, and the immediacy of a "scripting" style language (ie. no explicit compile step) ([Source](http://programmers.stackexchange.com/questions/5427/why-such-popularity-with-python))

https://imgs.xkcd.com/comics/python.png

Dear reader, we believe you have a fair understanding of what programming language means and little knowledge of how it is. Programming is not just about doing some chit-chat learning, and code some that work & gives a specified output. Like everything - place, object, person,. a programming language has its own beauty. For a while, doing web surfing you may feel beauty is also about speed, while you a search for project & contents, it's about finding more links and more information from multiple sources,. Like in this case, you see beauty can be variable, so does for programming languages as well.

You can browse the application of Python in there in almost everywhere internet - [https://www.python.org/about/apps/](https://www.python.org/about/apps/)

**Few things to know**

  1. Python Interactive shell: It’s dynamic, case-sensitive, attractive and simple Style.

  2. You don't specifically have to define type of the variables.

  3. Variables – Type Checking: In order to know about a variable type you already defined u can use a default function "type"

  4. Simple help function.

  5. Dir function: To know all about the operations that are available defined about a default function we use "dir" function. dir()

Note: Dear Pythonists, we call python as batteries loaded. It mean, python comes with all basic to great and many more wonderful libraries which are useful to you and help your escape burden to write lots of code. From a calculator program to setting up a small scale database, we have probability one of the best set of open source tools and packages in and around to do almost any kind of jobs.

In python, you will learn all things in a week or two but to be the best you got to beat the best. For that, you need to **learn more about packages** and others which we will learn soon after you finish this page.

  6. Python is very stylish. Don’t believe me? Why not try?

In python very imp is coding design - indentation is very important! The Founding father of Python, Guido van Rossum have made a strict rule of this, to make sure that code is more readable. I personally did not like when I started learning about python but during my years of experience in Python, I found that this is my 2nd favorite thing in Python while 1st being Python has a added advantage of C and Java.

  7. If you are having py 2.6 or later versions you will be provided a IDLE - Editor for writing `py` script.py is the suffix for py scripts or code files.  .pyc for compiled files; if you are saving a file with .py - once u right-click on it will get option "open with IDLE"

Once you open a script - "Alt + X" for check the py script IDLE.  In shell you have to "import" to run a function defined in script, after syntax check and import - do `dir()` ;

  1. If you have already did `import` once and edited - to import again use `reimport` .

**How to put comments in a Python Script?**

There are more than a couple of ways to do this in Python.

  * One way is to use `#` keyword, for single line comments.

  * Second way is to use triple quote, also known as multiline comments. Here we use (`'''` or `"""` ), 3 continuous quotes - use either single or double, these quotes should be in pairs. One set of quotes to start comments and other set is to end comments.

**How to import a script/module/re-import?**

import script/reimport script # syntax check

### Tutorial  Part 1:

Get ready for basic experimentation.

Mathematics

    >>> 12 + 12
    >>> 12.0 * 12
    >>><PHONE_NUMBER>0000000

Strings

    >>> bjorn = "Hello World"
    >>> print bjorn
    >>> dir(bjorn)
    >>> type(bjorn)
    >>>  print “a”,”a”
    >>> print “a” + “a”

Lists

    >>> bjorn = []
    >>> bjorn.append('1')

Tuples

    >>> tup1 = (1,2,3)
    >>> (x,y,z) = tup1
    >>> print x
    >>> print x,y,z

Dictionary

    >>> bjorn = dict()
    >>> dict['sam'] = 'teacher'

IO - operations

    >>> data = input(“input data please:”)
    >>> data = raw_input(“input data :”)

Function Declaration

    def myPrint(input1):
        print input1
        return 'success'

Loops

    for i in range(12):
    print i

    for i in range(12):
    print i, # comma is present here

    i = 0;
    while i < 12:
    print i
    i = i + 1;

Logical Operators

    “and” “or” “=” “==” “!=” “is” “is not” “not” “”

# please checks the data types & method from Wikipedia for more info: doing above operations will help you do some simple operations in py. (WikiLink)

File Operations - writing

    fp = open("newfile.py",'w')
    fp.write('This is new file')
    fp.close()

File Operations - Reading

    fp = open("newfile.py",'r')
    fp.readlines()

This fetches all the data in form of a list of rows.

    fp.read()

This fetchall the all the data info file with one go as a single connected string. We can use, instead of “fp.readlines” for reading a file.

    fp.close()

http://www.openbookproject.net/thinkcs/python/english2e/
http://imagefriend.com/python-language-comic.shtm
http://www.jeffpalm.com/fox/fox.jpg

extension: markdown


text:
# MastersStudentsMarks

# This is an excel file with 3 sheets.

## studentInput:

The main sheet where Data will be entered

## studentList:

The output sheet where a list of students will be found

## lists:

A sheet holding calculation data and lists used for the Drop down menus.

# studentInput Sheet:

This sheet is where the data will be input of each student:

## Fields:
    Name:
      Where the student name is entered
    Surname:
      Where the student surname is entered
    Field choice:
      Drop down where the Choice of field is chosen
### Section A:
    Masters (Psyc) Mark:
      If the student has completed their M in Psyc then their grade average is entered here.
    PhD (Psyc) Completed:
      If the student has completed a Psyc PhD then a one is entered into the field. Otherwise a 0 is entered.
    University:
      The university of the student is entered
    Hons:
      Location:
        The location where Hons was completed
      Year:
        The Year that Hons was attempted
#### Section A Subject Info:
    Name:
      A soft Dropdown of the Subject that is to be entered
    Year:
      The year Level of the subject
    Grade:
      The percentage grade that the student received
### Section B:
    Work Experience:
      Drop down of the relevant work experience that the student has.
    Academic (Non psycology):
      Drop down of the highest level of academic progress achieved

**Section B Work experience will be flagged when exporting student if the experience contains a value Designated as 'other'**

## Using studentInput sheet:
### Meanings of buttons:
#### New Student:
  Clears all data and increments a counter to keep track of the studentList sheet
#### Add Subject:
  Adds the information entered into the Subject info fields to the table on the right hand side.
#### Undo Subject:
  Removes the last entered subject and resets the counter.
  **DO NOT REMOVE AN INCORRECT SUBJECT ANY OTHER WAY!!!!**
#### Export student:
  Sends the entered info to the studentList sheet.

# lists sheet:
  Here a collection of tables thats values are self evident can be found.

  Also included is the control panel. This data should not be changed unless a mistake was made or other data needs to be changed:

## Control panel:

- Line Counter: A counter used to keep track of the Row Cloumn of stdentList
- Unique Years: The number of unique Years used in the calculation of Section A
- Current Year: The current year of data input.
- Y1: total of grades for Year One in section A
- Y2: total of grades for Year Two in section A
- Y3: total of grades for Year Three in section A
- YH: total of grades for Honours in section A
- YM: The average achieved in masters
- YPHD: Whether a PHD was achieved
- Section A: total for section A
- X: The calculated amount of X
- Work Exp Weight: The weight of work Experience
- Academic Exp Weight: Weight of Academic experience
- Y: Calculated amount of Y
- Final Score: The final calculated Score

***The Other Values in control panel should not be adapted UNDER ANY CIRCUMSTANCES***


text:
# Model Factory

Machine learning today is powering many businesses today, e.g., search engine, e-commerce, news or feed recommendation. Training high quality ML models is critical to all of these systems.

However, training a model is not trivial. Traditionally, engineers use single devvm to train models. It might be doable if you were only to build a few models. If you are interested in exploring hundreds or even thousands of ideas, repeating the workflow manually will be a painful process.

There are many issues with the above workflow:
* **Hard to scale**
* **No tracking**
* **No monitor**
* **No end-to-end automation**
* **Not easy to share with others**
* **No centralized model management**

The above pain points really slows engineers down when they are developing their ML models. Model factory is a project that targets at addressing the above issues.

# Background
There are existing work in the industry which tries to address the above issues as well, e.g., Facebook fblearner, Google Kubeflow.

The key difference between model factory and other projects is that model factory promotes a **pure python based authoring experience**, while most others uses DAG (Directed Acyclic Graph). The philosophy gives model factory the following advantages:
* **Easy to learn**: there is almost no learning curve. As long as you know how to write python, you know how to use model factory.
* **More flexible**: control flow logic can be easily implemented on it.
* **Allow communication between nodes**: free form communication can be done between operators, which opens up the possibility of building distributed training on top of model factory.

# Installation
Please follow the [Installation](docs/installation.md) page to deploy model factory in your production or testing environment.

# Development Guide
Please follow the [Development Guide](docs/development_guide.md) page to try out your first model factory pipeline.

repository: realzhukaihua/model-factory

repo_name: realzhukaihua/model-factory


text:
---
id: d6-7
title: "Building a robust data pipeline with the dAG stack: dbt, Airflow, Great Expectations"
url: /sessions/2021/building-a-robust-data-pipeline-with-the-dag-stack
speakers:
 - Sam Bail
time_start: 2021-07-14T18:30:00.000Z
time_end: 2021-07-14T19:20:00.000Z
block: d
slot: 6
format: presentation
aliases:
 - /sessions/Building-a-robust-data-pipeline-with-the-dAG-stack
crowdcast_id: 31
video: https://youtu.be/cmcFMz0xsz0
slides: 2021/d6-dAGStack.pdf
---

Data quality has become a much discussed topic in the fields of data engineering and data science, and it has become clear that data validation is absolutely crucial to ensuring the reliability of any data products and insights produced by an organization’s data pipelines. This session will outline patterns for combining three popular open source tools in the data ecosystem - dbt, Airflow, and Great Expectations - and use them to build a robust data pipeline with data validation at each critical step.

repository: softwareguru/airflowsummit-website

gha_language: HTML

gha_license_id: NOASSERTION

repo_name: softwareguru/airflowsummit-website


text:
# How to install if you have standalone Prometheus

Update your Prometheus configuration file’s `remote_write` section, as per the documentation [here](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#remote_write), by taking the `remoteWrite` section of the `prometheus-overrides.yaml` file, and making the following changes:

* `writeRelabelConfigs:` change to `write_relabel_configs:`
* `sourceLabels:` change to `source_labels:`
*  Modify remote URLs in the `remoteWrite` section of the `prometheus-overrides.yaml` file

The URLs in `remoteWrite` section of the `prometheus-overrides.yaml` file uses `env` variables which need to be changed to point to the correct location.

- Replace `$(CHART)` with the `release name-namespace` that you have used while installing the Sumo Logic helm chart.
- Replace `$(NAMESPACE)` with the namespace where Prometheus is running.

For example:\
If you have installed the Sumo Logic helm chart with release name `collection` in the `sumologic` namespace and Prometheus is running in the `prometheus` namespace:
```
`$(CHART).$(NAMESPACE)` will be replaced by `collection-sumologic.prometheus`
```

__NOTE__ To filter or add custom metrics to Prometheus, [please refer to this document](additional_prometheus_configuration.md)


text:
# Resource Watch Knowledge Graph

![screen shot 2017-06-07 at 3 06 04 pm](https://user-images.githubusercontent.com/545342/26879898-fb6500e6-4b92-11e7-8bdc-8dc469b1cf2b.png)

## Online Data browser

http://<IP_ADDRESS>:7474/browser/

## Data model

### Current node types

* CONCEPT
* DATASET

### Current relationship types

* RELATED_TO _This is a generic relationship used whenever it's not possible to use one of the more specific types_
* TYPE_OF
* PART_OF
* LOCATED_AT
* TAGGED_WITH
* AFFECTS
* IS_A
* CAN_AFFECT
* IS_INVOLVED_IN
* IS_SIMILAR_TO

### Current database schema

![screen shot 2017-06-07 at 4 00 13 pm](https://user-images.githubusercontent.com/545342/26882355-76464606-4b9a-11e7-85eb-ec5326379df1.png)

## Database creation

The knowledge graph of concepts is generated from the information stated in [this Google Spreadsheet](https://docs.google.com/a/vizzuality.com/spreadsheets/d/1awsO5aPEOv_OEFTakIhn-Ej7RFw46UP-jUWXnskPRqk/edit?usp=sharing).

### Step by step guide to import the Graph

1. Download the aforementioned spreadsheet as a CSV file
2. Upload it to the server using scp
3. Copy it to the folder called **import** that is located inside the Neo4j installation
4. Download the JSON file resulting from this request to the WRI API https://api.resourcewatch.org/dataset/?app=rw&includes=vocabulary
5. Execute the JAVA program: [src/main/java/com/vizzuality/CreateDatasetTagCSV.java]
6. Upload the resulting file to the server using scp
7. Copy it to the folder called **import** that is located inside the Neo4j installation
8. Execute the various Cypher statements included in the file: [ImportDBCypher.txt](ImportDBCypher.txt)

> Steps 4-7 can be skipped in the case you're not interested in adding the screenshot of datasets and their tags as a proof of concept

## Examples of queries

### Get all concepts that are descendants of the term 'energy'

```
MATCH (n:CONCEPT)-[*]->(e:CONCEPT {id: 'energy'})
RETURN n,e
```

![screen shot 2017-06-07 at 4 04 00 pm](https://user-images.githubusercontent.com/545342/26882540-f684425a-4b9a-11e7-83b9-46b204188045.png)

### Get all datasets tagged with water or any of the descendants of water

```
MATCH (d:DATASET)-[:TAGGED_WITH]->(c:CONCEPT)-[*]->(c2:CONCEPT)
WHERE c.id='water' OR c2.id='water'
RETURN d,c,c2
```

![screen shot 2017-06-07 at 4 29 42 pm](https://user-images.githubusercontent.com/545342/26883827-8dfe50a0-4b9e-11e7-9338-fbe176e4f0c1.png)

### Whole graph

```
MATCH p=()-[]-() return p
```
> Not recommended for computers with performance problems

repository: knesto/graph

repo_name: knesto/graph


text:
# LaravelTreats\Controllers

A set of multi-purpose base controllers for Laravel 5.

## Basic Usage

Composer takes care of autoloading, so you can simply have your controllers extend
the ones included in this package:

```php
<?php
namespace App\Http\Controllers;

class MyController extends \LaravelTreats\Controller\Controller
{
    // ...
```

If your controllers don't use the default namespace of `App\Http\Controller`,
specify that in a `$controllerNamespace` property on each of your controllers
(or a parent, which extends `LaravelTreats\Controller\Controller` and is extended by all
of your controllers):

```php
class MyController extends \LaravelTreats\Controller\Controller
{

    /** @var string $controllerNamespace The default controller namespace. */
    protected $controllerNamespace = 'App\Http\Controllers\\';
```

## Primary Controller

The top-level `LaravelTreats\Controller\Controller` provides some useful boilerplate features
commonly used in web apps.

### General Controller Setup

If you have general setup actions you'd like to perform for all actions in your
controller, you can do so by adding a `general()` method to your controller:

```php
class MyController extends \LaravelTreats\Controller\Controller
{

    /** @return mixed General setup for the whole controller. */
    protected function general()
    {
        // do stuff here
    }
```

If your `general()` method returns anything, it will override the default behavior,
which is to return (and eventually render) an `Illuminate\View\View` object.

### Default Views

`LaravelTreats\Controller\Controller` will cause your app to automatically look for view
scripts in a directory structure that matches the routing path. For example,
if a user navigates to the `getIndex` action in a `HomeController`, `LaravelTreats\Controller\Controller`
will look for a view script at `resources/views/home/index.blade.php` (or just `index.php`).

You can override the default mapping by adding a `$viewScript` property with
the desired view script path:

```php
class MyController extends \LaravelTreats\Controller\Controller
{

    /** @var string $viewScript Allows child classes to override the standard view script mapping. */
    protected $viewScript = 'custom.index';
```

If you need to override the standard view script path mapping in a conditional
manner, you can do so at the beginning of a custom `callAction()`:

```php
class MyController extends \LaravelTreats\Controller\Controller
{

    /**
     * Extends parent::callAction()
     *
     * @param string $method
     * @param array $parameters
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function callAction($method, $parameters)
    {
        if ('index' === $method)
            $this->viewScript = 'custom.index';

        return parent::callAction($method, $parameters);
    }
```

To exclude certain actions within the controller from standard view setup, simply
add them to an `$viewless` property on the controller:

```php
class MyController extends \LaravelTreats\Controller\Controller
{

    /** @var array $viewless Actions with no view script. */
    protected $viewless = ['logout'];
```

## API Controller

The `LaravelTreats\Controller\Api\Controller` provides a foundation for a RESTful API interface
that can be used to handle all of your app's CRUD opperations. It is an extension
of a Laravel "resource" controller.

### Basic usage

First, create a controller that extends `LaravelTreats\Controller\Api\Controller`:

```php
<?php
namespace App\Http\Controllers\Api;

class GroupController extends \LaravelTreats\Controller\Api\Controller
{
}
```

Then just add a route to `routes/web.php`:

```php
Route::group(['namespace' => 'Api', 'prefix' => 'api', 'as' => 'api.'], function() {
    Route::resource('group', 'GroupController');
}
```

If you choose to use a different URL route other than `/api/controllerName`, you'll
need to specify that using the `$routePrefix` property on the controller:

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /** @var string $routePrefix The route name prefix used for the API. */
    protected $routePrefix = 'resource.';
```

You now have a fully-functional REST enpoint at `example.com/api/group`!

### Database Interaction

`LaravelTreats\Controller\Api\Controller` works on the assumption that you have an Eloquent
model whose name matches the controller name. So in the `GroupController` example
above, an `App\Model\Group` class will be used to perform the CRUD operations.
You can specify a custom model namespace using a `$modelNamespace` property.

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /** @var string $modelNamespace The default model namespace. */
    protected $modelNamespace = '\\App\\';
```

To specify a custom model name, use a `$model` property on the API controller:

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /** @var string $model The fully-qualified model class name. */
    protected $model = '\\App\\CustomGroup';
```

### Injecting the ID of the Current Logged-in User

If you'd like `LaravelTreats\Controller\Api\Controller` to automatically inject the ID of
the current logged-in User, simply add a $injectUserId property to the controller:

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /** @var bool $injectUserId Should we inject a user_id into the input for every request? */
    protected $injectUserId = true;
```

### Custom Redirect URL

By default, `LaravelTreats\Controller\Api\Controller` will redirect back to the referring
page after the API action is performed. To specify a custom redirect URL for an
API controller, use the `$redirectUrl` property:

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /** @var string $redirectUrl Optional custom redirect URL. */
    protected $redirectUrl = '/home';
```

### Custom Lookup Logic

You can customize the way the API controller looks up records for the `index()`
action by adding a `findModel()` method:

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /**
     * Use the current input to find a record.
     *
     * @return Illuminate\Database\Eloquent\Model
     */
    protected function findModel()
    {
        // do stuff

        return Illuminate\Database\Eloquent\Model;
    }
```

### Customize Filling the Model with the Input

You can customize the way the API controller fills a model with input during
create by adding a fillModel() method. Remember, objects in PHP are automatically
passed by reference.

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /**
     * Fill the model with the input.
     *
     * @param Illuminate\Database\Eloquent\Model $model
     */
    protected function fillModel(Model $model)
    {
        $model->fill($this->input);
    }
```

### Custom Fetch Validation Rules

You can customize the way the API controller looks up validation rules by adding
a  `getValidationRules()` method:

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /**
     * Get validation rules for the current model.
     *
     * @return array
     */
    protected function getValidationRules()
    {
        $class = $this->model;

        return $class::$rules;
    }
```

### Custom Permission Checking

To add permission checking for the `update()` method, add a `canEdit()` method
to your controller. Returning false will block the request:

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /** @return bool Check if the current User can edit the given model. */
    protected function canEdit(Model $model)
    {
        return true;
    }
```

To add general permission checking for the whole controller, add a `checkPermissions()`
method to the controller. Returning false will block the request:

```php
class GroupController extends \LaravelTreats\Controller\Api\Controller
{

    /** @return bool Authorize the current User for this action. */
    protected function checkPermissions()
    {
        return true;
    }
```

gha_language: Less


text:
# PharmacyPrototype_Web

This website will allow pharmacies to register and provide details about their pharmacies.

## Working Process.

1. Pharmacy Registers.
2. Pharmacy is veriied.
3. Pharmacy keeps contantly updating price and stock of their products as they change.
4. All information is stored in our database.

### Database
    the database is accesed by our app to provide users realtime information(medication,location,price).


text:
---
languages:
- csharp
products:
- windows-wpf
page_type: sample
name: "Formatting a String on a Binding Sample"
---

# Formatting a String on a Binding Sample
This sample formats bound data by using the StringFormat property on a Binding and a MultiBinding. The sample binds a ListView to a collection of items for sale and uses the StringFormat on the Binding for the price to format the value as a currency. The sample also binds a ListBox to the collection and uses StringFormat on a MultiBinding to display a string that includes the description and price for each item.

## Build the sample
The easiest way to use these samples without using Git is to download the zip file containing the current version (using the link below or by clicking the "Download ZIP" button on the repo page). You can then unzip the entire archive and use the samples in [Visual Studio 2019](https://www.visualstudio.com/wpf-vs).

### Deploying the sample
- Select Build > Deploy Solution.

### Deploying and running the sample
- To debug the sample and then run it, press F5 or select Debug >  Start Debugging. To run the sample without debugging, press Ctrl+F5 or selectDebug > Start Without Debugging.

gha_language: C#


text:
You would like to add some code or fix an error?

**That's great!**

Please follow these instructions:

**1.** **[Create a new issue](https://github.com/udos86/ng-dynamic-forms/issues/new)** and give a detailed bug report or feature proposal.

**2.** [**Fork**](https://help.github.com/articles/fork-a-repo/) the NG Dynamic Forms repository.

**3.** **Switch to branch** `udos86:development` **and checkout a new feature branch** based on it.

**4.** Implement your code and verify it's functionality **by including some tests**.

**5.** Create a [**pull request**](https://help.github.com/articles/creating-a-pull-request/) from your branch
**into the original development branch** `udos86:development`.

**6.** **Wait for the Travis build to succeed**.

**7.** After a final code review your contribution will be merged or declined.

**Thank You!**

license: ISC

gha_language: TypeScript

gha_license_id: ISC


text:
## [Unreleased][]

* Your contribution here!

## [0.35.0][] (2018-09-03)

* Update x-sendfile configuration so that it works with Sidekiq's assets
* Move `dotenv:update` earlier in the deploy process so that new settings can be configured prior to the Rails app loading via `assets:precompile` or `db:migrate`

## [0.34.1][] (2018-07-08)

* [#18](https://github.com/mattbrictson/capistrano-mb/pull/18): Use `tee` to fix a problem where certain provisioning steps would fail for a non-root user

## [0.34.0][] (2018-05-20)

* Ubuntu 18.04 LTS is now supported
* Remove unnecessary steps from `mb:rbenv:modify_bashrc`
* Remove defunct `provision:12_04` and `provision:14_04` tasks

## [0.33.0][] (2017-12-29)

* Remove the deprecated `fiftyfive` compatibility layer
* Drop compatibility with older Ubuntu releases; now only Ubuntu 16.04 is supported via a single `provision` task
* Remove dependencies on `ppa:pitti` and `ppa:chris-lea` for postgres and node.js, respectively; use the official Ubuntu releases instead
* Replace init_d scripts with systemd configs
* Completely remove delayed_job support

## [0.32.0][] (2017-05-26)

* Add [immutable cache-control header](https://code.facebook.com/posts/557147474482256) to further boost performance of static assets
* Prefer IPv4 when fetching apt repo keys

## [0.31.0][] (2016-10-14)

* Ensure `software-properties-common` package is installed during `provision:14_04` so that `apt-add-repository` works.
* Don't echo dotenv values for keys with `pepper` in the name.
* Add `ntp` to the list of packages installed on all server roles.
* Fix "Capistrano tasks may only be invoked once" warning when using `deploy:migrate_and_restart` with Sidekiq.

## [0.30.0][] (2016-08-30)

* Change the hooks such that `mb:crontab` is run at the end of every deployment,
  rather than once during provisioning. This means that the crontab will now be
  regenerated and installed every time you `cap deploy`.
* Fix a `NoMethodError` when showing certain compatibility warnings [#14](https://github.com/mattbrictson/capistrano-mb/issues/14)

## [0.29.0][] (2016-07-19)

* Add `public/.well-known` to `:linked_dirs` to support Let's Encrypt renewals.
* Fix recipe definition code so that Capistrano's `invoke` is not used
  redundantly. This is not a change in behavior, but it does fix a warning that
  is printed starting in Capistrano 3.6.0.

## [0.28.0][] (2016-05-13)

* Add `--quiet` to the default `bundle install` flags
* Enable SSH compression by default, now that zlib warning has been fixed in
  SSHKit 1.10.0

## [0.27.0][] (2016-02-19)

* Symlink `.bundle` so that every release shares the same `.bundle/config`. This allows `bundle:check` to work, speeding up deployments when the Gemfile hasn't changed.
* Work around a regression in capistrano-bundler so that the Bundler path stays the same. See [capistrano-bundler #79](https://github.com/capistrano/bundler/pull/79).

## [0.26.0][] (2016-01-08)

* Remove `mb:postgresql:tune` task. The [pgtune](https://github.com/gregs1104/pgtune) tool no longer works with the latest versions of PostgresSQL.
* Overhaul the `mb:rbenv:*` tasks.
  * Use the official rbenv-installer script
  * Install necessary dev packages via `mb:aptitude:install` rather than relying on an external (and outdated) script
  * Remove several unused rbenv plugins, keeping only: `ruby-build`, `rbenv-vars`, `rbenv-update`
  * Install plugins using our own code, rather than using external script
  * No longer install the `psych` gem

## [0.25.0][] (2015-10-09)

* Add `X-Accel-Mapping` and appropriate NGINX configuration so that `send_file` used in a Rails controller is now accelerated using `X-Accel-Redirect`. For security this only works if the file being sent resides in the Rails app directory (e.g. `<rails_root>/tmp` or `<rails_root>/public`). This means `send_file` files will be served by NGINX natively, rather than through Rack.

## [0.24.0][] (2015-09-11)

* Improve README with step-by-step installation instructions.
* Expand the list of cipher suites used in the nginx SSL configuration. ([#7](https://github.com/mattbrictson/capistrano-mb/pull/7))

## [0.23.1][] (2015-08-08)

* Ensure gzip is enable for all assets, not just fingerprinted ones.

## [0.23.0][] (2015-07-10)

This release introduces a `bundler` recipe that automatically installs or upgrades bundler using `gem install bundler` during `cap deploy`. To disable this behavior:

```ruby
set :mb_bundler_gem_install_command, nil
```

Other changes:

* No longer assume that the `colorize` gem is available (it may be removed in an upcoming version of SSHKit/capistrano).

## [0.22.2][] (2015-06-22)

* For backwards compatibility with capistrano-fiftyfive, also search `lib/capistrano/fiftyfive/templates` for template files (the preferred location is `lib/capistrano/mb/templates`).

## [0.22.1][] (2015-06-22)

* Remove "capistrano-fiftyfive has been renamed to capistrano-mb" post-install message.

## [0.22.0][] (2015-06-22)

**THIS GEM HAS A NEW NAME! It is now `capistrano-mb`.**

* All settings now use the `mb_` prefix. E.g. if you are using `set(:fiftyfive_recipies, ...)`, change it to `set(:mb_recipes, ...)`.
* All tasks now use the `mb` namespace. E.g. `cap fiftyfive:crontab` is now `cap mb:crontab`.
* For backwards compatibility, you can still use the `fiftyfive` versions, but a deprecation warning will be printed. This compatibility will be removed in capistrano-mb 1.0.

## [0.21.0][] (2015-06-22)

* Add a post-install message explaining the rename of `capistrano-fiftyfive` to `capistrano-mb`.

## [0.20.1][] (2015-05-29)

* An internal change in Capistrano 3.4.0 caused `fiftyfive:aptitude:install` to fail to install packages. This is now fixed.

## [0.20.0][] (2015-05-29)

* Increase SSL/TLS security of the generated nginx configuration by following the suggestions of [weakdh.org](https://weakdh.org/sysadmin.html).

## [0.19.0][] (2015-04-10)

* Add `--retry=3` to bundle install options. This will help prevent deployment failures in case that a gem initially fails to download during the `bundle install` step.
* Ensure that `--dry-run` works without crashing. This involved working around Capistrano's `download!` behavior (it returns a String normally, but an entirely different object during a dry run).

## [0.18.0][]

* **The abbreviated log formatter has been removed and is now available in a new gem: `airbrussh`.** With this change, capistrano-fiftyfive no longer automatically changes the logging format of capistrano. To opt into the prettier, more concise format, add the airbrussh gem to your project as explained in the [airbrussh README](https://github.com/mattbrictson/airbrussh#readme).
* The version initializer that capistrano-fiftyfive adds during deployment sets a new value: `Rails.application.config.version_time`. You can use this value within your app for the date and time of the last commit that produced the version that is currently deployed.

## [0.17.2][]

* Default self-signed SSL certificate is now more generic (for real this time).

## [0.17.1][]

* Cosmetic changes to the gemspec.

## [0.17.0][]

* Write a banner message into `capistrano.log` at the start of each cap run, to aid in troubleshooting.
* Default self-signed SSL certificate is now more generic.

## [0.16.0][]

* capistrano-fiftyfive now requires capistrano >= 3.3.5 and sshkit => 1.6.1
* `ask_secretly` has been removed in favor of Capistrano's built-in `ask ..., :echo => false`
* `agree` no longer takes an optional second argument
* highline dependency removed
* Install libffi-dev so that Ruby 2.2.0 can be compiled

## [0.15.2][]

* The capistrano-fiftyfive GitHub repository has changed: it is now <https://github.com/mattbrictson/capistrano-fiftyfive>.

## [0.15.1][]

* Remove `-j4` bundler flag

## [0.15.0][]

* Dump useful troubleshooting information when a deploy fails.
* Nginx/unicorn: fix syntax errors introduced by changes in 0.14.0, ensuring that gzip and far-future expires headers are sent as expected.

## [0.14.0][]

* The `highline` gem is now a dependency ([#3](https://github.com/mattbrictson/capistrano-fiftyfive/pull/3) from [@ahmozkya](https://github.com/ahmozkya)).
* Dotenv: only mask input when prompting for keys containing the words "key", "secret", "token", or "password". Input for other keys is echoed for easier data entry.
* Dotenv: update `.env` files in sequence rather than in parallel, to avoid parallel command output clobbering the input prompt.
* Nginx/unicorn: tweak reverse-proxy cache settings to prevent cache stampede.
* Nginx/unicorn: apply far-future expires cache headers only for assets that have fingerprints.

## [0.13.0][]

The provisioning tasks now work for a non-root user that has password-less sudo privileges. Assuming a user named `matt` that can sudo without being prompted for a password ([instructions here](http://askubuntu.com/questions/192050/how-to-run-sudo-command-with-no-password)), simply modify `deploy.rb` with:

```ruby
set :fiftyfive_privileged_user, "matt"
```

Now all provisioning tasks that would normally run as root will instead run as `matt` using `sudo`.

## [0.12.0][]

* capistrano-fiftyfive's abbreviated format now honors the new `SSHKIT_COLOR` environment variable. Set `SSHKIT_COLOR=1` to force ANSI color even on non-ttys (e.g. Jenkins).
* The generated nginx config now enables reverse proxy caching by default.
* INFO messages printed by sshkit are now printed to console under the appropriate rake task heading.

## [0.11.1][]

Fixes errors caused by PostgreSQL password containing shell-unsafe characters. Passwords are now safely hashed with MD5 before being used in the `CREATE USER` command.

## [0.11.0][]

* INFO log messages are now included in abbreviated output (e.g. upload/download progress).
* Add `agree()` method to the DSL, which delegates to `HighLine.new.agree`.
* Add `fiftyfive:postgresql:dump`/`restore` tasks.

## [0.10.0][]

Add support for Ubuntu 14.04 LTS. To provision a 14.04 server, use the new `provision:14_04` task.

## [0.9.1][]

Flush console output after each line is printed. This allows deployment progress to be monitored in e.g. Jenkins.

## 0.9.0

Initial Rubygems release!

[Unreleased]: https://github.com/mattbrictson/capistrano-mb/compare/v0.35.0...HEAD
[0.35.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.34.1...v0.35.0
[0.34.1]: https://github.com/mattbrictson/capistrano-mb/compare/v0.34.0...v0.34.1
[0.34.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.33.0...v0.34.0
[0.33.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.32.0...v0.33.0
[0.32.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.31.0...v0.32.0
[0.31.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.30.0...v0.31.0
[0.30.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.29.0...v0.30.0
[0.29.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.28.0...v0.29.0
[0.28.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.27.0...v0.28.0
[0.27.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.26.0...v0.27.0
[0.26.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.25.0...v0.26.0
[0.25.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.24.0...v0.25.0
[0.24.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.23.1...v0.24.0
[0.23.1]: https://github.com/mattbrictson/capistrano-mb/compare/v0.23.0...v0.23.1
[0.23.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.22.2...v0.23.0
[0.22.2]: https://github.com/mattbrictson/capistrano-mb/compare/v0.22.1...v0.22.2
[0.22.1]: https://github.com/mattbrictson/capistrano-mb/compare/v0.22.0...v0.22.1
[0.22.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.21.0...v0.22.0
[0.21.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.20.1...v0.21.0
[0.20.1]: https://github.com/mattbrictson/capistrano-mb/compare/v0.20.0...v0.20.1
[0.20.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.19.0...v0.20.0
[0.19.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.18.0...v0.19.0
[0.18.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.17.2...v0.18.0
[0.17.2]: https://github.com/mattbrictson/capistrano-mb/compare/v0.17.1...v0.17.2
[0.17.1]: https://github.com/mattbrictson/capistrano-mb/compare/v0.17.0...v0.17.1
[0.17.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.16.0...v0.17.0
[0.16.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.15.2...v0.16.0
[0.15.2]: https://github.com/mattbrictson/capistrano-mb/compare/v0.15.1...v0.15.2
[0.15.1]: https://github.com/mattbrictson/capistrano-mb/compare/v0.15.0...v0.15.1
[0.15.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.14.0...v0.15.0
[0.14.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.13.0...v0.14.0
[0.13.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.12.0...v0.13.0
[0.12.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.11.1...v0.12.0
[0.11.1]: https://github.com/mattbrictson/capistrano-mb/compare/v0.11.0...v0.11.1
[0.11.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.10.0...v0.11.0
[0.10.0]: https://github.com/mattbrictson/capistrano-mb/compare/v0.9.1...v0.10.0
[0.9.1]: https://github.com/mattbrictson/capistrano-mb/compare/v0.9.0...v0.9.1

repository: b-ggs/capistrano-mb

repo_name: b-ggs/capistrano-mb


text:
# Pansori
Pansori is a program for creating an ASR corpus from YouTube videos with audio and subtitle data.

## Description
This program currently consists of three modules:

- Ingest: Takes in the YouTube video information and reads it to output an audio file and a text file of the subtitles with timing information
- Slice: Slices the audio file based on the timing information within the subtitle file and assigns the appropriate subtitle to the audio slice
- Validate: Compares the subtitle information to a transcription obtained through using the Google Cloud Speech-to-Text API

This program automatically creates audio segments with aligned text labels by utilizing the timing information stored in the subtitle data to build the corpus faster. It also automatically verifies the audio segments for accuracy using the Google Cloud Speech API.

## Installation
Clone repository:
```bash
$ git clone https://github.com/yc9701/pansori
```

Install *pytube*, a library for downloading YouTube videos.
```bash
$ pip install pytube
```

Install *pysubs*, a library for editing subtitle files.
\*Currently, pysubs2 runs only with Python 3.6; on Python 3.7, this does not work
```bash
$ pip install pysubs2
```

Install *pydub*, a library for manipulating audio.
\*Only necessary if wishing for audio playback
```bash
$ pip install pydub
```

The Google Cloud Speech API is also required for validate.py (an account is required).
* Create a Google Cloud Platform console project and enable the Speech-to-Text API
* Create a service account and download a private key as JSON
* Set the environment variable *GOOGLE_APPLICATION_CREDENTIALS*
* Install and initialize the Cloud SDK

repository: xinkez/pansori

repo_name: xinkez/pansori


text:
# Eat-Da-Burger

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

![Eat-Da-Burger](./public/assets/pictures/Eat-da-burger-screenshot.png)

---

## Table of Contents
- [About the Project](#About-the-Project)
- [Getting Started](#Getting-Started)
- [Installation](#Installation)
- [Contributing](#Contributing)
- [Testing](#Testing)
- [License](#License)

## About the Project
Eat-Da-Burger is a fun app that lets users input the names of burgers they'd like to eat. Whenever a user submits a burger's name, the app will display the burger on the left side of the page.  Each burger in the Pick a Burger area also has a `Devour!` button, when the user clicks it, the burger will move to the right side of the page.

## Getting Started
To get started, visit the app at:

https://fathomless-retreat-85881.herokuapp.com/

### Installation
To run this app localy, clone my repo at:
https://github.com/samrod777/Burger

Then run the following command in your terminal to install required dependencies:

npm install

## Testing
No testing required.

## Contributing
To contribute to this project contact Sam Rodriguez.
Github Repository URL: https://github.com/samrod777/Burger

## License
This application is covered under the MIT license.


text:
# 12-MySQL-Employee-Tracker

##  Repository:
[12-MySQL-Employee-Tracker](https://github.com/TBragg800/12-MySQL-Employee-Tracker)

![License: MIT](https://img.shields.io/badge/License-MIT-brightgreen.svg)
![GitHub repo size](https://img.shields.io/github/repo-size/TBragg800/12-MySQL-Employee-Tracker)

## Walkthrough Video Demonstration:
![Walkthrough](./assets/12-MySQL-Employee-Tracker.gif)
* YouTube link to the
[walkthrough](https://youtu.be/6woeY9KnERs)

## Table of Contents
  [Description](#Description)

  [Installation](#Installation)

  [Usage](#Usage)

  [License](#License)

  [Contributing](#Contributing)

  [Tests](#Tests)

  [Questions](#Questions)

## Description
 This project is a Content Management System made available to the users CLI. This application utilizes node.js to inquirer, and MySQL to architect and build a solution for managing a company's employees.

## Installation
* Begin by cloning the repo locally.
* Using the CLI, the user should navigate to the project directory and run 'npm install'.
* Use MySQL for database handling.

## Usage
  After installation, the user should run 'node employeeTracker.js' in the CLI, then answer the following prompts.

![](./assets/12-MySQL-Employee-Tracker1.png)

## License
  MIT License

Copyright (c) [2020] [Thomas Bragg]

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

## Contributing
  Fork the project & clone locally. Create an upstream remote and sync your local copy before you branch. Branch for each separate piece of work. Do the work, write good commit messages, and read the CONTRIBUTING file if there is one. Push to your origin repository. Create a new PR in GitHub.

## Tests
  There are no test instructions at this time.

## Questions
  All questions should be submitted to the email listed below. Please consult the GitHub profile or Repo for additional concerns.
  Email<EMAIL_ADDRESS>  Github: [TBragg800](http://github.com/TBragg800)

## Screenshot of deployed application
![](./assets/12-MySQL-Employee-Tracker2.png)


text:
# ssb-links

an [ssb-plugin](https://github.com/ssbc/secret-stack/blob/master/PLUGINS.md) that indexes all the links!

This plugin can perform queries about messages that refer to other messages or feeds.

## Example

if you have a handle on the sbot server:
``` js
sbot.use(require('ssb-links')
sbot.links2.read({query: [{$filter: {rel: ['mentions', {$prefix: '@d'}]}}]})
```
OR if sbot is a client...

``` js
links2 = require('ssb-links').init(sbot, {path: '~/.ssb'})
links2.read({query: [{$filter: {rel: ['mentions', {$prefix: '@d'}]}}]})
```

## Installation

Most clients will install ssb-links for you, check if the `ssb-server links2.read --help` command works
If not, to install it manually. Since ssb-links has the same name as a core feature, it actually exposes
it's api as `sbot.links2` it was [originally intended to replace ssb-db.links](https://hackmd.io/IM5_tWIfSFuNoe3jtrjrtQ?view#incomplete-intentions)
but that didn't end up happening. So after installing it you need to configure a different name.
see [the configuration for renaming a plugin](https://github.com/ssbc/ssb-plugins#load-user-configured-plugins).
This is not necessary if you are loading ssb-links directly in javascript code (as in the examples below).

to install `ssb-server plugins.install ssb-links` then to configure
`{"plugins":{"ssb-links": "links2"}}``` to your `~/.ssb/config`.

## database

A leveldb instance will be created in your ssb directory `~/.ssb/flume/links`.
Because of the size of a message id, this will be quite a large index.

## api: links2.read ({query: QUERY, live, reverse, limit})

If there is no query provided, a full scan of the links database
will be performed. this will return a stream of data that looks like

``` js
{
  source: @{author_of_link},
  rel: [{rel}, {rel_data}...],
  dest: @/%/&{link} //the dest can be any type of ssb object.
  ts: {local_timestamp}
}
```

this format will be the input to the query.

### relation data.

this module introduces the concept of "rel data",
the rel is now stored as an array, and the data associated
with the rel stored with it. by indexing it as an array,
it becomes easy to query it when that data is a sortable range
(for example, mention names, which may be alphabetically sorted)

see `./links.js` to see how data is mapped.

TODO: map all markdown links, including http links.

### query syntax

the query must be a valid [map-filter-reduce](https://github.com/dominictarr/map-filter-reduce)

## example queries

these queries are in JSON format so you can use them via the cli,
`ssb-server links2.read --query '{QUERY}'`
be sure to use single quotes around the query so that the json is property
escaped. otherwise, run these queries by passing them to `sbot.links2.read({query: QUERY})`
and taking the output as a [pull-stream](https://github.com/pull-stream/pull-stream).

### all feeds mentioned

counts the number of times each name is used by which feed.

returns a stream all  `{name, feed, uses}`
``` js
[
  {"$filter": {
    "rel": ["mentions", {"$prefix": "@"}]
  }},

  {"$reduce":{
    "name": ["rel", 1], "feed": "dest", "uses": {"$count": true}
  }}
]
```

### thread contributors

returns feeds in each thread, and how many posts they have made.
return object in form of `{[thread_id]:{[poster]:count}}`
``` js
[
  {"$filter": {
    "rel": ["root"]
  }},
  {"$reduce":{
    "thread": "dest", "participant": "source", "posts": {"$count": true}
  }}
]
```

### names used for<EMAIL_ADDRESS>and who mentioned them.

``` js
[
  {"$filter": {
    "rel": ["mentions", {"$prefix": "@"}],
    "dest"<EMAIL_ADDRESS>  }},
  {"$reduce": {
    "name": ["rel", 1], "by": "source", "uses": {"$count": true}
  }}
]
```

## License

MIT

repository: ssbc/ssb-links

gha_language: JavaScript

repo_name: ssbc/ssb-links


text:
# Squash XML JSON

A library to convert XML data to a flat JSON structure, and back.

This is a library suited for those who think of
XML as an asset, not a nuisance. It aims to offers a simple and efficient way of manipulating XML documents without a DOM.

*Squash XML JSON* can handle:
* mixed content
* namespaces and namespace prefixes
* two-way transformation XML <=> JSON

**Dependencies**
* requires [sax.js](https://github.com/isaacs/sax-js) (browser build will bundle it)

## Installation

```shell
npm install squash-xml-json
```

To build and test:

```shell
npm run build && npm test

# to build for use in browser
npm run build-web
```

## Usage

ES6
```JavaScript
import {flattenXML, hydrateXML} from "squash-xml-json"
```
node
```JavaScript
var sxj = require("squash-xml-json")
```
Browser
```html
<script src="squash-xml-json-web.js"></script>
<script>console.log(sxj)</script>
```

## XML to JSON: flattenXML()

*Squash XML JSON* creates a flat structure of "nodes", each identified by an UUID or an element's `xml:id` attribute when present.
This simplifies element lookup in the JSON structure.

```JavaScript
let xml = `<text xmlns="http://www.tei-c.org/ns/1.0">
      <body>
         <p xml:id="p1">Some <emph>text</emph> here.</p>
      </body>
  </text>`
let json = flattenXML(xml)
```

This will result in a JSON object containing each XML node. An element will look like this:

```JavaScript
{
	'p1': {
		'name': 'p',
		'children': ['>td8340e43',
			'>eeb0d435c',
			'>t11da3f7e'
		],
		'@': {
			'xml:id': 'p1'
		},
		'ns': {
			'': 'http://www.tei-c.org/ns/1.0'
		},
		'parent': '>ed8b1db33',
		'id': 'p1'
	}
}
```

The element includes its children's and parent's IDs, which can be used to retrieve those nodes directly form the JSON object. Note that the ID of this element `p1` is derived from its `xml:id` attribute, while other elements get assigned a UUID (truncated in the example).

### Before root

The IDs of processing instructions and text nodes before the root element are listed in a dedicated property called  `>before_root`.

```JavaScript
{
	'>before_root': ['>t8b1ef55d'],
	'>t8b1ef55d': {
		'pi' {
			name: 'xml',
			'body': 'version="1.0" encoding="utf-8"'
		}
	}
}
```

### Options

Set `skipSpace` to `true` to exclude empty text nodes. Do this if you want a leaner JSON and don't care about pretty printing or preserving original spacing.

```JavaScript
flattenXML(xml, {skipSpace : true})
```

## JSON to XML: hydrateXML()

Use `hydrateXML` To serialize a compliant JSON structure back into an XML string:

```JavaScript
let json = {
	'>before_root': [],
	'>ee0c1ac32': {
		name: 'root',
		children: ['>e3cadaf0c'],
		'@': {},
		ns: {},
		parent: null,
		id: '>ee0c1ac32'
	},
	'>e3cadaf0c': {
		name: 'el',
		children: ['>t62d02a9f'],
		'@': {},
		ns: {},
		parent: '>ee0c1ac32',
		id: '>e3cadaf0c'
	},
	'>t62d02a9f': {
		t: 'text',
		parent: '>e3cadaf0c'
	}
}

hydrateXML(json)

//returns "<root><el>text</el></root>"
```

repository: raffazizzi/squash-xml-json

repo_name: raffazizzi/squash-xml-json