text:
---
title: "The Effect of Electronic Benefit Transfer Cards on the Food Consumption of SNAP Recipient"
authors:
- admin
author_notes:
date: "2019"
doi: ""

# Schedule page publish date (NOT publication's date).
publishDate: "2019-11-01T00:00:00Z"

# Publication type.
# Legend: 0 = Uncategorized; 1 = Conference paper; 2 = Journal article;
# 3 = Preprint / Working Paper; 4 = Report; 5 = Book; 6 = Book section;
# 7 = Thesis; 8 = Patent
publication_types: ["3"]

# Publication name and optional abbreviated publication name.
publication: "University of Arizona Working Paper Series"
publication_short: ""

abstract: "The Supplemental Nutrition Assistance Program (SNAP) provides food assistance to nearly 44 million Americans each year. I document a substantial increase in the program’s ability to stimulate food consumption from 1990 to 2010, as measured by the marginal propensity to consume food (MPCf) out of SNAP. I provide the first evidence for a mechanism driving this increase: the transition from paper coupons to Electronic Benefit Transfer (EBT) cards. Using plausibly exogenous variation over states and time I estimate that the introduction of EBT doubles the MPCf out of SNAP and accounts for 25 percent of its observed increase."

# Summary. An optional shortened abstract.
summary: Using plausibly exogenous variation over states and time I estimate that the introduction of EBT doubles the MPCf out of SNAP and accounts for 25 percent of its increase between 1990 and 2016.

tags:
- Supplemental Nutrition Assistance Program (SNAP)
- Electronic Benefit Transfer (EBT)
- Marginal propensity to consume

featured: false

# links:
# - name: ""
#   url: ""
url_pdf: "files/ebt_snap_eck_1119.pdf"
url_code: ''
url_dataset: ''
url_poster: ''
url_project: ''
url_slides: ''
url_source: ''
url_video: ''

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
image:
  caption: 'Image credit: [**Unsplash**](https://unsplash.com/photos/jdD8gXaTZsc)'
  focal_point: ""
  preview_only: false

# Associated Projects (optional).
#   Associate this publication with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `internal-project` references `content/project/internal-project/index.md`.
#   Otherwise, set `projects: []`.
projects: []

# Slides (optional).
#   Associate this publication with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides: "example"` references `content/slides/example/index.md`.
#   Otherwise, set `slides: ""`.
slides:
---

<!-- {{% alert note %}}
Click the *Cite* button above to demo the feature to enable visitors to import publication metadata into their reference management software.
{{% /alert %}}

{{% alert note %}}
Click the *Slides* button above to demo Academic's Markdown slides feature.
{{% /alert %}} -->

<!-- Supplementary notes can be added here, including [code and math](https://sourcethemes.com/academic/docs/writing-markdown-latex/). -->

repository: chase-eck/academic-kickstart

repo_name: chase-eck/academic-kickstart


text:
---
title: "Review: JavaScript30"
date: "2020-04-27"
excerpt: "30 days of exercises. No frameworks. No 3rd party libraries. No tooling. Just VanillaJS."
featuredImage: ../images/js30.png
---

I'm taking the JavaScript30 course by Wes Bos. I've seen several recommendations for [this](https://javascript30.com/) challenge, but it was [Kent C Dodds](https://kentcdodds.com/blog/how-to-react) whose recommendation finally pushed me to sign up and check it out.

I'm going to keep a diary here of my experience. After I finish each day, I'll provide a short list of the key concepts and a **brief** writeup on my thoughts.

Hopefully this will be a good article for people who are curious about what the experience is like or working along and want to compare notes.

#### Day 1: JavaScript Drum Kit

Concepts:

- key events ([these](http://keycode.info/))
- Web Audio API ([this](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API))
- Listener for ```trasitionend``` event (CSS transitions)
- data attributes

Thoughts:

Wow: that took more time than I'd have liked. But, what a strong exercise to start on. As a musician, it was a really cool experience. I've never used the Web Audio API, so I had to read quite a bit to find the documentation for available methods. I like the way he snuck in ```el.classList``` property. That's a great jQuery alternative.

#### Day 2: CSS + JS Clock

Concepts:

- ```transform-origin``` (CSS)
- ```transition-timing-function``` (the easing curve can be shaped manually in Chrome DevTools!)
- ```setInterval()```
- ```Date()```

Thoughts:

Okay. This is a very well-designed course. I just built an analog clock! I honestly learned more about CSS than JS with this one, because I've used ```setInterval()``` and ```Date()``` plenty, but I've never used the transform and transition properties to achieve the effect of rotating clock hands.

#### Day 3: Playing with CSS Variables and JS

Concepts:

- CSS Variables
- NodeList ([this](https://developer.mozilla.org/en-US/docs/Web/API/NodeList), which has a different prototype from standard arrays)
- dataset property in NodeList prototype (to access [data attributes](https://developer.mozilla.org/en-US/docs/Learn/HTML/Howto/Use_data_attributes))

Thoughts:

Again, I feel like I'm learning more about CSS than I expected, but I'm not complaining. This is awesome. I did not know that CSS had native variables yet. But it does, and unlike preprocessed styling (Sass, Less, etc.) they can be updated dynamically by JavaScript... in runtime!

#### Day 4: Array Cardio 1

Concepts:

- ```map()```
- ```reduce()```
- ```filter()```
- ```sort()```
- ```console.table()```

Thoughts:

I've mentioned the last few days have been CSS heavy, not the case today. While I'm familiar with all these array functions, it's always fun to get another chance to use them. I was not familiar with ```console.table``` and it's highly useful for visualizing standard output in the console. My favorite exercise was scraping the Boulevards of Paris from Wikipedia.

#### Day 5: Flex Panels Image Gallery

Concepts:

- flex (css)
- event-driven class toggle
- ```transform: translate()```
- cubic-bezier

Thoughts:

Very cool exercise. I really enjoy the ones like these that touch on event-driven transitions and animations via class toggle. It's such a common pattern, but the possibilities for creative interactivity are endless. I didn't learn many new concepts per se, but it was a very creative and unique idea.

Stay tuned...

#### Day 6: AJAX Type Ahead

Concepts:

- Fetch API
- Promises & ```then()```
- ```json()```
- Spread syntax

Thoughts:

This is the best pattern (common and useful) for filtering large datasets in realtime as a user interacts with a form. I always appreciate when this type of feedback is provided into the UI.

#### Day 7: Array Cardio 2

Concepts:

- ```.some()```
- ```.every()```
- ```.find()```
- ```.findIndex()```

Thoughts:

I love arrays. JavaScript provides many useful methods for operating on arrays. Knowing all the methods and when to use them is a very useful skill for a JS developer.

#### Day 8: Fun with HTML5 Canvas

Concepts:

Thoughts:

license: MIT

repository: peterlanier/gatsby-blog

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: peterlanier/gatsby-blog


text:
# Zimnat-Insurance-Challenge
1st Place Solution

The data describes 51,685 life assurance policies, each identified by a unique Policy ID. Each year, some policies lapse as clients change jobs, move countries etc. The information on these policies are in multiple files.

Numerical quantities have been transformed, and many categories have been assigned unique IDs in place of the original text.

The objective of this hackathon is to develop a predictive model that determines the likelihood for a customer to churn - to seek an alternative insurer or simply stop paying for insurance altogether.

sample_submission.csv contains rows for the remaining Policy IDs (with ‘?’s in TRAIN). You must predict which of these policies marked with '?' will lapse in 2020.

Files available for download
client_data.csv - Contains some personal information on the principal member, such as location, branch and agent code, age etc.
payment_history.csv - Contains payment history up to the end of 2018 tied to Policy ID. Payments made in 2019 are not provided.
policy_data.csv - Describes the policies themselves. There may be multiple rows for each Policy ID since policies can cover more than one person.
train.csv - contains a list of all the policies. Policies that lapsed in 2017, 2018 or 2019 are identified with a 1 in the ‘Lapse’ column, and the year is provided. The policies with a '?' in the 'Lapse' and 'Lapse Year' column are the policies that remained and had not lapsed as of the end of 2019. You must estimate the likelihood that these policies lapsed or not in 2020.
sample_submission.csv - is an example of what your submission should look like. The order of the rows does not matter but the name of the ID must be correct.
variable_defintions.txt - definitions of the variables

https://zindi.africa/hackathons/the-zimnat-insurance-assurance-challenge/data


text:
# Coveo Standalone Search Box for Lightning Community
Simple lighting component to create a Coveo Standalone Search Box in a Salesforce Community

# Installation

Start by cloning the repo locally.

```
git clone https://github.com/coveo/community-standalone-search-box
cd community-standalone-search-box
```

Make sure you have NodeJs installed, and then execute

```
npm install -g gulp
npm install
```

Before deploying, enter your Salesforce credential in a `salesforce.config.json` file (you can simply rename the `salesforce.config.json.sample` file provided and fill it with your informations).

```json
{
  "SF_USERNAME": "USERNAME",
  "SF_PASSWORD": "PASSWORD",
  "SF_SECURITYTOKEN": "SECURITY_TOKEN",
  "SF_SERVERURL": "https://login.salesforce.com"
}
```

Save it and that's it ! Gulp should now be able to deploy the component into your Salesforce organization.

```
gulp
```

#How do I use it ?

Let's assume you already have a Coveo search page in your community.

First, you'll need to edit the Coveo Search lightning component and uncheck the `Auto-initilize` option.

Next, go to the `Settings` > `Theme` tab in your Community builder.
You should see an option named `Use a custom search component`, enable it and select the `CoveoSearchBar` in the dropdown below it.

Finally, go back to the `Page Editor` and select the search bar.
The default "search url" (your Coveo search page name) is `coveosearch`, change it if needed.

# Known issues / disclaimer
The project is meant to be an example of what you can achieve with the new "search region" and Coveo's search box.
There's still some known issues and we don't support that component as for now so use it at your own risk.

Of course, if you find a bug and fix it, I'll be more than happy to accept your pull request ;)


text:
# Concepts

## Flow Control

Flow control is the mechanism to **throttle the traffic** in order to protect endpoints that are under resource constraints.- Technically it's a scaling problem

gha_language: JavaScript

gha_license_id: MIT


text:
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## v0.3.2 - 2020-02-15

- Remove runtime gem dependency on actionpack.

## v0.3.1 - 2019-05-08

- Fix env calculation timing.

## v0.3.0 - 2019-05-05

### Added

- Support symbol keys in request headers.

## 0.2.2 - 2018-05-13

### Fixed

- Fix bug: Ignore case-sensitivity of HTTP headers.

## 0.2.1 - 2017-02-27

### Fixed

- Fix error from `#process`.

## 0.2.0 - 2017-02-27

### Added

- Support actionpack 5.1.0.

### Changed

- Declare runtime dependency on actionpack.

## 0.1.1 - 2016-05-15

### Fixed

- Prevent warning for Rails 5.

## 0.1.0 - 2015-10-09

### Changed

- Rename `method` with `http_method`.

## 0.0.9 - 2015-06-24

### Changed

- Ignore case-sensivity on Content-Type checking.

## 0.0.8 - 2015-05-20

### Changed

- Use more sophisticated method capture pattern.

## 0.0.7 - 2015-04-20

### Added

- Add `send_request` to explicitly call `subject`.

## 0.0.6 - 2015-02-12

### Fixed

- Allow any non-space characters in URL path.

## 0.0.5 - 2014-12-25

### Fixed

- Allow hyphen in path.

## 0.0.4 - 2014-12-18

### Added

- Define HTTPS as reserved header name.

## 0.0.3 - 2014-10-13

### Removed

- Remove dependency on ActiveSupport's `Object#in?`.

## 0.0.2 - 2014-09-25

### Added

- Support RSpec 3.

## 0.0.1 - 2014-08-29

### Added

- 1st Release.

branch_name: refs/heads/main

gha_language: Ruby


text:
# Culture

High level description of corporate culture what it means and its importance.

Focus on the primarily used corporate and organizational culture
- Hiearchical
  - position/seniority based
  - chain of command
  - distance between workers and managers
  - merit based reward system

How corporate culture affects social culture.

What is valued?
  - employees
  - ideas/innovation
  - work output
How are issues resolved/handled?
  - individual preference
    - isolated and quiet
    - free to broadcast concerns
  - protected from retaliation
  - are they tracked to identify large scale problems
  - just enough to be compliant and above board legally

## Management communication approaches that affect diversity and inclusion
///expand sections
Open door policies

Tell HR

Up to supervisor or manager to handle

## Methods

Value diversity
- rewards and recognition
  create an award system for recongizing groups for their diversity and inclusion (competition)
- seek opinions from different view points
- discuss issues that matter
  have a diverse voice (it shouldn't be a single person or a non diverse group talking about diversity events or matters)
- point out lack of inclusion within groups
  not to be forced but can be for different view points or education

Protect diversity
- in house rules
- identify internal issues
- survey organization
  open to employees
  third party evaulation

## Ways to establish and maintain organizational culture

1. evalute current culture
2. create transition plan to accomodate D&I initiatives
3. execute transition plan
4. post transition engagement
5. create reevaluation methods to identify problems and succsesses
6. feedback gap areas/outcomes into new transition plan and execution

responsibilities of all employees

responsibilities of management

Next Section:
[Recruitment](https://killumslow.github.io/Open-Social-Diversity-Initiative/content/recruitment)

branch_name: refs/heads/release


text:
---
layout: post
title: "Lossless Audio [FLAC]: Album Perdana Santana (1969)"
description: "Album perdana band rock Santana asal Amerika. Rilis tahun 1969 remaster tahun 1998. Riping audio format lossless"
author: mukidi
tags: [audio, romansa]
current: [romansa]
class: post-template
subclass: [post, tag-romansa]
navigation: true
---

## Deskripsi Album Santana

![cover album santana 1969](https://cdn.statically.io/img/lossless-flac.com/uploads/posts/2015-06/thumbs/1434619265_santana-santana-eu-col-489542-2-kopiya.jpg)

Santana is the debut studio album by the American rock band Santana. More than half of the album consists of instrumental music. At the suggestion of manager Bill Graham, the band began writing more conventional songs for more impact, but managed to keep the essence of improvisation in the music.
According to the music site AllMusic, "Santana is a foundational exponent of the Latin rock style, mainly due to the combination of Latin percussion with the characteristic piercing sound of Carlos Santana's lead guitar."
Santana - Santana (1969)

## Daftar lagu dalam Album Santana:

![CD Audio](https://cdn.statically.io/img/lossless-flac.com/uploads/posts/2015-06/1434619244_cd.jpg)

01. Waiting (4:07)
02. Evil Ways (4:01)
03. Shades Of Time (3:14)
04. Savor (2:47)
05. Jingo (4:23)
06. Persuasion (2:37)
07. Treat (4:47)
08. You Just Don't Care (4:38)
09. Soul Sacrifice (6:47)
10. Savor (Live At The Woodstock Festival Saturday, August 16, 1969) (5:30)
11. Soul Sacrifice (Live At The Woodstock Festival Saturday, August 16, 1969) (11:39)
12. Fried Neckbones (Live At The Woodstock Festival Saturday, August 16, 1969) (7:14)

Total: [01:01:43]

## Bonus track

Track 10 and 12 sebelumnya tidak dirilis. Sedangkan Track 11 dirilis Woodstock (Cotillion SD3-500) pada Juli 1970
Bonus track dirilis atas lisensi Atlantic Recording Corporation.

_Matrix:_ Sony Music S0248954210-0101 12 A1

## Detil File

|Santana|Santana|
|---|---|
|Artist:| Santana|
|Album:| Santana|
|Style:| Rock, Latin|
|Label:| Sony Music. Made in EU|
|Catalog #:| 489542 2|
|Released:| 1969 (Remastered 1998 Super Bit Mapping)|
|Format:| FLAC (image + .cue)|
|Quality:| lossless|
|Covers:| Complete set (600 dpi)|
|Amount of tracks:| 12|
|Size RAR:| ~ 416.65 mb.|
|Archive:| [Download RAR](https://nitroflare.com/view/A3834CA86236E21/S_69_r98_S.rar)|
|Password RAR|moote|

repository: paciran/www

repo_name: paciran/www


text:
# DryWrapper
Testable class wrappers for CLR

DryWrapper is a simple project that wraps .NET basic classes  so you can easily mock them.

## Use
Just add DryWrapper directory to your project and you're set to go.

## Related
* [SystemWrapper](http://systemwrapper.codeplex.com/)
* [UnitWrappers](https://github.com/OpenSharp/UnitWrappers)
* [IO Abstractions](http://systemioabstractions.codeplex.com/)


text:
# Changelog

## Unpublished

### 🛠 Breaking changes

- Deprecate `RCTDeviceEventEmitter` in favor of the renamed `DeviceEventEmitter`. ([#8826](https://github.com/expo/expo/pull/8826) by [@EvanBacon](https://github.com/EvanBacon))

### 🎉 New features

- Remove `prop-types` ([#8681](https://github.com/expo/expo/pull/8681) by [@EvanBacon](https://github.com/EvanBacon))
- Add `Platform.isDOMAvailable` to detect web browser environments. ([#8645](https://github.com/expo/expo/pull/8645) by [@EvanBacon](https://github.com/EvanBacon))
- Add `Platform.select()` method to switch values between platforms. ([#8645](https://github.com/expo/expo/pull/8645) by [@EvanBacon](https://github.com/EvanBacon))

### 🐛 Bug fixes

## 5.4.0 — 2020-05-29

### 🐛 Bug fixes

- Made it possible for SSR (node) environments that don't bundle using platform extensions to work without resolving native code. ([#8502](https://github.com/expo/expo/pull/8502) by [@EvanBacon](https://github.com/EvanBacon))

## 5.3.0 — 2020-05-27

_This version does not introduce any user-facing changes._

repository: mrexodia/expo

gha_license_id: NOASSERTION

repo_name: mrexodia/expo


text:
# Contributing to Infracost

The overall process for contributing to Infracost is:
1. Check the [project board](https://github.com/infracost/infracost/projects/2) to see if there is something you'd like to work on; these are the issues we'd like to focus on in the near future. There are also [other issues](https://github.com/infracost/infracost/issues) that you might like to check; the issue labels should help you to find a good first issue, or new resources that others have already requested/liked.
2. Create a new issue if there's no issue for what you want to work on. Please put as much as details as you think is necessary, the use-case context is especially helpful if you'd like to receive good feedback.
3.  Send a pull request from your fork to this repo with the proposed change (don't forget to run `make lint` and `make fmt` first). Please include unit and integration tests where applicable. We use [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
4. We'll review your change and provide feedback.

## Development

Install Go dependencies:
```sh
make deps
```

Get an API key.
```sh
make run ARGS="register"
```
Alternatively checkout and run the [cloud-pricing-api](https://github.com/infracost/cloud-pricing-api) and set the `INFRACOST_PRICING_API_ENDPOINT` environment variable to point to it.

Add the API key to your `.env.local` file:
```
cat <<EOF >> .env.local
INFRACOST_API_KEY=XXX
EOF
```

Run the code:
```sh
make run ARGS="--terraform-dir examples/terraform --usage-file=examples/terraform/infracost-usage.yml"
```

Run all tests:
```sh
make test
```

Exclude integration tests:
```sh
make test ARGS="-v -short"
```

Build:
```sh
make build
```

## Adding new resources

### Quickstart AWS

_Make sure to get familiar with the pricing model of the resource first by reading the cloud vendors pricing page._ To begin, add a new file in `internal/providers/terraform/aws/` as well as an accompanying test file.

```go
package aws

import (
	"fmt"

	"github.com/infracost/infracost/internal/schema"
	"github.com/shopspring/decimal"
)

func GetMyResourceRegistryItem() *schema.RegistryItem {
	return &schema.RegistryItem{
		Name:  "aws_my_resource",
		RFunc: NewMyResource,
	}
}

func NewMyResource(d *schema.ResourceData, u *schema.UsageData) *schema.Resource {

	region := d.Get("region").String()
    var instanceCount int64 = 1

	costComponents := []*schema.CostComponent{
		{
			Name:           fmt.Sprintf("Instance (on-demand, %s)", "my_instance_type"),
			Unit:           "hours",
			UnitMultiplier:  1,
			HourlyQuantity: decimalPtr(decimal.NewFromInt(instanceCount)),
			ProductFilter: &schema.ProductFilter{
				VendorName:    strPtr("aws"),
				Region:        strPtr(region),
				Service:       strPtr("AmazonES"),
				ProductFamily: strPtr("My AWS Resource family"),
				AttributeFilters: []*schema.AttributeFilter{
					{Key: "usagetype", ValueRegex: strPtr("/Some Usage type/")},
					{Key: "instanceType", Value: strPtr("Some instance type")},
				},
			},
			PriceFilter: &schema.PriceFilter{
				PurchaseOption: strPtr("on_demand"),
			},
		},
	}

	return &schema.Resource{
		Name:           d.Address,
		CostComponents: costComponents,
	}
}
```

Next append the resource to the registry in `internal/providers/terraform/aws/registry.go`.

```go
package aws

import "github.com/infracost/infracost/internal/schema"

var ResourceRegistry []*schema.RegistryItem = []*schema.RegistryItem{
	...,
  GetMyResourceRegistryItem(),
}

```

Finally create a temporary terraform file to test your resource and run (no need to commit that):

```
make run ARGS="--terraform-dir my_new_terraform/"
```

### Detailed notes

When adding your first resource, we recommend you look at one of the existing resources to see how it's done, for example, check the [nat_gateway.go](internal/providers/terraform/aws/nat_gateway.go) resource. You can then review the [price_explorer](scripts/price_explorer/README.md) scripts that help you find various pricing service filters, and something called a "priceHash" that you need for writing integration tests.

We distinguish the **price** of a resource from its **cost**. Price is the per-unit price advertised by a cloud vendor. The cost of a resource is calculated by multiplying its price by its usage. For example, an EC2 instance might be priced at $0.02 per hour, and if run for 100 hours (its usage), it'll cost $2.00. When adding resources to Infracost, we can always show their price, but if the resource has a usage-based cost component, we can't show its cost. To solve this problem, new resources in Infracost go through two levels of support:

You can add all price components for the resource, even ones that are usage-based, so the price column in the table output is always populated. The hourly and monthly cost for these components will show `-` as illustrated in the following output for AWS Lambda. Once this is done, please send a pull-request to this repo so someone can review/merge it. Try to re-use relevant costComponents from other resources where applicable, e.g. notice how the `newElasticacheResource` function is used in [aws_elasticache_cluster](https://github.com/infracost/infracost/blob/master/internal/providers/terraform/aws/elasticache_cluster.go) and [aws_elasticache_replication_group](https://github.com/infracost/infracost/blob/master/internal/providers/terraform/aws/elasticache_replication_group.go).

Please use [this pull request description](https://github.com/infracost/infracost/pull/91) as a guide on the level of details to include in your PR, including required integration tests.

  ```
  NAME                                        MONTHLY QTY  UNIT         PRICE   HOURLY COST  MONTHLY COST

  aws_lambda_function.hello_world
  ├─ Requests                                           -  1M requests  0.2000            -             -
  └─ Duration                                           -  GB-seconds    2e-05            -             -
  Total                                                                                -             -
  ```

#### Adding usage example

Infracost supports passing usage data in through a usage YAML file. When adding a new resource we should add an example of how to specify the usage data in [infracost-usage-example.yml](/infracost-usage-example.yml). This should include an example resource and usage data along with comments detailing what the usage values are. Here's an example of the entry for AWS Lambda:

  ```yaml
  aws_lambda_function.my_function:
    monthly_requests: 100000      # Monthly requests to the Lambda function.
    request_duration_ms: 500      # Average duration of each request in milliseconds.
  ```

When running infracost with `--usage-file path/to/infracost-usage.yml`, Infracost output shows the hourly/monthly cost columns populated with non-zero values:

  ```
  NAME                                        MONTHLY QTY  UNIT         PRICE   HOURLY COST  MONTHLY COST

  aws_lambda_function.hello_world
  ├─ Requests                                         100  1M requests  0.2000       0.0274       20.0000
  └─ Duration                                   3,750,000  GB-seconds    2e-05       0.0856       62.5001
  Total                                                                              0.1130       82.5001
  ```

### Cost component names and units

Our aim is to make Infracost's output understandable without needing to read separate docs. We try to match the cloud vendor pricing webpages as users have probably seen those before. It's unlikely that users will have looked at the pricing service JSON (which comes from cloud vendors' pricing APIs), or looked at the detailed billing CSVs that can show the pricing service names. Please check [this spreadsheet](https://docs.google.com/spreadsheets/d/1H_bn2jLzYr7xyrvNsFn-0rDaGPGpnrVTPsjVHzr-kM4/edit#gid=0) for examples of cost component names and units.

Where a cloud vendor's pricing pages information can be improved for clarify, we'll do that, e.g. on some pricing webpages, AWS mention use "Storage Rate" to describe pricing for "Provisioned IOPS storage", so we use the latter.

#### Resource notes

The following notes are general guidelines, please leave a comment in your pull request if they don't make sense or they can be improved for the resource you're adding.

- count: do not include the count in the cost component name or in brackets. Terraform's `count` replicates a resource in `plan.json` file. If something like `desired_count` or other cost-related count parameter is included in the `plan.json` file, do use count when calculating the HourlyQuantity/MonthlyQuantity so each line-item in the Infracost output shows the total price/cost for that line-item.

- units:
  - use plural, e.g. hours, months, requests, GB-months, GB (already plural). For a "unit per something", use singular per time unit, e.g. use Per GB per hour. Where it makes sense, instead of "API calls" use "API requests" or "requests" for better consistency.

  - for things where the Terraform resource represents 1 unit, e.g. an `aws_instance`, an `aws_secretsmanager_secret` and a `google_dns_managed_zone`, the units should be months (or hours if that makes more sense). For everything else, the units should be whatever is being charged for, e.g. queries, requests.

  - for data transferred, where you pay for the data per GB, then use `GB`. For storage, where you pay per GB per month, then use `GB-months`. You'll probably see that the Cloud Pricing API's units to use a similar logic. The AWS pricing pages sometimes use a different one than their own pricing API, in that case the pricing API is a better guide.

- unit multiplier: when adding a `costComponent`, set the `UnitMultiplier` to 1 unless the price is for a large number, e.g. set it to `1000000` if the price should be shown "per 1M requests" in the output.

- tiers in names: use the K postfix for thousand, M for million, B for billion and T for trillion, e.g. "Requests (first 300M)" and "Messages (first 1B)". Use the words "first", "next" and "over" when describing tiers. Units should not be included in brackets unless the cost component relates to storage or data transfer, e.g. "Storage (first 1TB)    GB" is more understandable than "Storage (first 1K)    GB" since users understand terabytes and petabytes.

- purchase options: if applicable, include "on-demand" in brackets after the cost component name, e.g. `Database instance (on-demand`

- instance type: if applicable, include it in brackets as the 2nd argument, after the cost component name, e.g. `Database instance (on-demand, db.t3.medium)`

- storage type: if applicable, include the storage type in brackets in lower case, e.g. `General purpose storage (gp2)`.

- upper/lower case: cost component names should start with a capital letter and use capital letters for acronyms, unless the acronym refers to a type used by the cloud vendor, for example, `General purpose storage (gp2)` (as `gp2` is a type used by AWS) and `Provisioned IOPS storage`.

- unnecessary words: drop the following words from cost component names if the cloud vendor's pricing webpage shows them: "Rate" "Volumes", "SSD", "HDD"

- brackets: only use 1 set of brackets after a component name, e.g. `Database instance (on-demand, db.t3.medium)` and not `Database instance (on-demand) (db.t3.medium)`

- free resources: if there are certain conditions that can be checked inside a resource Go file, which mean there are no cost components for the resource, return a `NoPrice: true` and `IsSkipped: true` response as shown below.
	```
	// Gateway endpoints don't have a cost associated with them
	if vpcEndpointType == "Gateway" {
		return &schema.Resource{
			NoPrice:   true,
			IsSkipped: true,
		}
	}
	```

- unsupported resources: if there are certain conditions that can be checked inside a resource Go file, which mean that the resource is not yet supported, log a warning to explain what is not supported and return a `nil` response as shown below.
	```
	if d.Get("placement_tenancy").String() == "host" {
		log.Warnf("Skipping resource %s. Infracost currently does not support host tenancy for AWS Launch Configurations", d.Address)
		return nil
	}
	```

- to conditionally set values based on the Terraform resource values, first check `d.Get("value_name").Type != gjson.Null` like in the [google_container_cluster](https://github.com/infracost/infracost/blob/f7b0594c1ee7d13c0c37acb8edfb36dde223471a/internal/providers/terraform/google/container_cluster.go#L38-L42) resource. In the past we used `.Exists()` but this only checks that the key does not exist in the Terraform JSON, not that the key exists and is set to null.

- use `IgnoreIfMissingPrice: true` if you need to lookup a price in the Cloud Pricing API and NOT add it if there is no price. We use it for EBS Optimized instances since we don't know if they should have that cost component without looking it up.

#### Usage file notes

1. Where possible use similar terminology as the cloud vendor's pricing pages, their cost calculators might also help.

2. Do not prefix things with `average_` as in the future we might want to use nested values, e.g. `request_duration_ms.max`.

3. Use the following units and keep them lower-case:
  - time: ms, secs, mins, hrs, days, weeks, months
  - size: b, kb, mb, gb, tb

4. Put the units last, e.g. `message_size_kb`, `request_duration_ms`.

5. For resources that are continuous in time, do not use prefixes, e.g. use `instances`, `subscriptions`, `storage_gb`. For non-continuous resources, prefix with `monthly_` so users knows what time interval to estimate for, e.g. `monthly_log_lines`, `monthly_requests`.

#### Google resource notes

1. If the resource has a `zone` key, if they have a zone key, use this logic to get the region:
	```
	region := d.Get("region").String()
	zone := d.Get("zone").String()
	if zone != "" {
		region = zoneToRegion(zone)
	}
	```

## Release steps

@alikhajeh1 and @aliscott rotate release responsibilities between them.

1. In [here](https://github.com/infracost/infracost/actions), click on the "Go" build for the master branch, click on Build, expand Test, then use the "Search logs" box to find any line that has "Multiple products found", "No products found for" or "No prices found for". Update the resource files in question to fix these error, often it's because the price filters need to be adjusted to only return 1 result.
2. In the infracost repo, run `git tag vx.y.z && git push origin vx.y.z`
3. Wait for the GH Actions to complete, the [newly created draft release](https://github.com/infracost/infracost/releases/) should have the mac/linux/windows assets.
4. Click on the Edit draft button, add the release notes from the commits between this and the last release and click on publish.
5. In the `infracost-atlantis` repo, run the following steps so the Atlantis integration uses the latest version of Infracost:

	```
	# you can also push to master if you want the GH Action to do the following.
	git pull
	docker build --no-cache -t infracost/infracost-atlantis:latest .
	docker push infracost/infracost-atlantis:latest
	```

6. Wait for the [infracost brew PR](https://github.com/Homebrew/homebrew-core/pulls) to be merged.
7. Announce the release in the infracost-community Slack announcements channel.
8. Update the docs repo with any required changes and supported resources.
9. Close addressed issues and tag anyone who liked/commented in them to tell them it's live in version X.

If a new flag/feature is added that requires CI support, update the repos mentioned [here](https://github.com/infracost/infracost/tree/master/scripts/ci#infracost-ci-scripts). For the GitHub Action, a new tag is needed and the release should be published on the GitHub Marketplace. For the CircleCI orb, the readme mentions the commit prefix that triggers releases to the CircleCI orb marketplace.

repository: DanielMabbett/infracost

repo_name: DanielMabbett/infracost


text:
# Citation

To cite this software package:

**Bibtex**

	:::bash
	@misc{wongpycmtensor,
		author       = {Melvin Wong},
		title        = {PyCMTensor: Tensor-based choice modelling estimation Python package},
		year         = 2023,
		publisher    = {Zenodo},
		version      = {v1.3.2},
		doi          = {10.5281/zenodo.8074154},
		url          = {https://doi.org/10.5281/zenodo.8074154}
	}

gha_language: Python


text:
# queryable-promise

A utility library for inspecting promises during development.

## Installation

```sh
npm i queryable-promise
```

## Usage

```js
const queryable = require('queryable-promise');

const val = queryable(superFunPromiseFunction(val));
await val;

console.log(val.isResolved()); // `true`
console.log(val.val()); // whatever the resolved value is.
```

repository: ttacon/queryable-promise

repo_name: ttacon/queryable-promise


text:
![Cagou git](doc/cagou-git.png)
# mygitserver

<!-- vim-markdown-toc GFM -->

* [Description](#description)
* [What's done](#whats-done)
* [Warning](#warning)
* [Selinux](#selinux)
* [How to give user access.](#how-to-give-user-access)
    * [General need](#general-need)
    * [Ok but what about mygitserver ?](#ok-but-what-about-mygitserver-)
        * [Every body can read, nobody can right using Git](#every-body-can-read-nobody-can-right-using-git)
        * [Every body can read and right (DANGEROUS) using Git](#every-body-can-read-and-right-dangerous-using-git)
        * [Every body can read, nobody can right using Apache](#every-body-can-read-nobody-can-right-using-apache)
        * [Every body can read and right (DANGEROUS) using Apache](#every-body-can-read-and-right-dangerous-using-apache)
        * ["Everyone at home and the hippos will be well looked after"  using Apache](#everyone-at-home-and-the-hippos-will-be-well-looked-after--using-apache)
    * [Next ...](#next-)
    * [Links](#links)
* [TODO](#todo)

<!-- vim-markdown-toc -->

## Description

Create a simply git server based on [cgit](https://git.zx2c4.com/cgit/about/)
for teams who do not want to install complex externals systems as
[GitLab](https://about.gitlab.com/)

The solution must use package available in Linux distros:
* http web server
* cgit
* ssh
* ssl
* kerberos/ldap...

The solution must easily create multiple servers for different users/groups.

The solution must give cli interface.

## What's done

The **mygitserver** script creates a httpd user environment using
[apache](http://httpd.apache.org/docs/current/) configuration.

It's developed on [Arch](https://www.archlinux.org/) and tested on [CentOS
7](https://www.centos.org)

    Usage: mygitserver [--help|-h]
                  [--run]
                  [--update]
                  [--user <user>]
                  [--group <group>]
                  [--systemd-enable]
                  [--systemd-uninstall]
                  [--listen-port <port>]
                  [--system-cgit-script-dir]
                  [--system-cgit-script-name]
                  [--system-cgit-data-dir]

    	--help|-h                  : This help
    	--run                      : Run the server after creation.
                                     Only works for current user.
    	--update                   : Update config file in existing env.
    	--user                     : Install service for his user.
                                     Default is current user (fccagou)
    	--group                    : Install service for this group.
    	                             Default is current user group(fccagou).
    	--systemd-enable           : configure user systemd service and runs it.
                                     Only works for current user.
    	--systemd-uninstall        : remove user systemd configuration
                                     Only works for current user.
    	--listen-port              : Define http listen port.
    	                             Must be greter then 1024.
    	                             Default is 8080.
    	--system-cgit-script-dir   : Define cgit script dir
    	--system-cgit-script-name  : Define cgit script name relative to script dir
    	--system-cgit-data-dir     : Define cgit dir containing web matérial (css, png)
    	--add-myself-as-git-sample : Clone myself in repos.
    	prefix_env                 : dir where cgit and http data will be created

Will create :

    prefix_env
     ├── cgit
     │   ├── cgitrc
     │   └── repos
     └── web
         ├── conf
         │   ├── extra
         │   │   └── httpd-cgit.conf
         │   ├── httpd.conf
         │   ├── magic -> /etc/httpd/conf/magic
         │   └── mime.types -> /etc/httpd/conf/mime.types
         ├── modules -> /etc/httpd/modules
         ├── var
         │   ├── httpd.pid
         │   └── log
         │       ├── access_log
         │       └── error_log
         └── www
             └── index.html

Then, the git bare repos have to be created in _prefix_env/cgit/repos_.

Cgit is configured to _scan-path_ and _section-from-path_. So, you
can organize bare repos in subdirs.

It's also possible to link existing git repos.

## Warning

The servers can be access by anybody connected with a shell on the host.
## Selinux

On CentOS, the default policy does not allow running cgit. I'ts necessary to
create and install a dedicated module.

First install needed package :

    yum install policycoreutils-devel

then create _cgit.te_ for default httpd server.

    cat > cgit.te <<EOF_TE
    module cgit 1.0;

    require {
            type httpd_sys_rw_content_t;
            type git_script_t;
            class dir { getattr open read search };
            class file { getattr open read };
    }

    #============= git_script_t ==============
    allow git_script_t httpd_sys_rw_content_t:dir { getattr open read search };
    allow git_script_t httpd_sys_rw_content_t:file { getattr open read };
    EOF_TE

Build the policy

    make -f /usr/share/selinux/devel/Makefile cgit.pp

Install the policy module

    semodule -i cgit.pp

If the git dir is not a default httpd dir, update fcontext

    semanage fcontext -a -t httpd_sys_rw_content_t -r s0  '/srv/git-repos(/.*)?'

## How to give user access.

... DRAFT ...

### General need
There are many options to manage user access to repos.
The general is "which _rights_ do I set for _a user_ on _each repos_"

_note:_ Sometime it could be useful to set rights on a particular branch.

* Alice and Bob can clone all repos
* Alice can push on all repos
* Bob can push on repoA and repoB

The other question is "how can i identify Alice or Bod surely".

This are common questions which have many solution more or less complex. For
examples,
* [gitolite](https://github.com/sitaramc/gitolite) use ssh key management and
  perl code hooks.
* [gitlab](https://about.gitlab.com/) great complete solution of CI (ssh,http ...)

### Ok but what about mygitserver ?

Has I said before, for this project, I'm looking for _simple native solution_.
Because actual code is based on web server, the solution can use all access
rights mechanism given by those http solutions.

And this can be easily done filtering some Git requests and setting rights with
the different identification and authentication methods ([apache
access](https://httpd.apache.org/docs/current/howto/access.html))

#### Every body can read, nobody can right using Git

This is actually the defaults configuration. The push is not allowed and failed
with "DAV error" because Git backend do not receive identity.

#### Every body can read and right (DANGEROUS) using Git

As describes in [git-http-backend](https://git-scm.com/docs/git-http-backend), push is disabled by default.
To enable the push in a specific repo, got to the repo directory and run

     git config http.receivepack true

#### Every body can read, nobody can right using Apache

The following apache configuration can be added

    <If "(%{QUERY_STRING} -strmatch '*service=git-receive-pack*' || %{REQUEST_URI} =~ m#/git-receive-pack$#)">
    # Deny push
    Require all denied
    </If>
    <Else>
    # Allow read
    Require all granted
    </Else>

A 403 http error will be returns.

#### Every body can read and right (DANGEROUS) using Apache

The following apache configuration can be added

    <If "(%{QUERY_STRING} -strmatch '*service=git-receive-pack*' || %{REQUEST_URI} =~ m#/git-receive-pack$#)">
    # Deny push
    Require all granted
    </If>
    <Else>
    # Allow read
    Require all granted
    </Else>

#### "Everyone at home and the hippos will be well looked after"  using Apache

Apache has a macro mechanism that can be used to configure each repos.

I use Apache since many years, not in an intensive way, I have built a module to
parse and modify HTML page to act has a reverseproxy ... and I just discovered
this cool one...  I love OpenSource !!

So ... a way to do the stuff is :
* loading the macro's module
* writing the macro
* setting the configuration file to use macro

The next example use basic auth.

__Loading the macro's module__

    LoadModule macro_module modules/mod_macro.so

__Writing the macro__

    <Macro Project ${repository} ${developers} ${users}>
      # The macro Project takes 3 parameters
      # - repository: the git repo
      # - developers: list of user separated by <space>
      # - users: list of users separated by <space>

      <LocationMatch "^/${repository}.*">
        # Set Basic authentication for the repo

        AuthType Digest
        AuthName "Git Access"
        AuthDigestProvider file
        AuthUserFile /some/where/apache/can/read/.htpasswd

        <If "(%{QUERY_STRING} -strmatch '*service=git-receive-pack*' || %{REQUEST_URI} =~ m#/git-receive-pack$#)">
          # Allows push for develoers
          Require user ${developers}
        </If>
        <Else>
          # Allows clone/read for every known users.
          Require user ${developers} ${users}
        </Else>

     </LocationMatch>
    </Macro>

    # Include config file to déclare all needed repos.
    IncludeOptional /some/where/apache/can/read/git_access.conf

__Setting the configuration file to use macro__

The config file is a Apache conf containg the macro call for each repository.

    $ cat /some/where/apache/can/read/git_access.conf
    Use Project mygitserver.git "admin puppetupdate" "fccagou"
    Use Project tests "puppetupdate fccagou" ""

__Basic auth passwd file__

A standard basic file created using _htdigest_ command line

    $ htdigest /some/where/apache/can/read/.htpasswd "Git Access" fccagou
    $ htdigest /some/where/apache/can/read/.htpasswd "Git Access" puppetupdate

    $ cat /some/where/apache/can/read/.htpasswd
    fccagou:Git Access:xxxxxxx
    puppetupdate:Git Access:yyyyyyyyy

### Next ...

Hum ... go go go ... code to be alive !

### Links

* [MIT](http://web.mit.edu/git/git-doc/howto/setup-git-server-over-http.html)
* [SSL](https://stackoverflow.com/questions/11621768/how-can-i-make-git-accept-a-self-signed-certificate)
* [PI/lighttp](https://dhole.github.io/post/raspberry_pi_git/)
* [LINUXCOM](https://www.linux.com/tutorials/give-your-git-repository-open-source-web-interface/)

## TODO
* Allow user defined logo.
* Add -v/--verbose parameter.
* Add httpd server param to manage configuration (apache/nginx/ligthttp...)
* Certainly many others good features.
* Add scripts to manage git bare repos
* Add ssl support
* Add kerberos/ldap support
* Install required distro packages
* Put each feature in a separate script
* Use getops. Not necessary yet.
* Add current usercheck to use or not sudo.
* Configure systemd for all users
* make a [puppet/bolt](https://puppet.com/docs/bolt/latest/bolt.html) project.

repository: fccagou/mygitserver

repo_name: fccagou/mygitserver


text:
---
title: Getting Started
page_title: Getting Started
description: Getting Started
slug: radspreadstreamprocessing-getting-started
tags: getting started
published: True
position: 2
---

# Getting Started

This article will get you started in using the **RadSpreadStreamProcessing** library. It contains the following sections:

* [Assembly References](#assembly-references)

* [Supported Formats](#supported-formats)

* [Create a Spreadsheet Document](#create-a-spreadsheet-document)

## Assembly References

In order to use RadSpreadStreamProcessing in your project, you will need to add a reference to:

* **Telerik.Documents.SpreadsheetStreaming**

## Create a Spreadsheet Document

This section will explain how a document could be created. If you need more detailed information about the classes that export the different document elements, you can check the articles from the [Model section]({%slug radspreadstreamprocessing-model-workbook%}).

When creating a document with **RadSpreadStremProcessing**, you should have in mind that the order of filling the content is much important. To achieve the low resources usage, the library directly writes the necessary content in a stream and due to the format restrictions of the way the content is presented in the structure of the file, you have to create the desired elements in a sequence keeping the following consecution:

1. Create a Workbook

2. Create a Worksheet

3. Create Columns (optional)

4. Create Rows (a worksheet must contain at least one row)

5. Create Cells (optional)

6. Merge Cells (optional)

**Example 2** shows how you could create a simple document.

#### **Example 1: Create a document**

{{region radspreadstreamprocessing-getting-started_0}}
	using (FileStream stream = File.OpenWrite("sample.xlsx"))
	{
	    using (IWorkbookExporter workbook = SpreadExporter.CreateWorkbookExporter(SpreadDocumentFormat.Xlsx, stream))
	    {
	        using (IWorksheetExporter worksheet = workbook.CreateWorksheetExporter("My sheet"))
	        {
	            worksheet.SkipColumns(1);
	            using (IColumnExporter column = worksheet.CreateColumnExporter())
	            {
	                column.SetWidthInPixels(80);
	            }

	            worksheet.SkipRows(3);
	            using (IRowExporter row = worksheet.CreateRowExporter())
	            {
	                row.SkipCells(3);
	                using (ICellExporter cell = row.CreateCellExporter())
	                {
	                    cell.SetValue("Merged cell.");
	                    cell.SetFormat(new SpreadCellFormat()
	                    {
	                        HorizontalAlignment = SpreadHorizontalAlignment.Center,
	                        VerticalAlignment = SpreadVerticalAlignment.Center
	                    });
	                }
	            }

	            using (IRowExporter row = worksheet.CreateRowExporter())
	            {
	                row.SetHeightInPixels(200);
	                using (ICellExporter cell = row.CreateCellExporter())
	                {
	                    cell.SetValue(123.456);
	                }

	                using (ICellExporter cell = row.CreateCellExporter())
	                {
	                    SpreadCellFormat format = new SpreadCellFormat()
	                    {
	                        NumberFormat = "dd/mm/yyyy",
	                        IsBold = true
	                    };
	                    cell.SetFormat(format);
	                    cell.SetValue(42370);
	                }
	            }

	            worksheet.MergeCells(3, 3, 6, 6);
	        }
	    }
	}
{{endregion}}

**Figure 1** shows the result of executing the code from **Example 1**.

#### Figure 1: The document created in Example 2
![](images/SpreadStreamProcessing-GettingStarted_01.png)

# See Also
* [Rows]({%slug radspreadstreamprocessing-model-rows%})
* [Columns]({%slug radspreadstreamprocessing-model-columns%})
* [Cells]({%slug radspreadstreamprocessing-model-cells%})
* [Worksheets]({%slug radspreadstreamprocessing-model-worksheet%})
* [Workbook]({%slug radspreadstreamprocessing-model-workbook%})


text:
When using the [namoona](https://github.com/chimefrb/namoona) template it will automatically setup
the following components for your backend.

## Project Layout

    <repository>                # Project Root
    ├── <package_name>          # Python Package Root
        ├── analysis/           # Location for low-level analysis code, e.g. functions
        ├── backend/            # Maestro Configuration File + Example API
        ├── pipelines/          # Analysis Pipelines, generally collection of routines.
        ├── routines/           # Analysis routines, generally collection of analysis functions.
        ├── utilities/          # Common code utilities
        docs                    # Technical Documentation
        tests                   # Tests

        .github/workflows       # Continous Integration Config
        .pre-commit-config.yml  # Configuration for pre-commit
        .gitignore              # Git configuration

        pyproject.toml          # The python package management
        poetry.lock             # Lock file for python packages
        mkdocs.yml              # Configuration for generating docs
        LICENCE                 # Project Licence
        README.md               # README for the project

## Project Components
When setting up a project with `namoona` the following components come pre-configured:

  - *Project Layout* with ideal module setup
  - *Backend Configuration* file for `maestro`
  - *Continous Integration* setup via Github Actions
  - *Pre-Commit* configuration hooks for:
    - Code Formatting
    - Documentation Style
    - Python Type Hinting
    - Checks for `yaml`, `json` & `toml` files
  - *Documentation* setup via [mkdocs-material](https://squidfunk.github.io/mkdocs-material/getting-started/)
  - *Testing* setup through [pytest](https://docs.pytest.org/en/stable/)

repository: CHIMEFRB/namoona

repo_name: CHIMEFRB/namoona


text:
Aquaduino
=========

Programable arduino Aquarium controler for RGB-led strips

I made this for use with my tropical aquarium to drive multible led strips with shiftregisters (3x 74HC595 )
So I can drive 3x8 = 24 (led) channels on my aquarium!

You can find smart things in this sketch like:

* Controle the settings by IR remote
* use of ShiftPWM libary to easy set the shiftregisters (by Eelco Jacobs: http://www.elcojacobs.com)
* Programing the time table to make a sunrise and sunset with color and intensity shifts.
* Optional Moonphase function
* Realtime Clock setup
* Shiftbalancing for the reqisters

please visit www.bluemotica.nl for some blogs about this.

license: Unlicense


text:
1) Generate a random key for encrypting challenges when server starts (that means all challenges are reset when server restarts. I guess that's ok.)
2) `/auth/challenge` Generate challenge from user address:
    - Concat address + timestamp + sig(address + timestamp, key)
    - Send challenge
3) User signs challenge with wallet private key
4) `/auth/token` User sends challenge + signed challenge (`web3.eth.accounts.sign`)
    - Verify challenge
      - check whether challenge signature is correct (concat again, use equality check)
      - Check whether challenge expiry date is met
      - Check whether wallet signature is correct (`web3.eth.accounts.recover`)
      - Check whether challenge address matches the recovered address
    - Issue JWT token
      - Use RS256
      - Payload
      - TTL, etc

repository: JoinColony/etherpass

repo_name: JoinColony/etherpass


text:
# nstextstorage-based output

NSTextAttachment(Cell) is very different between platforms. On iOS, we use a subclass. On the mac, we have to use the base class with a file wrapper.

For images, this file wrapper contains a serialized dictionary with "id" and "url" keys and a filename of "image{id}".

For files, this file wrapper contains a serialized dictionary with "id", "name". and "ext" keys and a filename of "file{id}".

root controller has 4 child controllers -- welcome, messages, workspaces, grading.
It has API to switch between them. The child controllers will call that api to switch
between different views (from toolbar buttons).

recent changes

Double tap opens session with specified document selected
Login error messages now provide more details
LDAP authentication supported

# variable display

when receiving delta updates, a variable that was rm()'d isn't removed from the list. If a value was removed, we need to include
info to delete it from client display

need to clear updateUpdated anytime results are received (value no longer unchanged)

# Rc2 iOS App #

0x2328 - keyboard key
0x21e7 - shift

## Lifecycle Notes ##

Need to record state information when put in the background so can use it on restore.

* if logged in and if so with what userid
* time of last network activity
* which session was open

on restore, need to check

* if was open but now closed, attempt a reconnect showing progress dialog
* if reconnect fails or wasn't open, freeze UI with buttons to exit session and reconnect

currentSessionWspaceId pref is saved when a session is open and the app goes to the background. this allows the app to restore the open session if it was quit while in the background

## Sweave ##

* Install mactex
* Edit .bash_profile so PATH includes /usr/texbin
* mkdir -p ~/Library/texmf/tex/latex
* cd ~/Library/texmf/tex/latex
* ln -s /Library/Frameworks/R.framework/Resources/share/texmf/tex/latex/Sweave.sty Sweave.sty

To execute, we need the full text sent to the server. We should show "executing sweave" in the output area while waiting on pdf.

## Major Tasks ##

* Sweave
* Admin installing R packages
* clustering R servers
* sass
* Enforce permissions when shared
* session user list, passing control around
* background processing with notifications
* workspace variable lists

## To Do ##

* report errors back to users (R code)
* when restoring and returning from a session, the current workspace is unselected
* execute on symbol keyboard
* need to prune image cache for images not refrerenced in any saved workspace. maybe an idle block if been running for x minutes?
* need to cancel any outstanding requests on close session. if one is pending, causes crash.
* not crazy about timestamp location in image display

## Audio Chat ##

Siphon could work, but it fuckin GPL. So that heans any ios app using it has to be GPL.
http://code.google.com/p/siphon/

Team speak seems interesting, and afforable for edu. no ios sdk listed, but the "may have outhers available" and they've got an app working on iOS that uses their technolog.
http://sales.teamspeakusa.com/

Twilio has an sdk for chat and sms. fees are per minute. $0.0025/minute for ip chat. $.01/min for phone chat.

license: ISC


text:
# Database-reporting
Database-reporting is a set of queries to a newspaper database that helps discover what kind of articles the site's readers like. The database contains newspaper articles, as well as the web server log for the site. The log has a database row for each time a reader loaded a web page.
## Preparation / installation
To start on this project, you'll need database software (provided by a Linux virtual machine) and the data to analyze. For help, follow this [link](https://classroom.udacity.com/nanodegrees/nd004/parts/4dcefa2a-fb54-4909-9708-9ef2839e5340/modules/5dbcf44d-760d-49d4-9055-b6a0a48e5454/lessons/3967218625/concepts/39636486110923) (you might need to pay for the course)

###Requirements
-Git: If you don't already have Git installed, download Git from [this link](git-scm.com). Install the version for your operating system.
On Windows, Git will provide you with a Unix-style terminal and shell (Git Bash). (On Mac or Linux systems you can use the regular terminal program.)
-Virtual Box:VirtualBox is the software that actually runs the VM. You can download it from [here](virtualbox.org). Install the platform package for your operating system. You do not need the extension pack or the SDK. You do not need to launch VirtualBox after installing it.
Ubuntu 14.04 Note: If you are running Ubuntu 14.04, install VirtualBox using the Ubuntu Software Center, not the virtualbox.org web site. Due to a reported bug, installing VirtualBox from the site may uninstall other software you need.
-Vagrant: Vagrant is the software that configures the VM and lets you share files between your host computer and the VM's filesystem. You can download it from [here](vagrantup.com). Install the version for your operating system.
Windows Note: The Installer may ask you to grant network permissions to Vagrant or make a firewall exception. Be sure to allow this.

### The virtual machine
This project makes use of a Linux-based virtual machine (VM)

This will give you the PostgreSQL database and support software needed to run the code. If you have used an older version of this VM, you may need to install it into a new directory.

To bring the virtual machine online, use `vagrant up`. Then log into it with `vagrant ssh`.

### Download the data
Next, download the data [here](https://d17h27t6h515a5.cloudfront.net/topher/2016/August/57b5f748_newsdata/newsdata.zip). You will need to unzip this file after downloading it. The file inside is called newsdata.sql. Put this file into the vagrant directory, which is shared with your virtual machine.

To build the reporting tool, you'll need to load the site's data into your local database.

To load the data, cd into the vagrant directory and use the command `psql -d news -f newsdata.sql`.
Here's what this command does:

`psql` — the PostgreSQL command line program
`-d news` — connect to the database named news which has been set up for you
`-f newsdata.sql` — run the SQL statements in the file newsdata.sql
Running this command will connect to your installed database server and execute the SQL commands in the downloaded file, creating tables and populating them with data.

Getting an error?
If this command gives an error message, such as —
psql: FATAL: database "news" does not exist
psql: could not connect to server: Connection refused
— this means the database server is not running or is not set up correctly. This can happen if you have an older version of the VM configuration from before this project was added. To continue, download the virtual machine configuration into a fresh new directory and start it from there.

The database includes three tables:

The authors table includes information about the authors of articles.
The articles table includes the articles themselves.
The log table includes one entry for each time a user has accessed the site.
As you explore the data, you may find it useful to take notes! Don't try to memorize all the columns. Instead, write down a description of the column names and what kind of values are found in those columns.

Connecting from your code
The database that you're working with in this project is running PostgreSQL. So in your code, you'll want to use the psycopg2 Python module to connect to it, for instance:

`db = psycopg2.connect("dbname=news")`

This might need previous installation:

`sudo pip3 install psycog2`

## Usage
The queries for analyzing the data are contained in the file [queries](create_views.sql). This file is automatically imported and executed when you run reporting_tool.py
#### Views recreation
##### First query: question1
###### Purpose:
This query answers the following question:
- What are the most popular three articles of all time?
- Which articles have been accessed the most?
###### Resulting table:
The resulting table will include the title of the top articles (text) and the number of views it has (integer)
##### Second query: question2
###### Purpose:
This query informs the user about:
- Who are the most popular article authors of all time? That is, when you sum up all of the articles each author has written, which authors get the most page views?
###### Resulting table:
The resulting table will include the name of the author (text) and the number of times it was searched (integer)
##### Third query: question3
###### Purpose:
This query informs the user about:
- On which days did more than 1% of requests lead to errors?
###### Resulting table:
The resulting table will include the date (date) and the percentage of errors (float)
#### Running the code
Once the virtual machine is on, the dependencies are downloaded, and the views are recreated, run `python3 reporting_tool.py` to execute the queries and data will be delivered as text.
## License
MIT License

Copyright (c) 2018 Bernardo Suárez Sepúlveda

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.

repository: bersuarez/Database-reporting

repo_name: bersuarez/Database-reporting


text:
^title Development blogs

[
0.3.0 released!
](2-0.3.0-released.html)
> <date>5 June 2020</date> • 0.3.0 release info! Plus some notes and goals for the next release, 0.4.0.

[
0.2.0 and beyond
](1-0.2.0-and-beyond.html)
> <date>30 Sep 2019</date> • Checkpoints, and the plans for 0.3.0.

[
System.print("hello wren")
](0-hello-wren.html)
> <date>4 Feb 2019</date> • A short post introducing the blog, the new maintainer, and the immediate term plans for Wren.

extension: markdown

gha_language: C


text:
---
layout: post
title:  "Fix Unexpected end of ZLIB input stream using Apache POI"
date:   2019-1-11 16:53:00 +0800
description: Fix Unexpected end of ZLIB input stream using Apache POI
image: /assets/2019-1-11-apache-poi-unexpected-end-of-zlib-input-stream-exception/banner.jpg
categories:
    - code
tags:
    - apache poi
---

Pretty sure the problem is you overwriting the file. Try to save on a different path. If you still want to overwrite the file, save to something else, delete the original, then rename the file you wrote into place:

```java
    String tempFilename = createTempFile(template);
    String outputFilename = StringUtils.removeEndIgnoreCase(tempFilename, ".temp");
    FileUtils.forceDelete(new File(outputFilename));
    System.out.println(outputFilename);
    try (
            XWPFDocument document = new XWPFDocument(OPCPackage.open(tempFilename));
            OutputStream outputStream = FileUtils.openOutputStream(new File(outputFilename))
    ) {
        replaceInParagraphs(document);
        replaceInTables(document);
        document.write(outputStream);
        filenames.add(outputFilename);
    }
    FileUtils.forceDelete(new File(tempFilename));
```

A similar issue in Stackoverflow:[https://stackoverflow.com/questions/52389798/java-io-eofexception-unexpected-end-of-zlib-input-stream-using-apache-poi](https://stackoverflow.com/questions/52389798/java-io-eofexception-unexpected-end-of-zlib-input-stream-using-apache-poi
)


text:
![React Native Web](/app/assets/react-native-web.png "Logo React Native Web")

# React Native for Web Starter

React Native for Web Starter aims at:
- Providing the leanest code base to bootstrap a React Native for Web project.
- Following the standard React Native project structure close so someone becoming familiar with React Native may quickly find its way in a RN4Web project, and vice-versa.
- Benefit from the React community dev-tools, such as Storybook.

## Presentation
You can find a presentation of React Native for Web and this starter here.
[![React Native for Web Starter](https://img.youtube.com/vi/eV4pZ6vv1VE/0.jpg)](https://www.youtube.com/watch?v=eV4pZ6vv1VE)

## Getting *quickly* started

As of today, React Native for Web, let's call it RN4Web, is still pretty recent, and could use some more documentations, along with contributions.

This repo is an attempt to make it easier for anyone to launch, experiment and publish a RN4Web App.

### Install
```
git clone https://github.com/grabcode/react-native-web-starter.git projectname
cd projectname
rm -rf .git
npm install
```

### Run
`npm run dev` - your app is accessible at `http://localhost:3000`

You can also enjoy [React Storybook](https://github.com/kadirahq/react-storybook) running `npm run storybook` and open `http://localhost:9001`

### Build
TODO

## Tools

React Native for Web runs in the browser, hence get out of the box full dev tools supports.

In the future, RN4Web Starter may come with some flavour such as Redux and its amazing [tool suite](https://github.com/gaearon/redux-devtools).

## About React Native for Web

[React Native for Web](https://github.com/necolas/react-native-web) is born from the brilliant mind of a member of the React Native community. Some would say it had to happen, many reasons begging for such project to get started.

React Native tends to unify iOS and Android, and soon Universal Windows developer under one banner, sort of the Wardens of the Native.

Well, following that GoT analogy, React Native for Web is the Wardens of the Web, unifying any React developer under a common set of values.

## License

React Native for Web Starter is [BSD licensed](LICENSE).

repository: tradle/rn-markdown-playground

repo_name: tradle/rn-markdown-playground


text:
Quick-Know
==========
QK is a High Available push server cluster

## Features
 * Support push private message
 * Support subscription message group
 * Support a key multi subscription
 * Failover support (Etcd)

## What can qk help you ?
 * quick to set a push system to the mobile phone or destop
 * quick to set a IM systerm

## Document
 [中文文档](https://github.com/Alienero/quick-know/blob/master/Documentation/qk.md)

## Contact me
 http:// yim.so


text:
# Setup

```
dependencies {
    implementation "com.github.skgmn:viewmodelevent:1.1.0"
}
```
If you don't know how to access to GitHub Packges, please refer to [this](https://gist.github.com/skgmn/79da4a935e904078491e932bd5b327c7).

# Usage

## Basic Usage of Event

```kotlin
class MyViewModel : ViewModel() {
    val myEvent = publicEvent<MyEvent>()

    fun hello() {
        myEvent.post(MyEvent())
    }
}

class MyActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by viewModels()

    fun onCreate(savedInstanceState: Bundle?) {
        handle(viewModel.myEvent) { doSomeWorkWith(it) }
    }
}
```
If you want to inhibit other than MyViewModel from posting events, then create private `Delivery` and post events through it.
```kotlin
class MyViewModel : ViewModel() {
    private val myEventDelivery = delivery<MyEvent>()
    val myEvent = event(myEventDelivery)

    private val yourEventDelivery = delivery<YourEvent>()
    val yourEvent = event(yourEventDelivery)

    fun hello() {
        myEventDelivery.post(MyEvent())
        yourEventDelivery.post(YourEvent())
    }
}

class MyActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by viewModels()

    fun onCreate(savedInstanceState: Bundle?) {
        handle(viewModel.myEvent) { doSomeWorkWith(it) }
        handle(viewModel.yourEvent) { doOtherThingsWith(it) }
    }
}
```
If you are free to make your ViewModel inherit other classes, make it extend `com.github.skgmn.viewmodelevent.ViewModel` rather than `androidx.lifecycle.ViewModel`. It becomes even easier.
```kotlin
class MyViewModel : com.github.skgmn.viewmodelevent.ViewModel() {
    val myEvent = event<MyEvent>()

    fun hello() {
        // this post() is invisible to the outside of MyViewModel
        myEvent.post(MyEvent())
    }
}
```

## Event Lifecycle

### Event delivery occurs only between onStart() and onStop()

The lambda function passed to `handle()` is only invoked when its Activity or Fragment is between onStart() and onStop().

### Events are buffered after onStop()

Events posted after onStop() are buffered until the Activity or Fragment retarts. Only the latest item is buffered if `DeliveryMode.LATEST` is passed to `handle()`(this is the default behavior). Otherwise, all items are buffered if `DeliveryMode.ALL` is passed to `handle()`.

### Events live across Activity recreation

Events posted while Activity recreation can be delivered after it is recreated.

## Multiple handling

An Activity or Fragment can handle multiple events, but cannot handle the same event multiple times. Only the latest handler will work then.
It is OK that several Activities or Fragments handle the same event at the same time. It can be useful when some ViewModels are shared by many Activities or Fragments.

## Survey

A `Survey` is a concept similar to `Event`, but it can reply to its sender.

```kotlin
class MyViewModel : ViewModel() {
    val mySurvey = survey<MyQuestion>()

    fun hello() {
        viewModelScope.launch {
            mySurvey.ask(MyQuestion()).collect { myAnswer ->
                doSomethingWith(myAnswer)
            }
        }
    }
}

class MyActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by viewModels()

    fun onCreate(savedInstanceState: Bundle?) {
        answer(viewModel.mySurvey) { question ->
            MyAnswerTo(question)
        }
    }
}
```

Event         | Survey
--------------|---------------
publicEvent() | publicSurvey()
delivery()    | poll()
event()       | survey()
post()        | ask()
handle()      | answer()

Unlike `Event`, `Survey` use coroutine.
`Survey.ask()` returns `Flow`, and `Survey.answer()` accepts `suspend` lambda function.
`Survey` also has same lifecycle as `Event`.

# License

```
MIT License

Copyright (c) 2021 skgmn

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.
```

repository: skgmn/ViewModelEvent

repo_name: skgmn/ViewModelEvent


text:
---
layout: post
title: Building Sortable lists with scalajs-react
tags: [react-sortable-hoc, react, scalajs]
gh-repo: dborisenko/scalajs-react-components
gh-badge: [star, fork, follow]
---

React Sortable (HOC) is a set of higher-order components to turn any list into an animated, touch-friendly, sortable list. It is possible to use it with Scala. Here I will provide short instructions how to do that.

## Dependencies

The code is based one the [react-sortable-hoc wrapper](https://github.com/dborisenko/scalajs-react-components#react-sortable-hoc) for [React Sortable (HOC)](https://github.com/clauderic/react-sortable-hoc) component. It is written using [scalajs-react](https://github.com/japgolly/scalajs-react) library for ScalaJs.

Add dependencies in `build.sbt`:

```scala
libraryDependencies ++= Seq(
  "com.dbrsn.scalajs.react.components" %%% "react-sortable-hoc" % "0.3.1"
)
npmDependencies in Compile ++= Seq(
  "react-sortable-hoc" -> "1.4.0",
  "react" -> "16.7.0",
  "react-dom" -> "16.7.0"
)
```

## Usage

Example of usage:

```scala
case class Model(text: String)
case class Props(model: Model)

val item1 = "Test 1"
val item2 = "Test 2"

SortableList[Model, Props].Props(
  listToDisplay = List(Model(item1), Model(item2)),
  sortableContainerProps = SortableContainer.Props(),
  externalProps = Props,
  itemComponent = raw
).render
```

## Source Code

Source code can be found [here](https://github.com/dborisenko/scalajs-react-components)

gha_language: HTML


text:
# Galaxy Docker example deployment

If you are running Docker on OSX (Mac), first see the [related subheading below](#osx-peculiarities).
Ensure docker can be [run without root privileges](https://docs.docker.com/engine/install/linux-postinstall/).
Change the current working directory to `/deployment/docker` (the path containing this read-me). Modify `./changeme.auto.tfvars` with any custom values you like.
You must at least set the `docker_gid` variable to a group id with write access to `/var/run/docker.sock`.
Run `stat /var/run/docker.sock` (or `stat -x /var/run/docker.sock` on OSX) to show the owning group id.

Run the following to start an instance on your local computer using docker:
```shell script
terraform init
./deploy.sh
```

Browse to http://localhost:8000/ to access the deployment.

To shut down this instance, run `./destroy.sh`. This will delete the instance, all of its data, and the container images.

## OSX Peculiarities

OSX does not natively support Docker, it runs Docker within a Linux virtual machine. This workaround means that support is limited to only the most
basic use case. The following needs to be added to `changeme.auto.tfvars`:

```hcl
docker_gid = 0
docker_socket_path = "/run/host-services/docker.proxy.sock"
```

The last modification you need to make is to allow group write access to the docker socket within containers.
See https://github.com/docker/for-mac/issues/3431 for more information about the issue.

Appropriate resources [must be allocated](https://stackoverflow.com/a/50770267/15446750) to the Docker VM or OSX will randomly kill the application and tools during an analysis.
A minimum of 8GB of RAM and 16GB of swap space is required. It is recommended to provide as much swap space as possible to avoid out of memory issues.

## Providers

No providers.

## Modules

| Name | Source | Version |
|------|--------|---------|
|  [admin\_user](#module\_admin\_user) | ../../modules/bootstrap_admin | n/a |
|  [galaxy](#module\_galaxy) | ../../destinations/docker | n/a |

## Inputs

| Name | Description | Type | Default | Required |
|------|-------------|------|---------|:--------:|
|  [debug](#input\_debug) | Enabling will put the deployment into a mode suitable for debugging | `bool` | n/a | yes |
|  [docker\_gid](#input\_docker\_gid) | GID with write permission to /var/run/docker.sock | `number` | n/a | yes |
|  [docker\_socket\_path](#input\_docker\_socket\_path) | Host path to docker socket | `string` | `"/var/run/docker.sock"` | no |
|  [email](#input\_email) | Email address to send automated emails from | `string` | n/a | yes |
|  [host\_port](#input\_host\_port) | Host port to expose galaxy service | `number` | n/a | yes |
|  [instance](#input\_instance) | Unique deployment instance identifier | `string` | n/a | yes |
|  [microbedb\_mount\_path](#input\_microbedb\_mount\_path) | Path on host to mount microbedb to share with jobs | `string` | `"./microbedb/mount"` | no |
|  [worker\_replicas](#input\_worker\_replicas) | Number of worker replicas | `number` | `1` | no |

## Outputs

| Name | Description |
|------|-------------|
|  [galaxy\_admin\_api\_key](#output\_galaxy\_admin\_api\_key) | Galaxy admin api key |
|  [galaxy\_admin\_password](#output\_galaxy\_admin\_password) | Galaxy admin password |
|  [galaxy\_admin\_username](#output\_galaxy\_admin\_username) | Galaxy admin username |
|  [galaxy\_endpoint](#output\_galaxy\_endpoint) | Galaxy front-end endpoint |
|  [galaxy\_master\_api\_key](#output\_galaxy\_master\_api\_key) | Galaxy master api key |

## Resources

No resources.

repository: brinkmanlab/galaxy-container

repo_name: brinkmanlab/galaxy-container


text:
# Project Layout

- `ansible`: Various files used to create the Vagrant virtual machine
- `apps`: Project-specific Django applications.
    - `api`: The project's API, using Django REST framework
    - `daily_content`: Renders the scheduled daily content. The content is schduled in the admin via django-events.
    - `cmsplugins`: This is where all the plugins for Django-CMS live.
    - `open_html`: The Django app that handles the "Open HTML" content type. Should be extracted into an external package/Django app.
    - `redeem`: This code allows a user to enter a redeem code which triggers an arbitrary action on the backend, such as sign the user up for a subscription to a magazine.
    - `redirects`: Custom URL redirection.
    - `search`:  The app that handles the site indexing and searching.
    - `site_ext`: Various extra glue code to implement various tasks and functions for the site.
    - `utils`: Various utilities used by legacy code.
    - `uuid_nk`: Allows the addition of an automatic UUID field on models that don't normally have them.
    - `widgets`: HTML form widgets for the site admin.
    - `sitemaps.py`: The site's sitemap implementation.
- `bin`: This directory contains useful scripts for developers.
- `bower_components`: `bower` installs its components into this directory.
- `conf`: Various server configurations.
- `deploy`: Contains the configurations and scripts for deploying the project
    - `prod`: The ECS configuration for Production deployments
    - `staging`: The ECS configuration for Staging deployments
- `docs`: Documentation. Built with `npm run-script build` or served with `npm run-script serve`
    - `book.json`: The GitBook configuration
    - `dist`: The built HTML documentation
    - `src`: The documentation source. Uses GitBook conventions for Markdown.
- `locale`: Compiled language translations.
- `node_modules`: This is where `node.js` stores its installed modules.
- `scripts`: Various Python or bash scripts that need to be run on the production server. This is typically done during very large or complex migrations, or to automate a one-time process that is cumbersome for producers.
- `settings`: Django settings.
    - `base.py`: Most of the settings go into this file. Other settings files will import this file and override the settings as appropriate.
    - `local_settings.py.template`: Default developer and development settings. This file should be copied to `local_settings.py` when first setting up development. You can customize `local_settings.py`, as it is ignored by `git`.
    - `production.py`: Settings for production servers.
    - `test.py.template`: A template used when creating a test server instance to create `test.py`, the settings used on the test instance.
    - `vagrant.py`: Settings when using Vagrant.
- `sites`: Customized versions of the primary site. These "micro-sites" run off the same code, but have their own database and server configurations. They override some of the default templates to allow the site to have its own look and feel.
- `static`: Static CSS, JavaScript and images used in the site.
- `templates`: The templates used in the site. See the template documentation for more information.
- `urlpatterns`: Complex URL patterns imported into `urls.py`, grouped by application. Just to make the `urls.py` file a bit smaller and easier to read.
- `.editorconfig`: [EditorConfig](http://editorconfig.org/) helps developers define and maintain consistent coding styles between different editors and IDEs.
- `.gitattributes`: Automatically sets attributes in `git` based on paths.
- `.gitignore`: Files and file name patterns to ignore when adding files to the `git` repo.
- `bootstrap.py`: This script is used when deploying to set up its isolated Python environment and install its requirements.
- `bower.json`: The packages and their versions that `bower` should install and maintain. `bower` installs them in `bower_components`.
- `fabfile.py`: The scripts and tasks we use to perform tasks on remote servers, using the [Fabric](http://www.fabfile.org/) library.
- `Gruntfile.js`: The definition of tasks used to manage the various NGKit, `bower`-installed pacakges and other front-end tasks.
- `manage.py`: The default command entry-point for Django.
- `package.json`: The `npm` configuration for the various packages and their versions that `npm` will install into `node_modules`.
- `requirements.txt`: The Python packages and their versions that are necessary for the project to run.
- `setup.cfg`: This provides defaults for Python-specific linting of code.
- `start_gunicorn.sh`: A script used to start the gUnicorn WSGI server on a production or test server.
- `start_rqscheduler.sh`: A script used to start the RQ Scheduler service on a production or test server.
- `start_rqworker.sh`: A script used to start the RQ worker service on a production or test server.
- `urls.py`: The primary Django URL configuration.
- `Vagrantfile`: The configuration for running the project within Vagrant.

repository: coordt/developerdocs

repo_name: coordt/developerdocs


text:
# USE CASE: 6 - Allow a user to rebalance alert setting.

## CHARACTERISTIC INFORMATION

### Goal in Context

As a *user* I will be able to edit the rebalance alert setting to be able to customise my portfolio rigorously.

### Level

Primary task.

### Preconditions

App contains current portfolio settings and a current alert setting value.

### Success End Condition

User has updated their rebalance alert setting.

### Failed End Condition

Rebalance alert setting not updated.

### Primary Actor

User.

### Trigger

User presses the update portfolio button after entering new alert value.

## MAIN SUCCESS SCENARIO

1. User updates alert setting.
2. Alert settings has to be between 5-30 pounds.
3. User presses update button and changes saved.

## EXTENSIONS

2. **When a user enters amount not between the range, the portfolio still accepts it**:
    1. User emails developers that there is a bug
3. **When update button is pressed the change is not succefully saved**:
    1. User emails developers that there is a bug

## SUB-VARIATIONS

None.

## SCHEDULE

**DUE DATE**: Release 1.0

repository: benhasselgren/portfolio-balancer

repo_name: benhasselgren/portfolio-balancer


text:
---
title: The Advisory Committee on Submerged
tags:
  - Nov 1968
---

The Advisory Committee on Submerged Land suggests making Biscayne Bay south of Cape Florida a preserve. [Photo of Stiltsville.]

Newspapers: **Miami Morning News or The Miami Herald**

Page: **1**, Section: **B**


text:
# Screencast Workflow

There's a more general [write-up about video recording of virtual conference talks and poster presentations here](https://willirath.github.io/blog/posts/2020-03-07-how-to-create-and-publish-videos-of-conference-contributions).

## Automated workflow on MacOSX

_This will set up an automated workflow that takes all files found in `Desktop/screen_recordings_raw/`, converts and compresses them, and puts them into `Desktop/screen_recordings_raw/`._

### Preparations _(only necessary once)_

Download [this file](https://raw.githubusercontent.com/willirath/screencast_workflow/master/scripts/mac_compress_screen_recordings.command) to your Desktop and make it executable.

To make the `mac_compress_screen_recordings.command` executable, open a Terminal (hit `Command(⌘)-Space` and type `terminal`) and run `chmod 755 ${HOME}/Desktop/mac_compress_screen_recordings.command`.

To set up the environment and run a test, execute `mac_compress_screen_recordings.command` by, e.g., double-clicking it or by chosing (secondary click) `open with -> Terminal`.
This will ensure
- there's a directory `Desktop/screen_recordings_compressed/` for the converted movies,
- there's a directory `Desktop/screen_recordings_raw/` for the original recordings, and that
- `ffmpeg` is available.

### Recording and compression

Use the screenshot tool (`Shift-Command(⌘)-5`) to record a video of your screen.
(See the [Apple support page](https://support.apple.com/en-us/HT208721) for details.)
Place the resulting video file in `screen_recordings_raw/` on your Desktop.

Then, execute the `mac_compress_screen_recordings.command`. (See above for how to do this.)
This will use `ffmpeg` to create a lower quality (but still great for online teaching) version of all `mov` files in `Desktop/screen_recordings_raw/` and place them in `Desktop/screen_recordings_compressed/`.

## What's happening under the hood?

The essentials are
```shell
ffmpeg -i "${original_file}" -vf fps=fps=15 -c:v libx264 -crf 28 "${target_file}"
```
with
- `-vf fps=fps=15` for reducing time resolution to 15 frames per second,
- `-c:v libx264` for selecting the codec,
- `-crf 28` for applying a constant rate factor (0 = very good, 51 = terrible), and
- `"${target_file}"` that should be named `...mp4` to make sure it plays in a web browser.

gha_language: Shell


text:
---
title: Pi Day
excerpt: March 14 (3.14) alternative is 22 July (22/7)
categories: iot
description: 3.14
image: https://pbs.twimg.com/media/C64yUhsWkAA5yA6.jpg
---
![get real and rational pi day](https://www.indstate.edu/cas/sites/arts.indstate.edu/files/Mathematics%20and%20Computer%20Science/get%20real.jpg)

[https://en.m.wikipedia.org/wiki/Pi_Day](https://en.m.wikipedia.org/wiki/Pi_Day)

![pi day](https://ashdown.mit.edu/photos/20130314CoffeeHour6thAnnualPiDay/6th_annual_pi_day_07.jpg)


text:
TeamCityZen
===========

##Purpose
TeamCity is much more than just a Continuous Integration server. It is the central communication point of software development organization. Using this plugin you can add communication and sozializing capabilities to your existing TeamCity server.

##How to use
1. Dowload [TeamCityZen.zip](http://teamcity.codebetter.com/repository/download/TeamCityZen_TeamCityZenMaster/.lastSuccessful/TeamCityZen.zip) and extract on the TeamCity agent, for example: C:\Tools\TeamCityZen
2. Configure TeamCity and SMTP details in TeamCityZen.exe.config
3. Add command line step in build configuration with command C:\Tools\TeamCityZen\TeamCityZen.exe /buildId %teamcity.build.id%
4. Use @UserName in comments to notify somebody about your checkin/commit

##Future plans:
1. Add @groupName support to notify group about checkin/commit
2. Port to Java as TeamCity plugin
3. Display link from TeamCity UI to user's profile page
4. Support emoticons in comments and display them on TeamCity UI

##Continuous Integration:
Last build status is:
![ci](http://teamcity.codebetter.com/app/rest/builds/buildType:(id:TeamCityZen_TeamCityZenMaster)/statusIcon "ci")

![alt text](http://www.jetbrains.com/img/banners/Codebetter300x250.png "continuous integration server")

##Author
Boris Modylevsky (@bormod)

##License
Apache 2.0

repository: borismod/TeamCityZen

repo_name: borismod/TeamCityZen