text:
# Lesson 2

This directory contains all of the files related to lesson #2. My lesson plan
(2_plan.md) and the file we created together in class (2.py) are found here. I
have also created a review of what we talked about in class that should be
easier to read. You can review the homework by accessing the homework directory.

## Outline

### blocks

Blocks are portions of code that encapsulate certain functionality. Last time we
talked a little bit about if statements which are a type of block. Blocks have
certain rules that apply to them. The following is an example:

```python
variable = 42
if some_condition:
  variable += 1
  print "it's true"
print "I'm outside of the block"
```

1. they must have a colon at the end of the statement
2. any code that is inside the block must be indented (watch out for spaces vs.
   tabs. Try to be consistent)
3. anything outside of the block must be indented at the same level as the block
   statement
4. it is good practice to define variables before you enter the block so that
   you don't run into problems later on.

### loops

There are different types of loops that you can create but they are all
virtually the same. They do have their own conveniences though.

#### while loops

While loops are a mechanism to continue to do something *while* some condition
is true.

```python
num = 0
while num < 11:
  print num
  num += 1
```

In the previous example we have a while loop that counts to 10. It will continue
to print `num` and increment `num` until it is greater than or equal to 11 at
which time it ends. You may notice that it is formatted very similar to our if
statement. That is because it is also a block. It is important that the same
rules that applied with a colon and indentation are followed here.

#### for loops

For loops are very similar to while loops but they provide us with a different
way of thinking about looping. We get to define a fixed end in the actual
looping statement.

```python
for num in range(1,11,1):
  print num
```

This code is two lines shorter than the while loop. This is because for loops
are very good at doing things a certain number of times. This is also a block
and must have the colon and indentation.

There is a special function we are using to get the range of numbers we want. It
is the `range()` function. The range function allows us to loop a specific
number of times. It takes 3 arguments `range(start, stop, step)`. The start is
the number you want to begin at. The stop is the number you want to stop before
(11 will make it so 10 is the last number we print). Step is the number we want
to increment by through each loop or iteration. If we were to pick a step of 2
we would get the output: `1, 3, 5, 7, 9`.

### special commands

Loops have some special commands that make it easier to work with the looping
flow. These are `break`, `continue` and `pass`.

```python
num = 0
while True:
  if num == 5:
    num += 1
    continue
  print num
  num += 1
  if num == 11:
    break

if i_dont_know_what_to_do:
  pass
```

The continue statement simply skips the rest of the loop and starts on the next
iteration. The break statement will completely break out of the loop and
continue execution where the block ends. `pass` is what we call a noop (pronounced
NO-op and stands for no operation). This does nothing. If we didn't put `pass`
in the `if` statement above though the program would not be able to run. The
`pass` simply allows us to move on in our program.

### modules

Modules are very useful to use in our programs. They are pieces of code that
someone else wrote (they could even be your own modules) that you can import
into your program. They have functions on them that you can call to perform some
kind of functionality.

Some common modules are `sys`, `os`, `math` and `random`. These are really handy
and one of my favorites is `random`. We could create a little dice rolling
program using `random`:

```python
import random
print random.randint(1,6)
```

This very simple program will print out a random number between 1 and 6.

You can import modules in various ways:
- `import random` will simply import all of random's functions prefixed by
    random as we saw in the example above.
- `import random as rand` will allow you to shorten the command like: `print
    rand.randint(1,6)`
- `from random import randint` will allow you to call `randint` without any
    prefix: `print randint(1,6)`
- `from random import *` will import all of randoms methods in a manner that you
    don't have to prefix them (I don't recommend doing this)

repository: reedcwilson/programming-fundamentals

repo_name: reedcwilson/programming-fundamentals


text:
# [v1.0.0](https://github.com/upb-uc4/University-Credits-4.0/compare/operation-v0.19.1...operation-v1.0.0) (2021-03-15)
## Feature
- Added token with expiration date to every getProposal
- Added token with expiration date to every getTransaction
- Added check with expiration date to submitProposal
- Added check with expiration date to submitTransaction
## Refactor
## Bugfix

# [v0.19.1](https://github.com/upb-uc4/University-Credits-4.0/compare/operation-v0.18.1...operation-v0.19.1) (2021-03-03)
## Feature
- Added call to get a user's watchlist
- Added functionality to clear a user's watchlist on user deletion
## Refactor
## Bugfix

# [v0.18.1](https://github.com/upb-uc4/University-Credits-4.0/compare/operation-v0.17.1...operation-v0.18.1) (2021-02-15)
## Feature
 - Adapted Service to new HLF API
## Refactor
## Bugfix

# [v0.17.1](https://github.com/upb-uc4/University-Credits-4.0/compare/operation-v0.16.1...operation-v0.17.1) (2021-02-04)
## Feature
 - Adapted Operation Service to implement Operations 1.1 API
    - Added POST endpoint for unsigned_proposal_approve
 - Adapted Service to new Certificate API
## Refactor
## Bugfix

# [v0.16.1](https://github.com/upb-uc4/University-Credits-4.0/compare/operation-v0.16.1...operation-v0.16.1) (2021-01-28)
## Feature
 - Created Operation Service with endpoints for
    - getting operations
    - acknowledging operations
    - rejecting operations (temporarily on the getProposal endpoint, proper proposal workflow coming in next version)
## Refactor
## Bugfix

branch_name: refs/heads/develop

extension: md

gha_language: Scala

license_type: permissive


text:
# NetMonitor
## What it does
PowerShell script that runs an ICMP echo request ("ping") to <IP_ADDRESS> or a host of your choice using PowerShell's `Test-NetConnection` command and stores the result in an SQLite database. Date/Time is stored as [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time). Script can easily be run periodically, e.g. using Windows Task Scheduler.

`powershell -ExecutionPolicy Bypass -Command C:\Path\to\NetMonitor\NetMonitor.ps1`

I wrote this to check how often my internet connection is down.

## Parameters
.\NetMonitor.ps1 -Hostname `some.host` -Database `C:\Full\Path\to\SQLite.db`

## Requirements
* [PowerShell](https://github.com/PowerShell/PowerShell)
* [PSSQLite](https://github.com/RamblingCookieMonster/PSSQLite)

branch_name: refs/heads/master


text:
+++
# Display name
name = "Ben Andrew"

# Is this the primary user of the site?
superuser = true

# Role/position
role = "Resident Physician-Scientist"

# Organizations/Affiliations
#   Separate multiple entries with a comma, using the form: `[ {name="Org1", url=""}, {name="Org2", url=""} ]`.
organizations = [ { name = "Department of Anesthesiology | Duke University School of Medicine", url = "" } ]

# Short bio (displayed in user profile at end of posts)
# bio = "My research interests include distributed robotics, mobile computing and programmable matter."

# Enter email to display Gravatar (if Gravatar enabled in Config)
email =<EMAIL_ADDRESS>
# List (academic) interests or hobbies
interests = [
  "Pediatric Anesthesiology",
  "Risk Prediction Modeling",
  "Heterogeneity of Treatment Effects",
  "Clinical Decision Making",
  "Statistics",
  "Epidemiology",
  "Data Visualization"
]

# List qualifications (such as academic degrees)
[[education.courses]]
  course = "MD"
  institution = "Duke University School of Medicine"
  year = 2019

[[education.courses]]
  course = "MHS in Clinical Research"
  institution = "Duke University School of Medicine"
  year = 2018

[[education.courses]]
  course = "BS in Nutritional Sciences"
  institution = "Cornell University"
  year = 2013

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/widgets/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "#contact" for contact widget.

[[social]]
  icon = "envelope"
  icon_pack = "fas"
  link = "#contact"  # For a direct email link, use<EMAIL_ADDRESS>
[[social]]
  icon = "twitter"
  icon_pack = "fab"
  link = "https://twitter.com/BenYAndrew"

[[social]]
  icon = "google-scholar"
  icon_pack = "ai"
  link = "https://scholar.google.com/citations?user=dUCBcpwAAAAJ&hl=en"

[[social]]
  icon = "github"
  icon_pack = "fab"
  link = "https://github.com/andrew10043"

# Link to a PDF of your resume/CV from the About widget.
# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
# [[social]]
#   icon = "cv"
#   icon_pack = "ai"
#   link = "files/cv.pdf"

+++

I am a resident physician-scientist in the Department of Anesthesiology at the Duke University School of Medicine with plans to pursue a fellowship in Pediatric Anesthesiology. My primary interests include risk prediction and rigorous assessment of heterogeneity of treatment effects in an effort to develop tools to guide patient-specific clinical decisions in the perioperative period.

license: MIT


text:
# Samples for Cohesity Management SDK

These samples showcase the combined capability of both *Cohesity Apps SDK* and *Cohesity Management SDK*.
Samples leverage *Cohesity App APIs* for seamless authentication without requiring login credentials from the end user.

### Prerequisites

These samples depend on *Cohesity Management SDK* (https://github.com/cohesity/management-sdk-python) and
*Cohesity Apps SDK* (https://github.com/cohesity/app-sdk-python/tree/master/cohesity_app_sdk)
Note: The samples do not have any dependency requirement if deployed through  *Cohesity EasyScript APP*

## Samples

### Clone and Update a Cohesity View.
[README](clone_and_update_view/README.md)

### List Protection Jobs.
[README](list_protection_jobs/README.md)

### List Unresolved Alerts.
[README](list_unresolved_alerts/README.md)

### Running a Protection Job on demand.
[README](on_demand_job_run/README.md)

repository: cohesity/cohesity-easyscript-samples

repo_name: cohesity/cohesity-easyscript-samples


text:
cache-gcfilter
==============

Listens the GC events from the JVM, on Full GC, the ehcaches statistic is flushed on Full GC event

To enable the listening add following code in your application:

		import net.yogocodes.gclistener.ehcache.EhCacheGCListener;

		EhCacheGCListener.register();

See example use please see the ExampleApp.java file.

The events are logged via slf4j, so for example the log4j.xml:

	<logger name="net.yogocodes.gclistener.ehcache.EhCacheGCListener">
 		<level value="info" />
 	</logger>

This jar supports the Oracle java7 and java8.

JVM-options
===========

gc.listener.disable - disable the full gc monitoring. Set this value to true

gc.listener.analyze.memory - set this true, if you want to calculate cache size. This consumes CPU

gc.listener.loop.detect - enable the full gc -loop detection. Monitor only if the full gc is happening too often

gc.listener.loop.time - how often the full gc is determined as a full gc -loop. Value users msecs.

repository: joukojo/cache-gcfilter

repo_name: joukojo/cache-gcfilter


text:
---
layout: post
title: ecolab
---

Businessmodel of Ecolab
------------------------

### Customer Segments

Ecolab has a niche market business model, with a specialized customer segment. The company targets its offerings at firms in the foodservice, food processing, hospitality, healthcare, industrial, and oil and gas markets.

### Value Proposition

Ecolab offers two primary value propositions: performance and brand/status.

The company has demonstrated strong performance through tangible results. Specific examples of positive outcomes for clients include the following:

 * Ecolab helped an operator in South Texas by designing a treatment program that decreased oil carryover, resulting in a 3,550% return on investment with $55,000 in annual increased oil sales
* Ecolab helped a major refinery complex in the Middle East improve bio-fouling control, resulting in $4 million in annual savings and potential reduced maintenance costs of $0.5 million annually
* Ecolab helped a customer implement a paraffin inhibitor to extend production time, resulting in savings of $4,000 per month and total savings of $20,000 in five months
 The company has established a strong brand due to its success. It serves customers in over 1.3 million locations in over 171 countries (including 90 outside of the U.S.). It has 47,000 employees and generates $13.5 billion in annual sales. Lastly, it has won many honors, including the following:

 * Recognition as one of the World’s Most Admired Companies by *Fortune *
* Ranking as #13 out of 500 on *Newsweek’s *Green Rankings list
* Recognition as one of the World’s Most Ethical Companies by Ethisphere ten years in a row
* Recognition as one of the 100 Best Corporate Citizens by *Corporate Responsibility* magazine
* Recognition as one of the Best Companies for Leaders by *Chief Executive* magazine
 ### Channels

Ecolab’s main channel is its direct sales team. It also sells its products through independent third-party distributors. The company promotes its offeringS through its website, social media pages, and participation in conferences.

### Customer Relationships

Ecolab’s customer relationship is primarily of a personal assistance nature. It has its 25,000 field associates partner with clients in order to provide on-the-ground consultation and service at their facilities. That said, there is a self-service component.

The company’s website features a “Document Library” section with useful resources including articles, reports, case studies, and brochures. The site also has a “Resources” section with news, webinars, and expert-authored articles.

### Key Activities

Ecolab’s business model entails designing, developing, and manufacturing its products for customers.

### Key Partners

Ecolab’s key partners are the suppliers that provide it with the over 10,000 raw materials it needs to manufacture its products, as well as other components. These items include the following:

 * Inorganic chemicals, including alkalis, acids, biocides, phosphonates, phosphorous materials, silicates, and salts
* Organic chemicals, including acids, alcohols, amines, fatty acids, surfactants, solvents, monomers, and polymers
* Plastic films and parts to manufacture medical devices that serve the surgical and infection prevention markets
* Packaging materials for its manufactured products
* Components for its specialized cleaning equipment and systems
 Ecolab also maintains several consolidated and non-consolidated joint ventures with various businesses in order to to achieve quicker operational scale, meet local ownership requirements,  expand its ability to provide customers a more fully integrated offering, and provide other benefits.

### Key Resources

Ecolab’s main resources are its human resources, who include the engineers and scientists that design, develop, and/or manufacture its solutions; the water, healthcare, food safety, and public health experts who provide valuable insight; and the customer service personnel who provide support.

It also maintains important physical resources in the form of manufacturing plants and 19 global technology centers. Lastly, it places a high priority on intellectual property, with 6,300 patents.

### Cost Structure

Ecolab has a value-driven structure, aiming to provide a premium proposition through significant personal service and frequent service enhancements. Its biggest cost driver is cost of sales, a variable expense. Other major drivers are in the areas of sales/marketing and administration, both fixed costs.

### Revenue Streams

Ecolab has one revenue stream: revenues it generates from sales of its products to customers.


text:
---
layout:     post
title:      OpenMP support
author:     Stefan Lankes
tags: 	    openmp bare-metal video
subtitle:   Running OpenMP Applications in a bare-metal environment
---

The video shows OpenMP applications running in bare-metal environment.

<div style="width:100%; margin:0; auto" align="center">
<script type="text/javascript" src="https://asciinema.org/a/42857.js" id="asciicast-42857" async=""></script>
</div>


text:
+++
hook = "A little background on cookies and local storage, where they overlap, and where they don't."
published_at = 2020-12-05T20:57:58Z
title = "Cookies vs. local storage"
+++

The phrase "cookies vs. local storage" was something I found myself googling the other day. If I'd thought about it longer and harder, the not-so-unsubtle difference would have come to me, but it was a sloppy google-so-I-don't-have-to-think moment.

It did end up putting me down a bit of a rabbit hole though. Cookies are a deeply entrenched internet keystone, but tend to be so well-abstracted that even web developers don't think about what's happening very often. Local storage is a newer idea that does a different job, but with some overlap.

## Cookies (#cookies)

The basic mechanism of a cookie is very simple. A server sends back a header telling a client that it should now set a cookie:

```
Set-Cookie: id=123
```

The client remembers that value, and when making subsequent requests to the same server, sends it through:

```
Cookie: id=123
```

A lot of us are used to thinking about cookies as tarnished technology these days for spying and selling ads, but we should remember that the fundamental reason they exist is to facilitate complex interactions on the web. Unlike with a desktop application which stays open and keeps all its state around moment to moment, the web is fundamentally _stateless_. From a server's perspective, there's no intrinsic way in which two HTTP requests from the same user are related.

Absent cookies, clients would have to send something like a session ID in the payload of every request they made to remind servers of who they are so they could, for example, stay logged in. That's what a cookie does as well, but with a standardized scheme that does the work automatically.

Cookies may also be available on the client side via JavaScript's [`document.cookie`](https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie) API.

Over the years, cookies have picked up new bells and whistles, largely for reasons of security and privacy. `Secure` ensures cookies are sent over encrypted HTTPS only. `HttpOnly` disables client-side JavaScript access. `Path` can scope cookies down to specific HTTP paths. `SameSite` defines behavior around cross-origin requests to mitigate CSRF attacks. Most apps will want to use most of these to keep things as tight as possible. Adtech will intentionally relax use of them to improve the chances of users checking in.

Beyond security, the blunt instrument of a cookie can have other downsides as well. Back when I worked at iStock, we were always careful to serve static assets from a separate domain as a resource optimization measure to prevent clients from sending sizable `Cookie` payloads for thousands of image requests where no cookie was needed. This is often less of a problem nowadays by virtue of that the fact that a lot of big apps will be using a separate domain for static assets for CDN purposes anyway, but still worth thinking about.

Lastly, cookies have a size limit of roughly 4096 bytes. This is a hallmark of the fact that they're intended as a vehicle for an identifiers of server-side state, and not intended for use transmission anything heavy.

## Local storage (#local-storage)

Like cookies, local storage also saves state, and can do so across multiple requests. Unlike cookies, it can't be used to transmit anything to servers -- it's a mechanism that lives purely on the client side.

It has a number of advantages. Most obviously, a [much improved API](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) (no need to do your own encoding like with a cookie):

``` js
localStorage.setItem('myCat', 'Tom');
const cat = localStorage.getItem('myCat');
localStorage.removeItem('myCat');
localStorage.clear();
```

Cookies require a dynamic server process to receive a cookie, interpret the results, and do some persistence. Since local storage lives purely in the browser, none of that is required, making it perfect for applications that don't have or want a dynamic component. Static sites for example.

It can also store _more_, up to 5 MB, although it's not recommended to do so because the API for setting and getting data is synchronous and will block the main thread.

Lastly, there's an argument to be made in favor of local storage for user privacy. Why send something back to the cloud when you don't have to? With local storage, users are in possession of their data and can purge it at will.

## What to use (#what-to-use)

There's a reason that cookies exist, and a lot of what they do can't be replicated by local storage, but there's certainly a local storage sweet spot for applications that want to store some minimal configuration needed on the client side, but don't otherwise need cookies for anything.

Personally, I've found it perfect for things like remembering a user's preference between light mode and dark mode -- no server-side persistence required, and local storage is long-lived enough that it still feels changing the setting is permanent, lasting until the user explicitly clears their caches.

repository: brandur/sorg

gha_language: Go

gha_license_id: MIT

repo_name: brandur/sorg


text:
# Ironfan Core: Knife Tools and Core Models

Ironfan, the foundation of The Infochimps Platform, is an expressive toolset for constructing scalable, resilient architectures. It works in the cloud, in the data center, and on your laptop, and it makes your system diagram visible and inevitable. Inevitable systems coordinate automatically to interconnect, removing the hassle of manual configuration of connection points (and the associated danger of human error).
For more information about Ironfan and the Infochimps Platform, visit [infochimps.com](http://www.infochimps.com/).

This repo implements:

* Core models to describe your system diagram with a clean, expressive domain-specific language
* Knife plugins to orchestrate clusters of machines using simple commands like `knife cluster launch`
* Logic to coordinate truth among chef server and cloud providers

## Getting Started

To jump right into using Ironfan, follow our [Installation Instructions](https://github.com/infochimps-labs/ironfan/wiki/INSTALL). For an explanatory tour, check out our [Web Walkthrough](https://github.com/infochimps-labs/ironfan/wiki/walkthrough-web).  Please file all issues on [Ironfan issues](https://github.com/infochimps-labs/ironfan/issues).

### Tools

Ironfan consists of the following Toolset:

* [ironfan-homebase](https://github.com/infochimps-labs/ironfan-homebase): centralizes the cookbooks, roles and clusters. A solid foundation for any chef user.
* [ironfan gem](https://github.com/infochimps-labs/ironfan):
  - core models to describe your system diagram with a clean, expressive domain-specific language
  - knife plugins to orchestrate clusters of machines using simple commands like `knife cluster launch`
  - logic to coordinate truth among chef server and cloud providers.
* [ironfan-pantry](https://github.com/infochimps-labs/ironfan-pantry): Our collection of industrial-strength, cloud-ready recipes for Hadoop, HBase, Cassandra, Elasticsearch, Zabbix and more.
* [silverware cookbook](https://github.com/infochimps-labs/ironfan-pantry/tree/master/cookbooks/silverware): coordinate discovery of services ("list all the machines for `awesome_webapp`, that I might load balance them") and aspects ("list all components that write logs, that I might logrotate them, or that I might monitor the free space on their volumes".

### Documentation

* [Index of wiki pages](https://github.com/infochimps-labs/ironfan/wiki/_pages)
* [Ironfan wiki](https://github.com/infochimps-labs/ironfan/wiki): high-level documentation
* [Ironfan issues](https://github.com/infochimps-labs/ironfan/issues): bugs, questions and feature requests for *any* part of the ironfan toolset.
* [Ironfan gem docs](http://rdoc.info/gems/ironfan): rdoc docs for Ironfan
* [Ironfan Screencast](http://bit.ly/ironfan-hadoop-in-20-minutes) -- build a Hadoop cluster from scratch in 20 minutes.
* Ironfan powers the [Infochimps Platform](http://www.infochimps.com/how-it-works), our scalable enterprise big data platform. Ironfan Enterprise adds zero-configuration logging, monitoring and a compelling UI.

**Note**: Ironfan is [not compatible with Ruby 1.8](https://github.com/infochimps-labs/ironfan/issues/127). All versions later than 1.9.2-p136 should work fine.

### The Ironfan Way

* [Core Concepts](https://github.com/infochimps-labs/ironfan/wiki/core_concepts)     -- Components, Announcements, Amenities and more.
* [Philosophy](https://github.com/infochimps-labs/ironfan/wiki/Philosophy)            -- Best practices and lessons learned
* [Style Guide](https://github.com/infochimps-labs/ironfan/wiki/style_guide)         -- Common attribute names, how and when to include other cookbooks, and more
* [Homebase Layout](https://github.com/infochimps-labs/ironfan/wiki/homebase-layout) -- How this homebase is organized, and why

### Getting Help
* Feel free to contact us at<EMAIL_ADDRESS>or 855-DATA-FUN
* Also, you're invited to a [private consultation](http://www.infochimps.com/free-big-data-consultation?utm_source=git&utm_medium=referral&utm_campaign=consult) with Infochimps founders on your big data project.

repository: infochimps-labs/ironfan

gha_language: Ruby

gha_license_id: NOASSERTION

repo_name: infochimps-labs/ironfan


text:
# ACR - Academic Course Registration load tester

Purpose of this project is to show how to loadtest the demo project at https://github.com/fnunezkanut/acr
using Gatling+Scala

### Requirements
* JDK 1.8
* Scala
* Kotlin
* IntelliJ

### Local development of Simulations

* Create a <SimulationName>Simulation.scala class in src/gatling/scala/

* Running a single simulation
* ``./gradlew clean gatlingRun-<SIMULATION_CLASSNAME_HERE>``
* eg: ```./gradlew clean gatlingRun-HealthcheckSimulation```

Running integration simulation with custom properties
* ``./gradlew clean gatlingRun-HealthcheckSimulation -Penv=dev``
where `dev.properties` should exist in `propfiles/` folder.
Check `propfiles/sample.properties_` for examples and more documentation

If you want more details on what the simulation is doing consider developing only with 1 user as input
in build.gradle edit gatling.logLevel setting from WARN to TRACE

### Viewing load test reports

After each run a html report is generated in /build/reports/gatling/ directory

There is also a simulation.log containing raw simulation data, which could be parsed for further integration...

repository: fnunezkanut/acr-loadtester

branch_name: refs/heads/main

repo_name: fnunezkanut/acr-loadtester


text:
---
author: shisaq
comments: true
date: 2017-01-24 20:42:35+00:00
layout: post
title: Unable To Manipulate MongoDB Due To Unproperly Closed Terminal?
tags:
- frontend
---

> I met a problem while I was learning MongoDB. Here are my steps eliciting the problem:

1. I start MongoDB service: `mongod`.

2. In my terminal, at the MongoDB service window, I carelessly close it without using `ctrl + c` to kill the service process.

3. Now, I cannot manipulate MongoDB service AT ALL...

## Solution

There might be several different ways to solve the problem in different systems. Mine is MacOS, so here is my solution:

1. Open a new window of terminal, type `mongo`, to enter MongoDB, as the process is still working, so I'm able to login.

2. type `use admin` to get the root permission.

3. type `db.shutdownServer()`.

Now the service has been closed successfully. I can simply type `mongod` to start it again, and manipulate by using the normal window. Next time, I will be carefull when trying to close a terminal window. Attatching this solution in case the same condition happens in future.

## Reference

[stackoverflow](http://stackoverflow.com/questions/8495293/whats-a-clean-way-to-stop-mongod-on-mac-os-x)

gha_language: JavaScript


text:
# libfibonacci - `ubxlib` library example

This is a trivial `ubxlib` library which can do three things:
* calculate a number from the fibonacci series
* return last calculated number
* return a hello world string

It serves the purpose of showing how a `ubxlib` library can be implemented.

# File structure

`api/` - the library public header

`src/` - the library implementation

`example-app/` - platform specific example apps using the library

`platform/` - platform specific utility scripts for building the library

`Makefile` - will build the library using module `common/lib_common` library build utilities

repository: PCI-BDO/ubxlib

repo_name: PCI-BDO/ubxlib


text:
[![CircleCI](https://circleci.com/gh/giantswarm/bridge-operator.svg?&style=shield)](https://circleci.com/gh/giantswarm/bridge-operator) [![Docker Repository on Quay](https://quay.io/repository/giantswarm/bridge-operator/status "Docker Repository on Quay")](https://quay.io/repository/giantswarm/bridge-operator)

# bridge-operator

`bridge-operator` is deployed as a DaemonSet on all KVM installations. It emits metrics for orphaned flannel resources.


text:
# Row Checks

## Duplicate Row

This checks for duplicate rows. You need to take into account that checking for duplicate rows can lead to high memory consumption on big files. Here is an example.

### Example

```python script tabs=Python
from pprint import pprint
from frictionless import validate, checks

source = b"header\nvalue\nvalue"
report = validate(source, format="csv", checks=[checks.duplicate_row()])
pprint(report.flatten(["type", "message"]))
```

### Reference

```yaml reference
level: 4
references:
  - frictionless.checks.duplicate_row
```

## Row Constraint

This check is the most powerful one as it uses the external `simpleeval` package allowing you to evaluate arbitrary Python expressions on data rows. Let's show on an example.

### Example

```python script tabs=Python
from pprint import pprint
from frictionless import validate, checks

source = [
    ["row", "salary", "bonus"],
    [2, 1000, 200],
    [3, 2500, 500],
    [4, 1300, 500],
    [5, 5000, 1000],
]
report = validate(source, checks=[checks.row_constraint(formula="salary == bonus * 5")])
pprint(report.flatten(["type", "message"]))
```

### Reference

```yaml reference
level: 4
references:
  - frictionless.checks.row_constraint
```

repository: frictionlessdata/frictionless-py

gha_language: Python

repo_name: frictionlessdata/frictionless-py


text:
# DeviceMonitoring
DeviceMonitor (A Full Stack Application) audits running applications in a device (e.g. ubuntu desktop, android device, mac machine) with the help of DeviceManager who manage devices. DeviceManager get the audit information from the DeviceDaemon(running inside the device, responsible to collect the running application information in a specified time interval). If Device-Monitor finds any suspicious activity on that device, then it alerts to the authorized user of that device.

![alt tag](http://media.hiringlibrary.com.s3.amazonaws.com/wp-content/uploads/17045321/How-DeviceMonitor-Works.png)

# Flow of Device Monitoring

DeviceDaemon: – Device Daemon is a TCP server, it waits for DeviceInfo request to receive. Once It receive the request, It calls to DeviceWorker(a new thread) which in turn call DaemonHelper. That DaemonHelper executes a perl script or ‘ps axo ppid,pid,command’ to get the details info about the ‘process’ running in that device. It parses the received ‘process information’ and converts into a Linked List of process.

This LinkedList of process processed by the DeviceProcessToJsonConverter. It parses the received list of nodes, put into right parent/child tree order and then converts into a json file DeviceInfo.json. It also adds additional information into this file e.g. Device Time, Address,OS Details.
Once the DeviceInfo.json got prepared then DeviceWorker send this DeviceInfo.json to DeviceManager and terminate its thread.

DeviceManager: DeviceManager runs TCP client in a thread. In every minute (time is configurable), it sends a DeviceInfo request to DeviceDameon. That DeviceDameon receives the request and return the DeviceInfo.json to DeviceManager. DeviceManager receives DeviceInfo.json file, then it maps DeviceInfo.json to a DeviceInfo Object and adds additional information e.g. time it received the info and produce DeviceInfoDB Object. After that it converts DeviceInfoDB Object into Json and then insert it to MongDB’s collection -name -‘DeviceInfo’.

Device-Monitor Web Service: This Web Service runs inside the Catalina container, deployed as a REST based web service. The URL of this GET is: http://localhost:8080/device-monitor/device/getdeviceinfo. Internally it call the getDeviceInfo API, which in turn access the DeviceInfo MongoDB database ,fetches the latest DeviceInfo Record and then return to caller as a JSON response.

Device-Monitor Display: It contains following things :

Device-Monitor.html – On call to http://localhost:8080 , browser fetches this file and display on the browser with ‘Start’ and ‘Stop’ Button.

Devicemonitor.js: On click to start, it sends getDeviceInfo GET request (on every 60 seconds) to the webservice( as explained above) and receives the DeviceInfo.json file. It parses this file and display the information on Browser.

# How overall flow will work ?

[Assumption : Java/Maven/MongoDB installed on the machine]

 // Run MongoDB

 Step-1 : Start MongoDB Server, Create a Database name ‘DeviceInfo’ and collection deviceInfo.

 // Run DeviceDameon

Step-2 : Go to DeviceDaemon folder – Type : mvn clean install, and then go to its target folder and Type : java -jar device-daemon.jar

(to configure IP and port, go to its config.properties file)

// Run DeviceManager

Step-3 : Go to DeviceManager folder – Type : mvn clean install, and then go to its target folder and Type : java -jar device-manager.jar

(to configure IP and port, go to its config.properties file)

Now Device Manager getting the DeviceInfo.json from DeviceDaemon and inserting into the DeviceInfo database of MongoDB.

// Once both are running, then run the WebService

Step-4 : Go to DeviceMonitor folder – Type : mvn clean install, and then go to its target folder and Type : mvn tomcat7:run

(to configure IP and port, go to its config.properties file)

![alt tag](http://media.hiringlibrary.com.s3.amazonaws.com/wp-content/uploads/17045133/All-Four-Process-are-Running.png)

// Open the browser
Step-5 : Open the browser e.g. chrome or safari , type : http://localhost:8080/
5.1 It will show Device-Monitor.html as below :

![alt tag](https://github.com/esumit/DeviceMonitoring/blob/master/Images/DeviceMonitoring_MainPage.png)

5.2 Click ‘Start’ button – It will start fetching the records from database and change the Stop button to ‘Stop it If you want’

![alt tag](https://github.com/esumit/DeviceMonitoring/blob/master/Images/DeviceMonitoringWithDetails.png)

5.3 Scroll Down to See the Device’s Process details:

A process shows red if it is harmful for the system (dummy at this time, randomly picked some process as harmful process).

A process shows green if its normal process.

![alt tag](https://github.com/esumit/DeviceMonitoring/blob/master/Images/DeviceMonitor_DeviceStatus.png)

Code Structure

![alt tag](https://github.com/esumit/DeviceMonitoring/blob/master/Images/DeviceMonitor_CodeStructure.png)

Technology Used:

OS  Used : Mac OS X,10.10.1, x86_64
Languages : Java , JavaScript, CSS,JavaScript
Framework/Server : Apache CXF, Spring, Tomcat Container
Database : MongoDB

repository: netpass/DeviceMonitoring

repo_name: netpass/DeviceMonitoring


text:
Visual Questioning and Answering System

We yet have to train the whole model, We have tried a prototye of custom images and questions.

The Whole architecture will be posted soon:

Resnet152:
	The Resnet152 Model taken from adamcasson(https://github.com/adamcasson/resnet152/blob/master/resnet152.py)


text:
HIPPO CHAT

People, involved in the project:
1. https://github.com/ginkogrudev | https://softuni.bg/users/profile/show/GinkoGrudev
2. https://github.com/VaskoViktorov | https://softuni.bg/users/profile/show/Backo_vd  - Created the admin panel, chat, main and user info views. Polished some of the other views, changed the structure of the project.
3. https://github.com/Bullsized | https://softuni.bg/users/profile/show/Bullsized > Created the repository, so we can all participate, invited Ginko and Vasko as collaborators. Created the main UI of the chat, showed how registered users can customize their profile and/or other personal details; create, join and participate in both public and private chat rooms, view other people's profiles, attach files, send pictures and so on - everything is in the Bullsized\ folder.

And unfortunately we do NOT have a number 4, because of the js-teamwork.github.io system having a bug and putting him in two groups, so it's just the three of us.

Online Live Chat
1.	Requirements
Create a Web-based application for real-time text messaging. Users can connect anonymously with a nickname and participate in different chat rooms.
Provide the following functionality to all visitors (without authentication):
•	Send messages anonymously under a nickname
•	Join public chat rooms
In addition to the previous functionality, registered users can:
•	Customize their profile with a picture and other personal details
•	Reserve a nickname
•	Create and join private chat rooms (with password protection)
Authenticated administrators have additional options, available in the normal views of the app. They should have the ability to:
•	View the profiles of all users
•	Mute or ban users who post inappropriate messages
•	Join all chat rooms, including password protected ones
Create a Web UI prototype for the Online Chat system.

2.	Team Organization
Create a GitHub organization for all team members, or a GitHub project with collaborators. Initialize the project with a Readme.md file in which you should describe what each team member is doing.
Split the different views (core pages) of your assignment and have each team member work on at least one task. Commit the results to the GitHub repository.

3.	Tools
When creating the prototypes, you are free to use whatever method you like, including paper and post-it notes (take pictures and commit them to the repository). Additionally, you may use image editing software, HTML+CSS, or a prototyping tool (Indigo Studio, Balsamiq, etc.).

4.	Submitting Your Work
If you used a prototyping tool that works online, submit a link to your project page instead, and make sure it’s publicly accessible. Every team member submits the same link!

repository: Bullsized/Teamwork-Assignment-Live-Chat

repo_name: Bullsized/Teamwork-Assignment-Live-Chat


text:
Also, why does it never stop spinning?

## Install and Running

Ok, rants aside, it seems to work nicely

- Install drivers: `sudo apt install ros-foxy-rplidar-ros`
    - Then: `source /opt/ros/foxy/setup.bash`
- Run lidar node to get data: `ros2 run rplidar_ros rplidarNode`
- Run client node to see data: `ros2 run rplidar_ros rplidarNodeClient`


text:
# Cytoskeleton

This is a script to analyse cytoskeleton organisation in 2D images

## Input data

The following three sub-folders within a single directory need to be present:
1. **borders** with the 8-bit tif images of cell outlines (e.g. E-cadherin staining) segmented in Packing Analyser. Each image will have a subfoder with the same name, that need to contain "tracked_bd.png" mask.

1. **cytoskeleton** with the corresponding tif projections (we use maximum projection in this case), which will be analysed for alignminet of cytoskeleton fibers within cells.

1. **cytoskeleton_average** with the corresponding tif projections (we use average projection in this case), which will be analysed for density and uniformity of cytoskeleton organisation.

Images should be numbered, but the numbers do not have to be sequencial, and the names might contain additional information. The numbers in image names will be used in the output files.

## Running the script
1. Start **actin_automatic_v1.m** script.

1. Select a folder with input data.

1. Select the parameters you would like to analyse: alignment of cytoskeleton (*MTSD*) or cytoskeleton distribution (*Density*).

1. In case you select density, choose the threshold method: Otsu's method with a threshold calculated on an adjusted image (*Otsu*), or calculating a threshold from intensity of edges detected in an image (*Edges*).

## Output files and format

The following folders will be automatically created depending on the selection at the start of a run.
1. **distribution** with cell-by-cell signal direction distributions for each image (**image number**_distribution.csv) in case *MTSD* option for analysis is selected.

1. **images_analysed** with adjusted images of cytoskeleton, projection of a cell mask on them and numbers of each analysed cell.<br>
![Example of analysed image](images/8_analysed_image.png)

1. **summary** with the summarysed data.

In the summary folder the subfolders will be created depending on the run choice: *edges*, *otsu* or *MTSD*. These subfolders will contain **image number**_summary**run choice**.csv files with cell-by-cell data for each analysed image. The cell numbers correspond to that in *images_analysed* files.

Additionally, in the summary folder itself will be files with data averaged per image: *Summary_edges.csv*, *Summary_otsu.csv* or *Summary_MTSD.csv* depending on the run choice.

## Output data explained

### MTSD
The following columns record cell-by-cell data:
1. **Cell** - cell number, which correspond to the cell number in *images_analysed*.
1. **Area** - area in pixels of each cell.
1. **Eccentricity** - eccentricity of each cell.
1. **Direction_cell** - direction of the main axis of each cell calculated from regionprops.
1. **SD** - a measure of cytoskeleton alignment, which is a standard deviation of signal direction distribution, fitted with Von-Misus distribution. For detailed explanation of how it is calculated see Gomez J.M., Chumakova L., Bulgakova N.A., Brown N.H. (2016) Microtubule organization is determined by the shape of epithelial cells. Nature Communications, 7. [PubMed](https://www.ncbi.nlm.nih.gov/pubmed/27779189).
1. **DEV** - a measure of direction of overall cytoskeleton orientation - mean of signal direction distribution, fitted with Von-Misus distribution.
1. **Elongation** - aspect ratio of each cell calculated from eccentricity.
1. **Alignment** - an alernative measure for cytoskeleton alignment, calculated as proportion of signal within 10° of mean signal direction.

### Density
Independent on the chosen way to threshold, the resulting files will contain the following cell-by-cell data about the cytoskeleton signal:
1. **Cell** - cell number, which correspond to the cell number in *images_analysed*.
1. **Signal area** - proportion of pixels above threshold.
1. **Density** - mean intensity of pixels above threshold with subtracted mean intensity of pixels below threshold, and then normalized to mean intensity of pixels below threshold and signal area.
1. **Bundling** - mean intensity of pixels above threshold normalized to threshold.
1. **Uniformity** - standard deviation of signal in each cell without thresholding.
1. **Sparseness** - sparseness of the signal, calsulated as discribed in Lin A.C., Bygrave A.M., de Calignon A., Lee T., Miesenböck G. (2014). Sparse, decorrelated odor coding in the mushroom body enhances learned odor discrimination. Nat Neurosci. 17(4):559-68. [PubMed](https://www.ncbi.nlm.nih.gov/pubmed/24561998).
1. **Skewness** - skewness of the signal above threshold.
1. **Kurtosis** - kurtosis of the signal above threshold.

## References
1. Gomez J.M., Chumakova L., Bulgakova N.A., Brown N.H. (2016) Microtubule organization is determined by the shape of epithelial cells. Nature Communications, 7. [PubMed](https://www.ncbi.nlm.nih.gov/pubmed/27779189).
1. Lin A.C., Bygrave A.M., de Calignon A., Lee T., Miesenböck G. (2014). Sparse, decorrelated odor coding in the mushroom body enhances learned odor discrimination. Nat Neurosci. 17(4):559-68. [PubMed](https://www.ncbi.nlm.nih.gov/pubmed/24561998).

repository: nbul/Cytoskeleton

repo_name: nbul/Cytoskeleton


text:
---
name: StratMap 2018 50cm Crockett County Lidar
short_description:
Lidar data for portions of Crockett County

type: Raster
available_formats: LAS
source: StratMap
coverage_extent: Crockett County
data_download_lvl:
statewide_coverage:
footprint: 1/64 USGS Quadrangle
download_size:
recommended_use: Basemap, Research, Analysis
date_created: 2018
tags: Crockett County, Lidar, Point Cloud, LAS, Elevation, County, Historical
known_issues: None
alternative_data: 1M Hydro-Flattened DEM, 3D Breaklines
derivative_data: 2ft and 5ft Contours
spatial_reference:
EPSG 6344

relationship_tag:
category: Lidar
download: T
download_link:
order: T
wms_category:
wms_link:
pop_link:
status_map_cartodb_id: 1be7ada8-df6b-4df6-a7f4-42ed8901c704
agency:
agency_web:
agency_gis_page:
date_added: 2018-08-26
license: CC0
tile_index: Lidar
supplemental_report: T
lidar_breaklines: T
urlized_name: stratmap-2018-50cm-crockett-lidar
filename: data-catalog/entry/stratmap-2018-50cm-crockett.md
layout: redirect.njk
title: StratMap 2018 50cm Crockett County Texas
urlized_category: lidar
detail_image_url: images/data-catalog/entry/stratmap_2018_50cm_crockett_lidar_detail.jpg
overview_image_url: images/data-catalog/entry/stratmap_2018_50cm_crockett_lidar_overview.jpg
thumb_url: images/data-catalog/entry/stratmap_2018_50cm_crockett_lidar_th.jpg
supplemental_report_url: https://tnris-datadownload.s3.amazonaws.com/datacatalog/supplemental_reports/stratmap_2018_50cm_crockett_supplementalreports.zip
tile_index_url: https://tnris-datadownload.s3.amazonaws.com/d/tnris-lidar/state/tx/tnris-lidar_tx.zip
lidar_breaklines_url: https://tnris-datadownload.s3.amazonaws.com/datacatalog/lidar_breaklines/stratmap_2018_50cm_crockett_breaklines.zip
license_text: Public Domain (Creative Commons CC0)
license_url: https://creativecommons.org/publicdomain/zero/1.0/
---

The Texas Water Development Board (TWDB) and the Texas Commission on Environmental Quality partnered to acquire high quality lidar data. The Statement of Work was issued by the Strategic Mapping (StratMap) Program of the Texas Natural Resources Information System (TNRIS), part of the Texas Water Development Board (TWDB). The project area is approximately 484 square miles in Crockett County, Texas. The data was acquired by Sanborn with third party QAQC from AECOM. The project specification for the lidar data acquisition was developed to support a point density of 4 points per square meter. The dates of acquisition are March 20,2018-March 22, 2018. The purpose of this LiDAR data was to produce high accuracy 3D elevation products, including tiled LiDAR in LAS 1.4 format, 3D breaklines, and 1 meter cell size hydro flattened Digital Elevation Models (DEMs).

Lidar data for Texas is made available online through the use of data compression using [LASTools](https://rapidlasso.com/lastools/). LASTools is an open-source collection of tools for lidar data viewing and manipulation. TNRIS uses the LASzip portion of LASTools for compression\decompression. LASTools provides a lossless compression of the data from las to laz formats.

- Software with native LAZ support
- ERDAS IMAGINE (14.1 and up) by Hexagon Geospatial
- Global Mapper (13.1 and up) by Blue Marble Geo
- ENVI LiDAR (5.1 and up) by Exelis VIS
- FME (2012 and up) by Safe Software
- LAStools by rapidlasso
- plas.io 3D Web Viewer by Hobu Inc.
- FUSION (3.40 and up) by Bob McGaughey of the USDA
- Voyager (1.3 and up) by Voyager GIS
- GRASS GIS (7.0 and up) by Open Source Geospatial Foundation (OSGeo)


text:
# send_safe
> Safely convert Rust types to `Send`

Suppose you have a variable `x` of type `T` which is not `Send`.
We want to use `x` from other threads.
But `T` is not `Send`, so we cannot move `x` across threads.

This crate provides `SendWrapperThread` which will create `x` in its own thread.
Then you can interact with `x` from other threads through the wrapper.

This is safe because `x` always stays on its own dedicated thread.
It's only the communication with it that needs to cross thread boundaries.
The thread exits and `x` is dropped when the wrapper is dropped.

## Example Usage
Suppose `x` is a raw pointer, which is not `Send`:

```rust
use send_safe::SendWrapperThread;

let make_x = || Box::into_raw(Box::new(41));
let mut wrapper = SendWrapperThread::new(make_x);

// Use `wrapper` to interact with `x` from inside a different thread.
std::thread::spawn(move || {
    let x_plus_1 = wrapper.execute(|&mut x| {
        // The Box is just for demonstrating wrapping a raw pointer.
        // This doesn't have to be unsafe if you were using different types.
        let unboxed_x = unsafe { Box::from_raw(x) };
        *unboxed_x + 1
    }).unwrap();
    assert_eq!(x_plus_1, 42);
}).join().unwrap()
```

Use `wrapper.execute_move` if you want to take ownership and possibly consume `x`.

## Acknowledgements
Thanks to [@pirocks](https://github.com/pirocks/) for advice and debugging help.


text:
---
ID: 872
post_title: Lesson Example From Google Docs
author: Mark Lang
post_excerpt: ""
layout: post
permalink: >
  https://www.creativemedia.space/lesson-sample-original/
published: true
post_date: 2017-12-27 19:09:24
---

Title of the Lesson Revised

Subtitle of the Lesson

This is the Summary paragraph. The Summary is a quick introduction to the lesson in a single paragraph form. It should be a brief, engaging overview of the lesson, similar to an editorial nut graph and inverted pyramid style of writing used in journalism. Suggested length is 4-5 sentences. It should briefly describe the lesson, state the primary purpose, goals, etc. Perhaps state the who, what, why, when, and how.

This is a definition or link or block quote. Example: can be used for Wikipedia definitions.

– Source

Image Heading

Image caption explaining the key points of the image

Section Heading or Step One

Brief Description of Section/Step One

Image caption explaining the key points of the image

This is an explanation of this section or step. It can include inline images, videos, lists, sub-headers, paragraphs, etc. Be sure to keep it as short as possible.

Section or Step Two

Brief Description of Section/Step Two

Image caption explaining the key points of the image

This is an explanation of this section or step. It can include inline images, videos, lists, sub-headers, paragraphs, etc. Be sure to keep it as short as possible.

Section or Step Three

Brief Description of Section/Step Three

Image caption explaining the key points of the image

This is an explanation of this section or step. It can include inline images, videos, lists, sub-headers, paragraphs, etc. Be sure to keep it as short as possible.

Conclusion

The conclusion is a quick wrap-up of the lesson in a single paragraph form. It should be a brief, rewarding overview of the lesson. Suggested length is 4-5 sentences. It should briefly describe the lesson, explain how the primary purpose, goals, etc were met, and perhaps highlight key outcomes.

Related Resources and Reading

Link to Resource One

Link to Resource Two

Link to Resource Three

Go Further

Try doing this Link to Resource One

Try adding a Link to Resource Two

Can you replicate this Link to Resource Three

Author Notes

This was written specifically to help aspiring web designers as they aim to:

Learn the basic concepts and principles of something as Outcome #1

Understand the basic history and principles of something as Outcome #2

Use applications, technologies, and techniques to address known challenges or common problems as Outcome #3

Create something using something as Outcome #4

Apply something using something as Outcome #5

repository: kccnma/creativemediaspace-jekyll

gha_language: HTML

repo_name: kccnma/creativemediaspace-jekyll


text:
# howtostudykorean-vocab
This repo contains code that saves the vocab entries from howtostudykorean.com into a csv for further parsing.

# usage
First run the download script in the units folder.
Then you can run parse.py on the downloaded html files.

repository: spatker/howtostudykorean-vocab

repo_name: spatker/howtostudykorean-vocab


text:
# BASE jumper's body found in Jurupa Valley rock quarry; death investigated as suspicious

Published at: **2019-11-04T01:17:17+00:00**

Author: **ABC7.com staff**

Original: [ABC7 Los Angeles](https://abc7.com/base-jumpers-death-in-ie-investigated-as-suspicious/5668911/)

JURUPA VALLEY, Calif. (KABC) -- A BASE jumper was found dead Sunday morning in a rock quarry in Jurupa Valley, authorities said.The unidentified man's body was discovered by two hikers shortly before 7:30 a.m. on private property near Sierra Avenue and 30th Street, according to the Riverside County Sheriff's Department.The agency said the death was being investigated as suspicious, but did not immediately disclose any other details.The man is believed to have died sometime Saturday evening, a sheriff's spokesperson said.An employee of the quarry said he met the man who died the previous day after he was kicked off the site and appeared to be scouting it out for a jump.

license: Unlicense

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
# Mock Style Log Data Writer for Honeycomb.io

## Purpose:

This repo is written to be used to write data to Honeycomb.io for testing & experimentation purposes.

## How-to:

Setup the following with your keys & pertinent information. See the [Go lib] and check out the initialization section for more specifics. The specific code snippet that needs the write key looks like this.

### Step 1

```go
libhoney.Init(libhoney.Config{
  WriteKey: "77f502feb3ccfcdaa5b792ff49c872b0",
  Dataset: "honeycomb-golang-example",
})
defer libhoney.Close() // Flush any pending calls to Honeycomb
```

**NOTE:** The code is setup however to use an environment variable I've called "THRASHER_HONEYCOMBKEY". If the environment variable is set it will use that key, preventing the need to place the key inside the repository. However if you'd like, you could always just change the WriteKey out to your write key, but just be sure not to commit it back into your repository.

### Step 2

To change the number of threads writing to Honeycomb you can change the Go Routines started in this snippet of code. Just change the count, which is 10 in this example, and that many thread will kick off via Go Routines.

```go
for i := 1; i < goRoutineCount; i++ {
    go loadHoneycombData(perRoutineCount, "load_"+strconv.Itoa(i))
}
```

### Step 3

Run `go build` and then run the executable `data-writer-honeycombio`.

repository: Adron/data-writer-honeycomb

repo_name: Adron/data-writer-honeycomb


text:
# Example: task_watchdog

This test code shows how to initialize the task watchdog, add tasks to the
watchdog task list, feeding the tasks, deleting tasks from the watchdog task
list, and deinitializing the task watchdog.

### Test:

Program should run without error. Comment out "esp_task_wdt_feed()" to observe
a watchdog timeout.

repository: espressif/esp-afr-sdk

gha_language: C

repo_name: espressif/esp-afr-sdk


text:
## Example 4

This example includes both a Mapbox background vector tile layer, and an uploaded dataset converted into vector tiles with Mapbox Studio.

## Usage
1. Open the file `vektor101/example-4/example-4.html` in your browser.
2. Zoom in and out to see different features appear and disappear.
3. Open the file `example-4.html` in your text editor, and see the comments for how to change styles.

<img width="446" alt="screen shot 2017-02-01 at 16 36 12" src="https://cloud.githubusercontent.com/assets/2197944/22513465/9b020c3e-e89c-11e6-95ac-ccecc85fdfdf.png">

## How to upload your own datasets
1. Create free account on [Mapbox Studio](https://www.mapbox.com/studio/)
2. Upload a new dataset.
3. Convert your dataset to a `Tileset` and get the `tileset` ID.
4. Exchange the source in the example with your new tileset.
```javascript
 "source": {
    type: 'vector',
    url: 'mapbox://YOUR-TILESET-ID'
},
```
![upload-mapbox](https://cloud.githubusercontent.com/assets/2197944/22513901/ec719e44-e89d-11e6-8f94-db42e9731354.gif)

Then you can change style (fill, line, etc) to fit your `.geojson` data (linestring, polygon). Refresh the page, and your data should be visible. Then play around some more! :)


text:
# Support

## Support plans

dj-stripe offers paid support plans via Github Sponsors:

<https://github.com/sponsors/dj-stripe>

All issues and feature requests raised by corporate sponsors will be prioritized.
Gold Sponsors also get a dedicated developer point of contact, to help with any
questions, issues, or general inquiries relating to dj-stripe.

## Bug reports and feature requests

Please report any issues you come across
[on the Github issue tracker](https://github.com/dj-stripe/dj-stripe/issues).

Do not hesitate to leave feedback and suggestions there as well.
You may also ask usage questions on the issue tracker.

repository: dj-stripe/dj-stripe

repo_name: dj-stripe/dj-stripe


text:
# libserver
[![Build Status](https://travis-ci.org/zx1239856/libserver.svg?branch=master)](https://travis-ci.org/zx1239856/libserver) [![Build status](https://ci.appveyor.com/api/projects/status/ig4gmoo8mf317b9x?svg=true)](https://ci.appveyor.com/project/zx1239856/libserver) [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/zx1239856/libserver/blob/master/LICENSE)

A cross-platform, versatile library management system

Server side application

Tested on Ubuntu 14.04-18.04 , CentOS 7

It is recommended that you run the server on Linux to avoid weird problems.

If you have encountered any problem while using this application, see [Problem Resolutions](#problem-resolutions) below.

## 2018 Spring
**O**bject-**O**riented **P**rogramming Project
:+1::+1::+1:
See [contributors](https://github.com/zx1239856/libserver/graphs/contributors) here
:sparkles::sparkles::sparkles:**The contributors of the whole project(Server and Client) are [here](https://github.com/zx1239856/libserver/wiki/Statistics-and-Collaboration)**

Sample Server Address:
inftyloop.tech:5678
username: testuser password: testuser

## Client Side Application
See [libclient](https://github.com/lixiaojia2017/libclient) here.

## Highlights

The icing on the cake would be as follows:

+ Book search/borrow/return
+ Online PDF preview
+ Client configuration(password, server address, etc.) encrypted storage
+ Administrator management
+ Automatic Email return notification
+ Find your forgotten password through Email
+ Easy customizable Email template
+ etc...

## How to build

Make sure you have properly configured your Qt5 environment, or the project won't build.

**Requires Qt 5.8 or higher**

Also you need to install [Poppler library](https://poppler.freedesktop.org/). For Ubuntu, run the following command:

```bash
sudo apt-get install libpoppler-dev libpoppler-qt5-dev
```

For CentOS or other linux systems, you need to build the library yourself, and we provide you with a simple script to compile and install the library(Assume you have cloned our project):

```bash
cd libserver/scripts
chmod +x install_poppler_CentOS.sh
./install_poppler_CentOS.sh
```

If everything goes without error and you have successfully acquired all the libraries needed, run the following command to build the project:

```bash
git clone https://github.com/zx1239856/libserver.git
cd libserver && qmake && make
```

## Usage

The server requires MySQL as server-side database, so you need to set up a database server in advance either using the same host or some other remote host. But it is recommended that you deploy DB server locally to maximize performance and stability.

**Prepare your SQL server**

First you need to deploy MySQL server. Create a database named **libserver**, then import [libserver.sql](https://github.com/zx1239856/libserver/blob/master/sql/libserver.sql) file into this database. You can conveniently use [phpMyAdmin](https://www.phpmyadmin.net/) or other MySQL management software.

**Config File Guidance**

Before running, please create a config file (See example config file in libserver/docs/[config.conf](https://github.com/zx1239856/libserver/blob/master/docs/config.conf))

Available commands for the server:

```
Usage: ./libserver [option] <parameter>

Options:
  -i, --install              	 Install the libserver service
  -u, --uninstall            	 Uninstall the libserver service
  -s, --start <config-path>  	 Start the libserver service using the config file
  -t, --stop                 	 Stop the libserver service
  --status                   	 Show the status of libserver service
  --fake <config-path>       	 Run the libserver service in fake mode(for debugging purpose)
  -h, --help                 	 Display this help message
  --dbus-prefix <path>       	 Set the path for the installed dbus configuration file
  --initd-prefix <path>      	 Set the path for the installed init.d script
```

First you need to install the service, simply type install command, and this will create a configuration file in dbus conf path(usually /etc/dbus-1/system.d/) and an init.d bash script in /etc/init.d/

The init.d script is as follows, please replace the [configFile path] with your real configuration file path.

```bash
#!/bin/bash
### BEGIN INIT INFO
# Provides:          libserver
# Required-Start:    $local_fs $syslog dbus
# Required-Stop:     $local_fs $syslog dbus
# Default-Start:     2 3 4 5
# Default-Stop:
# Short-Description: libserver
# Description:       Library Management Server
### END INIT INFO

HELP_TEXT="Usage: $0 {start|stop|restart|uninstall|force-reload|status|help}"

case "$1" in
    start)
       [installed path]/libserver --start [configFile path]
       ;;
    stop)
       [installed path]/libserver --stop
       ;;
    force-reload) # Just fall through
       ;&
    restart)
       [installed path]/libserver --stop
       [installed path]/libserver --start [configFile path]
       ;;
    uninstall)
       [installed path]/libserver --uninstall --initd-prefix=/etc/init.d --dbus-prefix=/etc/dbus-1/system.d
       ;;
    status)
       [installed path]/libserver --status
       ;;
    help)
       echo $HELP_TEXT
       ;;
    *)
       echo "Unrecognised option. "$HELP_TEXT
esac
```

For **Ubuntu 17.10** or earlier, or any other linux system using initd to manage services other than systemd:

Now you would be able to manage the server using systemctl.

Before starting, type `systemctl daemon-reload` to flush services.

### A little reminder

For **CentOS** or **Ubuntu 18.04**, you need extra procedures:

*Step1*: Create a service file in (**CentOS**) /usr/lib/systemd/system, (**Ubuntu**) /etc/systemd/system, you may type

```bash
vim /usr/lib/systemd/system/libserver.service  ## CentOS
vim /etc/systemd/system/libserver.service  ## Ubuntu
```

The content of the service file is

```bash
[Unit]
Description=libserver - library management server side application
After=network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
ExecStart=/etc/init.d/libserver start
ExecReload=/etc/init.d/libserver restart
ExecStop=/etc/init.d/libserver stop
User=root
Group=root
Environment="LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib64:/usr/local/lib"

[Install]
WantedBy=multi-user.target
```

*Step2*:

```bash
systemctl daemon-reload
```

Now you will be able to manage the service using systemctl just as in the Ubuntu.

### Systemctl guidance

Here are commands used to manage the service through systemctl, which is a commonly used application to monitor and manage services in most Linux systems.

```bash
systemctl start libserver # Start the server
systemctl stop libserver  # Stop the server
systemctl restart libserver  # Restart the server
systemctl status libserver # Get the status of the server
systemctl enable libserver # Automatic startup the server when system boots
```

### Email Sending Customization

The server supports notifying users to return books and password reset through Email. You can choose to use either plain text Email or one equipped with HTML, which would be much more beautiful.

To customize your Email, please create a folder named **template** in the same directory as the server App. And create two HTML files, **forgetPwd.html** for password reset, **returnNotify.html** for book return notification.  The forgetPwd.html should contain **%%Newpwd** placeholder, and returnNotify.html should contain **%%Bookname** and **%%Exptime**.

You can refer to [example HTML](https://github.com/zx1239856/libserver/tree/master/template) here.

## Problem Resolutions

Here is guidance to some common problems.

**Q**: QSqlDatabase: QMYSQL driver not loaded

**A**: This problem comes from the version of libmysqlclient.so. Typically, MySQL drivers of QT support version 18 of this library. If you have versions that are not identical, the MySQL would not load.

To solve this, you need to install [RPM](https://pkgs.org/download/libmysqlclient.so.18) or [DEB](https://launchpad.net/ubuntu/xenial/amd64/libmysqlclient18/5.6.25-0ubuntu1) package, and the problem should be addressed.

**Q**: QSSLSocket unavailable on Ubuntu 18.04, resulting in the failure of email sending

**A**: Owing to the fact that the newer Ubuntu release utilizes a newer version of OpenSSL which is not compatible with SSLSocket protocol, the email sending would presumably fail. To solve this, please install the following packages:

```bash
sudo apt install libssl1.0-dev
```

## Third-party libraries or projects involved

The server is based on Qt5, and it involves these libraries/ projects as well:

[QtDaemon](https://bitbucket.org/nye/qtdaemon/overview)  Modified to support user specified log path

[Epoll eventdispatcher](https://github.com/sjinks/qt_eventdispatcher_epoll)  Epoll event dispatcher for Qt4 and Qt5

[Smtp Email](https://github.com/bluetiger9/SmtpClient-for-Qt)  Little changes to make the interface easier to utilize

[Poppler library](https://poppler.freedesktop.org/)  A library to handle PDF files, including Qt5 wrapper

## Wiki

For more information, please refer to [Wiki](https://github.com/zx1239856/libserver/wiki).


text:
# CHANGELOG

## v2.2.2

- security update to rake 13.0.6 [CVE-2020-8130]

## v2.2.0

- adds support for "balancing" requests over time

## v2.1.0

- add support to call a block when limiting takes place

## v2.0.1

- eliminate kwarg warning in ruby 2.7 (while still supporting 2.6)

## v2.0.0

- end support for ruby 2.3/2.4/2.5
- test on ruby 2.6/2.7/3.0 (using ruby 2.7 for development)

## v1.1.0

- using Process.clock_gettime(Process::CLOCK_MONOTONIC) instead of Time.now for improved accuracy

## v1.0.2

- DOCFIX: fix name of gem in README
- BUGFIX: add ruby-limiter.rb so that it works better with bundler

## v1.0.1

- BUGFIX: support arguments for throttled methods

## v1.0.0

- initial release

repository: Shopify/limiter

repo_name: Shopify/limiter


text:
---
layout: 'layouts/home.html'
title: 'Home'
meta:
  desc:
    '11st-Starter-Kit is a minimal starting point for building static websites
    with 11ty, powered by Snowpack with Tailwind CSS and Alpine.js.'
intro:
  title: 'Welcome to Your Eleventy App'
  desc:
    'For a guide and recipes on how to configure / customize this project, check
    out the Eleventy and Snowpack documentation.'
---

## Community

[Eleventy](https://www.11ty.dev/news/discord/) -
[Snowpack](https://discord.com/invite/snowpack) - [Tailwind
CSS](https://tailwindcss.com/discord) - [Alpine.js](https://discord.gg/CGmj5nq)

## Awesome

[Eleventy](https://github.com/scottishstoater/awesome-eleventy) -
[Snowpack](https://github.com/rajasegar/awesome-snowpack) - [Tailwind
CSS](https://github.com/aniftyco/awesome-tailwindcss) -
[Alpine.js](https://github.com/alpine-collective/awesome)

## Ecosystem

[Eleventy](https://www.11ty.dev/) - [Snowpack](https://www.snowpack.dev/) -
[Tailwind CSS](https://tailwindcss.com/) - [Alpine.js](https://github.com/alpinejs/alpine/)


text:
---
title: Python Calculator
layout: post
author: ethan.roche
permalink: /PythonCalculator/
source-id: 1j0RWkBxJQvvrUbge3USIVB48Igv3WAYXIyfJhAV5YIA
published: true
---

    Title
    Making a Calculator
    Date
    08/01/18

    Starting point:
    Knowing a bit about python from year 8 and previous year 9 lessons.

    Target for this lesson?
    To apply my past knowledge of python to my work in this lesson.

    Did I reach my target?
    Yes, but I was struggling to complete the tasks to begin with.

    Lesson Review

    This lesson, we were looking at the worksheets that we have been working on and we attempted to make our own calculator on python. I completed it by using the instruction. It starts off by asking for a number and then another number. Once it has these two numbers, it then asks you to choose one of the four options: add, subtract, multiply and divide. Once you have chosen that, it tells you the answer to the first number add, subtract, divide, or times by the second number. Here is my work:

def add(num1,num2):
    answer = num1 + num2
    return answer

def subtract(num1,num2):
    answer = num1 - num2
    return answer

def divide(num1,num2):
    answer = num1 / num2
    return answer

def multiply(num1,num2):
    answer = num1 * num2
    return answer

first = int(input("Enter your first number: "))
second = int(input("Enter your second number: "))

print("Choose an option: (1) Add, (2) Subtract, (3) Divide, (4) Multiply")
choice= int(input())

if choice == 1:
    answer = add(first,second)

elif choice == 2:
  answer = subtract(first,second)

elif choice == 3:
  answer = divide(first,second)

elif choice == 4:
  answer = multiply(first,second)

print("The answer is",answer)

    What limited my learning? Which habits do I need to work on?

    I found it difficult to work out the coding, but I think a bit more practising will help.

    What will I change for next time? How will I improve my learning?

    I did well.


text:
[![Build status](https://johnwatson484.visualstudio.com/John%20D%20Watson/_apis/build/status/Sugar%20Free%20Diet)](https://johnwatson484.visualstudio.com/John%20D%20Watson/_build/latest?definitionId=12)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=johnwatson484_sugar-free-diet&metric=alert_status)](https://sonarcloud.io/dashboard?id=johnwatson484_sugar-free-diet)

# Sugar Free Diet

Create and publish recipes.

## Prerequisites

Visual Studio
SQL Server
.Net Framework

## License

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

gha_language: C#


text:
[![View Storybook][view-storybook-image]][view-storybook-url]
[![Join Discord][join-discord-image]][join-discord-url]
[![NPM version][npm-version-image]][npm-url]
[![NPM downloads][npm-downloads-image]][npm-downloads-url]
[![MIT License][license-image]][license-url]
[![Storybook][storybook-action-image]][storybook-action-url]
[![NPM Publish][npm-publish-action-image]][npm-publish-action-url]

# React Navigations

View Storybook at: https://master--618170a92697cd003a33e813.chromatic.com

### Where to write components?

1. There is a `src` folder where you can write your components
2. Whichever components you want to be exposed would go into: `index.js`

## Workflow

There are two ways you can develop components.

### Storybook

- Run: `yarn storybook` which will run the storybook in your localhost
- When you write your own component, also write a `.stories.jsx` and storybook would pick it up

### Another ReactJS App

- Create a brand new react js app (Ex: my-app) using following: https://reactjs.org/docs/create-a-new-react-app.html#create-react-app
- Run `yarn link` in current component library. Ex: If you component name is react-alerts, you would run yarn link inside react-alerts
- Go to newly created reactjs app (my-app) and run `yarn link @reusejs/react-alerts`
- At the same time also run `yarn serve` in react-alerts, so that as you make changes, build happens simultaneously and your my-app refreshes it

## Contributing

### New components

Hit us on discord on `ideas` channel. Propose your ideas, we will blow our brains out.

### To existing components

Right now we don't a lot of hard and fast rules.

Just follow: https://www.atlassian.com/git/tutorials/comparing-workflows/forking-workflow

Basically:

- Fork the component to which you want to contribute
- Make your changes, test it properly
- Raise a Pull Request

## Releases

Once your pull request is made, a release would be schedule which will push the library to npm to @reusejs org. You can't push to reusejs org.

 ## License

react-alerts is freely distributable under the terms of the [MIT license][license-url].

[license-image]: https://img.shields.io/badge/license-MIT-blue.svg?style=flat
[license-url]: LICENSE

[npm-url]: https://npmjs.org/package/@reusejs/react-alerts
[npm-version-image]: https://img.shields.io/npm/v/@reusejs/react-alerts.svg?style=flat

[npm-downloads-image]: https://img.shields.io/npm/dm/@reusejs/react-alerts.svg?style=flat
[npm-downloads-url]: https://npmcharts.com/compare/@reusejs/react-alerts?minimal=true

[view-storybook-image]: https://img.shields.io/badge/View-Storybook-F59E0B.svg
[view-storybook-url]: https://master--618170a92697cd003a33e813.chromatic.com

[join-discord-image]: https://img.shields.io/badge/Join-Discord-7389D8.svg
[join-discord-url]: https://discord.gg/VUa9SHvvDb

[storybook-action-image]: https://github.com/reusejs/react-alerts/actions/workflows/chromatic.yml/badge.svg
[storybook-action-url]: https://github.com/reusejs/react-alerts/actions/workflows/chromatic.yml

[npm-publish-action-image]: https://github.com/reusejs/react-alerts/actions/workflows/publish.yml/badge.svg
[npm-publish-action-url]: https://github.com/reusejs/react-alerts/actions/workflows/publish.yml

repository: reusejs/react-alerts

repo_name: reusejs/react-alerts


text:
## Virtual Environment
It is strongly recommended to use a Python virtual environment. To create a virtual env, use the `venv` feature of python3.
Run the command below in the root project directory. Recommended folder name for the virtual environment is `env`.
```
python3 -m venv <env-folder-name>
```

To activate that virtual environment, use the below command:
```
source <env-folder-name>/bin/activate
```
You may want to create an alias for this if you do a lot of Python work.

After activating, to install the dependencies run
```
pip install -r requirements.txt
```

repository: graysonpike/markdown-boilerplate

repo_name: graysonpike/markdown-boilerplate


text:
In order to not repeat the same information coming from multiple nodes, we have a filter added to some metrics like so:

chia_network_space{job="NODE1"}

where NODE1 is the job_name attribute configured in prometheus.yml. You can put in the name of any node, what matters is that we only get one value instead of 2 or 3.

Open the dashboard file you want to use "dashboardv2_dual_node_xxxxx.json" and search/replace NODE1 by the name of one of your jobs.


text:
# Audio System

## Overview

AGL uses the PipeWire daemon service to provide audio playback and capture
capabilities. PipeWire is accompanied by a secondary service, WirePlumber
(also referred to as the *session manager*), which provides policy management,
device discovery, configuration and more.

Applications can connect to the PipeWire service through its UNIX socket, by
using the *libpipewire* library as a front-end to that socket.

## Configuration

Currently in AGL Happy Halibut (8.0.0) there are limited configuration options
for the PipeWire audio stack. In a future release it is expected that a new
configuration mechanism will be available, with more flexibility,
comprehensibility and options.

### wireplumber.conf

The most useful configuration options for the audio stack can be found
in **/etc/wireplumber/wireplumber.conf**.

Through this file it is possible to configure:

* The default playback and capture devices:
```
  "default-playback-device": <"hw:0,0">,
  "default-capture-device": <"hw:0,0">,
```

You may change these lines to reflect the configuration of your board. The ALSA
device strings that you use there **must** start with *hw:* and **must** use
exactly 2 integer numbers, one for the device and one for the subdevice. Other
strings are not understood as of the time of writing of this document.

* The streams that are available for applications to use:
```
load-module C libwireplumber-module-mixer {
  "streams": <["Master", "Multimedia", "Navigation", "Communication", "Emergency"]>
}
...
load-module C libwireplumber-module-pw-alsa-udev {
  "streams": <["Multimedia", "Navigation", "Communication", "Emergency"]>
}
```

You may modify these arrays to include the streams that you would like to be
available on your system. These strings are matched against the strings that
the applications declare as their *role*.

*Note*: the *Master* stream on the mixer is a special stream that enables the
master volume control. Removing it will remove the ability to have a master
volume and may break applications that expect it to be available. This stream
should not be listed in the configuration for *libwireplumber-module-pw-alsa-udev*

*Note*: the stream names should be aligned everywhere they appear in this
configuration file. Listing different streams in different places may result in
undefined behaviour.

* The priorities of the roles:
```
  "role-priorities": <{
    "Multimedia": 1,
    "Communication": 5,
    "Navigation": 8,
    "Emergency": 10
  }>
```

A stream with a higher priority will always take over the audio output, pausing
any other lower priority streams in the meantime.

Currently there is no way of configuring other policy options.

### pipewire.conf

PipeWire also ships with **/etc/pipewire/pipewire.conf**, which can be used to
configure which pipewire modules are being loaded in the PipeWire deamon. You
should normally not need to modify anything there, unless you understand what
you are doing.

## APIs

### Native API - libpipewire

The main entry point for applications to access the audio system is the API
offered by *libpipewire*. The functionality offered by *libpipewire* is vast
and it is beyond the scope of this document to describe it all.

For playback and capture, applications should use *struct pw_stream* and its
associated methods. There are usage examples for it in the PipeWire
[source code](https://github.com/PipeWire/pipewire).

### Native API - GStreamer (Recommended)

For convenience, applications that use GStreamer can use the PipeWire GStreamer
elements to plug the functionality offered by *struct pw_stream* directly in
the GStreamer pipeline. These elements are called *pwaudiosrc* and *pwaudiosink*

Example:
```
gst-launch-1.0 audiotestsrc ! pwaudiosink
```

Through these elements, it is possible to specify the application role by setting
it in the *stream-properties* property of the element, as shown below:

```
gst-launch-1.0 audiotestsrc ! pwaudiosink stream-properties=p,media.role=Multimedia
```

or, in the C API:

```
gst_util_set_object_arg (sink, "stream-properties", "p,media.role=Multimedia");
```

When using these GStreamer elements, applications **should** handle the
**GST_MESSAGE_REQUEST_STATE** message on the bus and change their state accordingly.
This message will be sent when the *session manager* requests a change in the state
due to a higher priority stream taking over.

### ALSA Compatibility

AGL offers a virtual ALSA device that redirects audio to PipeWire
through an ALSA PCM plugin. This device is the default one, so unless you
explicitly specify a device in your ALSA client application, audio will go
through PipeWire instead.

This mode has limitations, however.
* There is no way to specify the role of the application. WirePlumber will
always assume it is a "Multimedia" application
* There is no way for the application to be notified when another stream
takes over. When this happens, the audio clock will simply stop progressing and
the ALSA API will likely block.

### Audiomixer service

See the separate audiomixer service documentation.

## Runtime mechanics

The PipeWire service is activated on demand, via systemd socket activation.
The WirePlumber service is always started and stopped together with the PipeWire
service.

If you wish to manually start/stop/restart the service, you can do so by using
*systemctl*:
```
systemctl start/stop/restart<EMAIL_ADDRESS>```

## Debugging

When something is wrong with the audio setup, it is useful to know how to debug
it...

### PipeWire & WirePlumber

The PipeWire and WirePlumber daemons can be configured to be more verbose
by editing **/etc/pipewire/environment**

* Set G_MESSAGES_DEBUG=all to enable WirePlumber's debug output.
* Set PIPEWIRE_DEBUG=n (n=1-5) to enable PipeWire's debug output.

All messages will be available in the systemd journal, inspectable with
journalctl.

### AGL applications & services (AppFW)

For AGL applications and services that are installed by the app framework,
you can set the *PIPEWIRE_DEBUG* environment variable in **/etc/afm/unit.env.d/pipewire**.
This will enable the debug messages that are printed by *libpipewire* and will
make them available also in the systemd journal.

repository: ftab/docs-sources

repo_name: ftab/docs-sources


text:
# pyfolio
Collection of functions to check the performances of portfolio and portfolio back testing

# installation

Please install this package with the following command:
```shell
pip install git+https://github.com/jianboli/pyfolio
```
# dependence
numpy, pandas, tia

At the same time, this package heavily rely on Bloomberg. So you will need local Bloomberg open and API service aviable to use most of the functionailities.

repository: jianboli/pyfolio

repo_name: jianboli/pyfolio


text:
SparseMultiDim
==
## Description
A MATLAB script for sparse representation using multidimensional mixed-norm penalty

## Usage
Run main.m

## References
- [N. Murata, S. Koyama, N. Takamune, and H. Saruwatari, "Sparse Representation Using Multidimensional Mixed-Norm Panlty With Application to Sound Field Decomposition," *IEEE Trans. Signal Process.*, 2018.](https://doi.org/10.1109/TSP.2018.2830318)


text:
# dotnet-nosln [![Build Status](https://travis-ci.org/eiriktsarpalis/nosln.svg?branch=master)](https://travis-ci.org/eiriktsarpalis/nosln) [![NuGet](https://img.shields.io/nuget/vpre/dotnet-nosln.svg)](https://www.nuget.org/packages/dotnet-nosln/) [![license](https://img.shields.io/github/license/eiriktsarpalis/nosln.svg)](License.md)

dotnet-nosln is a cli tool that generates solution files.
Designed to minimize the awkwardness of solution files,
nosln treats them as disposable, auto-generated entities deriving from the file system.

To install the tool simply type (dotnet sdk >= 2.1 required)
```
$ dotnet tool install -g dotnet-nosln
```

Then simply navigate to your favorite repo and type
```
$ dotnet nosln --start
```
This will will automatically generate a solution file based on the folder structure in your current directory,
then immediately start Visual Studio using that particular solution file.

It will also include any solution items that happen to exist in the particular folder hierarchy, respecting any `.gitignore` files that happen to exist in the repo.

Running
```
$ dotnet nosln -TF -I '**/*Tests*' -o tests.sln
```
will create a solution file containing test projects only.

## Building & Installing

To install nosln on your machine, just clone the repo and run
```
make install
```
GNU make is required.

## More arguments

Full list of all nosln command line arguments:
```
USAGE: dotnet nosln [--help] [--version] [--output <solution file>] [--include-projects <pattern>]
                    [--exclude-projects <pattern>] [--include-files <pattern>] [--exclude-files <pattern>]
                    [--no-git-ignore] [--no-files] [--no-transitive-projects] [--absolute-paths] [--flatten]
                    [--start] [--quiet] [--temp] [--debug] [<path>]

PATH:

    <path>                Base directory or project file used for populating the solution file. All projects and
                          files within the directory will be added to the solution. Defaults to the current
                          directory.

OPTIONS:

    --version             Display the version string and exit.
    --output, -o <solution file>
                          Output solution file. Defaults to a solution file at the root of the supplied base
                          directory.
    --include-projects, -I <pattern>
                          Included project files globbing pattern. Multiple arguments are treated using OR semantics.
    --exclude-projects, -E <pattern>
                          Excluded project files globbing pattern. Multiple arguments are treated using OR semantics.
    --include-files, -i <pattern>
                          Included solution files globbing pattern. Multiple arguments are treated using OR
                          semantics.
    --exclude-files, -e <pattern>
                          Excluded solution files globbing pattern. Multiple arguments are treated using OR
                          semantics.
    --no-git-ignore, -G   Do not take .gitignore files into account when excluding files.
    --no-files, -F        Do not include any solution items in the generated solution.
    --no-transitive-projects, -T
                          By default, nosln will include transitive p2p dependencies, even if excluded by a globbing
                          pattern or outside of the project directory.Enable this flag to avoid expanding to
                          transitive projects.
    --absolute-paths, -a  Use absolute paths in generated solution file. Otherwise contents will be relative to the
                          solution file output folder.
    --flatten, -f         Places all projects at the root of the solution file without replicating the filesystem
                          structure. Also implies --no-files.
    --start, -s           Starts an IDE process with the newly generated solution file. Uses 'start' command on
                          Windows, 'open' on OSX, 'xdg-open' on Linux.
    --quiet, -q           Quiet mode, only output the file name of the generated solution to stdout. Useful for
                          passing generated solution to shell scripts.
    --temp, -t            Creates a disposable solution file in the system temp folder. Overrides the --output
                          argument. Also implies --absolute-paths.
    --debug, -D           Generate debug logs. Overrides --quiet mode.
    --help                display this list of options.
```

repository: eiriktsarpalis/nosln

gha_language: F#

repo_name: eiriktsarpalis/nosln