text:
# 云服务

## free

### 虚拟主机
::: tip Desc
由于是免费的原因，不同的平台可能会有不同的限制，大家可以自己比对着看
:::
* [byet.host](https://byet.host/)https://byet.host/

* [freewha](https://freewha.com/)https://freewha.com/

* [freehosting](https://www.freehosting.com/)(https://www.freehosting.com/)

* [freehostingnoads](https://freehostingnoads.net/)https://freehostingnoads.net/

* [awardspace](https://www.awardspace.com/free-hosting/)https://www.awardspace.com/free-hosting/

* [accuwebhosting  wordpress-hosting]()https://www.accuwebhosting.com/web-hosting/free-wordpress-hosting

* [x10hosting](https://x10hosting.com/)https://x10hosting.com/

* [byet.host](https://byet.host/free-hosting)https://byet.host/free-hosting

* [infinityfree](https://infinityfree.net/)https://infinityfree.net/

* [000webhost](https://www.000webhost.com/)https://www.000webhost.com/

* [wpnode wordpress-hosting](https://wpnode.net/free-wordpress-hosting/)https://wpnode.net/free-wordpress-hosting/

repository: huskyAreYouScared/blog

repo_name: huskyAreYouScared/blog


text:
# Machine Learning Models

Cognitive Class course that contains differents machine learning models to implement in **Python**.

## 1. Regression

- Simple linear regression.
- Multiple linear regression.
- Non-linear regression.

## 2. Classification

- K-Nearest neighbors.
- Decision trees.
- Logistic regression.
- Support vector machines.

## 3. Clustering

- K-Means clustering.
- Hierarchical clustering.
- Density-based clustering.

## 4. Recommender Systems

- Content-based.
- Collaborative filtering.

license: MIT

repository: stivenramireza/machine-learning-models

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: stivenramireza/machine-learning-models


text:
# Chrome Mailinator Omnibox
Chrome Omnibox extension allows the user to open a mailinator inbox right from the address bar in chrome.

# Usage
## Omnibox
The intended usage of this is to use the chrome omnibox. Navigate to the chrome omnibox (address bar) by clicking on it
or pressing CMD+L or CTRL+L.

After typing mail and pressing the spacebar, type the name of any mailinator inbox you wish.

## Persistance
Every time you navigate to an inbox, the inbox name is stored to your chrome sync data. This means it will be available on every chrome installation you have
provided that sync is turned on. Otherwise the saved inboxes will save to the local storage of your chrome browser.

The extension will save the last 20 mailboxes accessed.

You can access your recent inboxes by clicking on the extension icon in the chrome toolbar.

# Development
## Build
To build the extension from deployment, run:
```sh
./build.sh
```

To clean the repository from build artifacts, run:
```
./clean.sh
```

## Versioning
When adding a new version, make sure to update manifest.json and build.sh with appropriate version numbers.

repository: wcchristian/chrome-mailinator-omnibox

repo_name: wcchristian/chrome-mailinator-omnibox


text:
= Stripe Scala bindings

== Installation
The current release is distributed for <b>Scala 2.11.0 or later</b>. Add +stripe-scala+ as a dependency in sbt or Maven:

== Run the test suite

Set API_KEY environment variable to your stripe test secret key before running tests.

== Documentation
=== Example

    import com.stripe
    stripe.apiKey = "sSs57dBsUSkxo3lQPsNKNDX5H0RAcYsj"
    val charge = stripe.Charge.create(Map(
      "amount" -> 100,
      "currency" -> "usd",
      "card" -> Map("number" -> "4242424242424242", "exp_month" -> 3, "exp_year" -> 2015)
    ))

See https://stripe.com/api for the most up-to-date documentation.

repository: adamkuipers/stripe-scala

extension: markdown

repo_name: adamkuipers/stripe-scala


text:
# depypi
A Tool for deploying Python packages to PyPI with multiple user support and a Pythonic API

depypi allows registration and upload of packages to Pypi and PypiTest.
It can also check availability of packages on Pypi and PypiTest.
It also generate ~/.pypirc on the fly to allow usage of alternate credentials

## Usage

```shell
depypi --help
Usage: depypi [OPTIONS] COMMAND [ARGS]...

  Upload, register and query packages on pypi and pypitest

Options:
  --help  Show this message and exit.

Commands:
  isonpypi  Check if package exists on pypi
  register  register package to pypi
  upload    upload package to pypi
```

Example:

This will register and verify successful registration of a package to pypitest:
```shell
depypi register -t -p cloudify-cli/
```

This will check if this version has been uploaded to pypitest:
```shell
depypi isonpypi -t -p cloudify-cli/
```

This will upload a version to Pypi:
```shell
depypi upload -f -p cloudify-cli/
```

This will upload a version to Pypi with specific credentials:
```shell
depypi upload -f -p cloudify-cli/ -c USER PASSWORD
```

This will upload a version to PypiTest:
```shell
depypi upload -t -c heathenasparagus zaAQ1QAaz
INFO - running sdist
running egg_info
writing requirements to depypi.egg-info/requires.txt
writing depypi.egg-info/PKG-INFO
writing top-level names to depypi.egg-info/top_level.txt
writing dependency_links to depypi.egg-info/dependency_links.txt
writing entry points to depypi.egg-info/entry_points.txt
reading manifest file 'depypi.egg-info/SOURCES.txt'
writing manifest file 'depypi.egg-info/SOURCES.txt'
running check
creating depypi-0.0.1
creating depypi-0.0.1/depypi
master
creating depypi-0.0.1/depypi.egg-info
making hard links in depypi-0.0.1...
hard linking README.rst -> depypi-0.0.1
hard linking setup.py -> depypi-0.0.1
hard linking depypi/__init__.py -> depypi-0.0.1/depypi
hard linking depypi/depypi.py -> depypi-0.0.1/depypi
hard linking depypi/dictconfig.py -> depypi-0.0.1/depypi
hard linking depypi/logger.py -> depypi-0.0.1/depypi
hard linking depypi.egg-info/PKG-INFO -> depypi-0.0.1/depypi.egg-info
hard linking depypi.egg-info/SOURCES.txt -> depypi-0.0.1/depypi.egg-info
hard linking depypi.egg-info/dependency_links.txt -> depypi-0.0.1/depypi.egg-info
hard linking depypi.egg-info/entry_points.txt -> depypi-0.0.1/depypi.egg-info
hard linking depypi.egg-info/requires.txt -> depypi-0.0.1/depypi.egg-info
hard linking depypi.egg-info/top_level.txt -> depypi-0.0.1/depypi.egg-info
Writing depypi-0.0.1/setup.cfg
Creating tar archive
removing 'depypi-0.0.1' (and everything under it)
running upload
Submitting dist/depypi-0.0.1.tar.gz to https://testpypi.python.org/pypi
Server response (200): OK

WARNING - The upload operation was completed successfully but verification has failed
```
Occasionally there will be delay and verification will fall through. Afterwards we can check:
```shell
depypi isonpypi -t
INFO - package depypi of version 0.0.1 is available on testpypi
```

## Logic

upload and register operation have no default target and require a flag (either test or force) to run

isonpypi defaults to checking pypi and if called with --test flag with check pypitest instead

If ~/.pypirc already exists it will be backed up and restored after an operation should you use the credentials flag.

repository: cloudify-cosmo/depypi

gha_language: Python

repo_name: cloudify-cosmo/depypi


text:
Welcome to the v4.3.2 release of Sealos!🎉🎉!

## Changelog
### Other work
* 3d1cbf6cdd1bdbac912d6aa079557723620e49b7: feature(main): using 22 default port (#3759) (#3760) (@sealos-ci-robot)

**Full Changelog**: https://github.com/labring/sealos/compare/v4.3.1...v4.3.2

See [the CHANGELOG](https://github.com/labring/sealos/blob/main/CHANGELOG/CHANGELOG.md) for more details.

Your patronage towards Sealos is greatly appreciated 🎉🎉.

If you encounter any problems during its usage, please create an issue in the [GitHub repository](https://github.com/labring/sealos), we're committed to resolving your problem as soon as possible.

repository: cuisongliu/sealos

branch_name: refs/heads/main

gha_language: Go

repo_name: cuisongliu/sealos


text:
# The Human Cell Atlas: Overview of Metadata Structure

## Table of Contents
- [Introduction](#introduction)
- [Structure overview](#structure-overview)
- [Specifying JSON schemas](#specifying-json-schemas)

## Introduction

This document describes the structure of the HCA metadata standard as implemented and utilized by the Data Coordination Platform (DCP). More detailed specification of the format and syntax of the metadata schemas and their instantiation can be found in the [metadata schema structure specification](https://docs.google.com/document/d/1pxQj7BfM8HHgD4ilm4dlvZuZATfJkNC5s_-TUoA4lYA/edit?ts=59b16455) on Google Drive.

**What is in this document?**
 - High-level [overview of the schema structure](#structure-overview)
 - Description of [schema URL structure](#specifying-schema-urls)

**Who should be reading this document?**
 - Data contributors
 - Data consumers
 - Members of external projects seeking alignment with HCA metadata standards

**What *isn't* in this document?**
 - The set of [principles](rationale.md#design-choices) specifically guiding the schema structure design

## Structure overview

### Motivation

The primary motivations for the HCA metadata entity model are to:

1. Handle transitions between biomaterial and file entities
1. Enable independent versioning of schemas representing different entities
1. Support modeling of future sample and experiment types easily and without needing to drastically alter the current entity model

### Entities

There are five major entities supported by the HCA metadata standard: Projects, Biomaterials (samples), Protocols, Processes, and Files.

![Entities](images/entities.jpg)

The entities are arranged in units that represent different parts of an experiment. For example, the diagram below is an abstract illustration of an input *biomaterial* (*e.g.*, a tissue sample) undergoing a *process* (*e.g.*, dissociation) to produce another *biomaterial* (*e.g.*, a sample of dissociated cells). The *process* that was executed followed a specific *protocol* - or intended plan - to produce the output *biomaterial*.

![Entities](images/unit_of_hierarcy.jpg)

The metadata entity model supports units that can have one or more biomaterials or files as inputs or outputs. If the input is a biomaterial entity and the output is a file entity, the unit represents an assay. If both the input and output entities are files, the unit represents an analysis. This flexible model allows for the possibility of modeling synthetic biology experiments - for example a file is used as an input to produce a custom biomaterial - in the future.

![Entities](images/unit_scenarios.jpg)

Below is an example single cell sequencing experiment modeled using the HCA metadata entity model.

![Entities](images/project_scenario.jpg)

### Metadata field organisation

- *Core entities* = Very stable, high-level entities that are referenced by *Type* entities. Core entities contain fields that apply to and are inherited by all corresponding *Type* entities.
- *Type entities* = Entities that are a specific instance of a *Core* entity. Type entities contain fields specific to that *Type* and inherit core fields from the corresponding *Core* entity.
- *Module entities* = Small, flexible entities that are extensions of an existing *Type* entity. Module entities contain extra fields related to a *Type* but that are domain- or user-specific.

Each project, biomaterial, protocol, process, and file entity is represented by a Type schema. Each Type schema inherits a Core entity and zero or more Module entities.

### User-supplied versus ingest-supplied metadata fields

Most metadata fields in Core, Type, and Module schemas are provided by data generators via metadata spreadsheets. A subset of metadata fields in the standard, however, are not provided by data generators, but rather are provided by the Ingestion Service component of the DCP. These fields are referred to as "ingest-supplied" fields, and include the following:

- `provenance` field in all Type schemas
- `describedBy`, `schema_version`, `schema_type` fields in all schemas
- all fields in `links.json` and `provenance.json` schemas

The ingest-supplied fields contain information about the metadata submission (*e.g.* when metadata was uploaded to the DCP) and about the metadata schema being used. Data generators will never submit values to these fields directly, and they do not appear in the metadata spreadsheet.

In addition to ingest-supplied metadata fields, the `ontology` and `ontology_label` fields present in all ontology schemas will not be supplied by data generators in many cases. Data generators who choose to submit programmatically using their own JSON files might choose to supply values for these fields, and therefore the fields are not strictly ingest-supplied.

### Recording the standard

The metadata standard is stored as a series of individual schemas which represent the entities and fields associated with them (*e.g.*, `project.json`, `biomaterial_core.json`, `sequencing_protocol.json`). The schemas are stored in a single versioned control GitHub repository alongside documentation about the schema, the meaning of their content, and the update process. Anyone is able to propose changes to the schema through GitHub pull requests and issues. Only a specific list of committers will be allowed to approve pull requests and release new versions of the metadata schemas.

## Specifying JSON schemas

### Self-describing metadata schemas

Each JSON metadata schema is self-describing using the `$id` field with a URL to the location of that specific version of the schema.

In the `donor_organism.json` schema, the `$id` field looks like:

    {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "$id": "https://schema.humancellatlas.org/type/biomaterial/10.1.1/donor_organism",
        ...
    }

### Metadata documents

Each metadata document for a Type entity requires a property - `describedBy` - that explicitly records the URI of the metadata schema which represents it.

In the `donor_organism.json` schema, the `describedBy` field is specified as:

    "describedBy": {
        "description": "The URL reference to the schema.",
        "type": "string",
        "pattern": "^(http|https)://schema.(.*?)humancellatlas.org/type/biomaterial/(([0-9]{1,}.[0-9]{1,}.[0-9]{1,})|([a-zA-Z]*?))/donor_organism"
    }

In a metadata document representing a Donor organism entity, the `describedBy` field is expressed as:

    {
        "describedBy": "http://schema.staging.data.humancellatlas.org/type/biomaterial/10.1.1/donor_organism",
        ...
    }

### Schema URI structure

The structure of metadata schema URIs follows the convention:

`http://schema.humancellatlas.org/{primary_directory}/{secondary/directory/structure}/{version}/{unqualified_schema_name}`

where

- `{primary_directory}` is one of [`core`, `type`, `module`]
- `{secondary/directory/structure}` describes the path to the schema, *e.g.* `biomaterial`, `process/sequencing`
- `{version}` is the version number of the schema, *e.g.* `10.1.1`
- `{unqualified_schema_name}` is the unqualified name of the schema, *e.g.* `donor_organism`

Some example URIs include:

```
http://schema.humancellatlas.org/core/biomaterial/5.0.1/biomaterial_core
http://schema.humancellatlas.org/type/biomaterial/5.0.0/cell_line
http://schema.humancellatlas.org/type/protocol/sequencing/5.0.0/library_preparation_protocol
http://schema.humancellatlas.org/module/ontology/5.0.0/cell_type_ontology
http://schema.humancellatlas.org/module/process/sequencing/5.2.0/barcode
```

repository: ShalekLab/alexandria-metadata-schema

repo_name: ShalekLab/alexandria-metadata-schema


text:
# Part 4 - AutoML

In this part of the Advanced Course we'll explore the options of the AutoML utility of MLApp.

As of now, MLApp supports automatic search for the best model from a variety of estimator families:

- classification
- clustering
- linear
- non linear

These functions are highly configurable, such as choosing the parameters for each model, hyper-parameters, scoring function, cross validation and more.

It is recommended to go through the documentation as there is thorough explanation on each configuration option.

> Note: these functions also support non-sklearn models as long as they support the interface of the sklearn models (functions such as `fit`, `predict`, etc.)
>
> Example models from other libraries that can also be used: XGBoost, LightGBM.

In this part of the Advanced Topics, we'll see how we use a neural network model with MLApp's AutoML, which is not included in the default models provided by MLApp.

## 2. Prerequisites - Crash Course Asset

Install the crash course with the MLApp's CLI **boilerplates** command in the root of your project and rename it to `mlp_classifier`:
```bash
mlapp boilerplates install crash_course --new-name mlp_classifier
```

Run a train Pipeline via `run.py` and see it has no errors:
```json
{
    "asset_name": "mlp_classifier",
    "config_path": "assets/mlp_classifier/configs/mlp_classifier_train_config.json",
    "config_name": "mlp_classifier_config"
}
```

## 3. MLPClassifier

We'll be using the neural network model provided by sklearn: [MLPClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html).

Let's update the Model Manager of the MLP Classifier `assets > mlp_classifier > mlp_classifier_model_manager.py`:

## 4. Scaler

First we need to scale our data for the neural network model to fit properly.

Add import of the scaler and pandas library:
```python
from sklearn.preprocessing import MinMaxScaler
import pandas as pd
```

In the `train_model` Pipeline function add the following between the prepare data for train and the run auto ml:
```python
@pipeline
def train_model(self, data):
    # prepare data for train
    ...

    # fit scaler
    scaler = MinMaxScaler()
    scaler.fit(X_train)
    self.save_object('scaler', scaler)

    # run auto ml
    ...
    ...
    ...
```

We are saving the scaler object so when using the forecast pipeline we can use the same transformation of scaling on new data. In order to do so we'll need to add this code to the `forecast` Pipeline function:

```python
# use scaler
scaler = self.get_object('scaler')
data = pd.DataFrame(scaler.transform(data), columns=data.columns, index=data.index)

# transform X_train and X_test
X_train_scaled = pd.DataFrame(scaler.transform(X_train), columns=X.columns, index=X_train.index)
X_test_scaled = pd.DataFrame(scaler.transform(X_test), columns=X.columns, index=X_test.index)
```

## 5. AutoML - AutoMLPandas

Add import of the neural network:
```python
from sklearn.neural_network import MLPClassifier
```

Now in order to use the **MLPClassifier** in the AutoMLPandas lets update the arguments this way:
```python
# run auto ml
result = AutoMLPandas(
    'multi_class', models=["NN"], model_classes={"NN": MLPClassifier},
    fixed_params={
        "NN": {
            "solver": "lbfgs",
            "max_iter": 5000
        }
    },
    hyper_params={
        "NN": {
            "alpha": [0.1, 1],
            "hidden_layer_sizes": [(16, 32), (32, 64), (64, 128)]
        }
    }).run(X_train_scaled, y_train, X_test_scaled, y_test)
```

!!! note "AutoML Utility"

    for explanation on each key in the `AutoMLPandas` check the [AutoML API Reference](/api/utils.automl).

## 6. Investigate results

We have sent a few hyper-parameters, lets use the AutoMLResult to view the full results to see which ones were chosen:

Update the following now with `full=True`:
```python
result.print_report(full=True)
```

The Pipeline function of `train_model` in `assets > mlp_classifier > mlp_classifier_model_manager.py` should look like this:
```python
@pipeline
def train_model(self, data):
    # prepare data for train
    X, y = data.drop(self.model_settings['target'], axis=1), data[self.model_settings['target']]
    X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=self.model_settings.get('train_percent'))

    # fit scaler
    scaler = MinMaxScaler()
    scaler.fit(X_train)
    self.save_object('scaler', scaler)

    # transform X_train and X_test
    X_train_scaled = pd.DataFrame(scaler.transform(X_train), columns=X.columns, index=X_train.index)
    X_test_scaled = pd.DataFrame(scaler.transform(X_test), columns=X.columns, index=X_test.index)

    # run auto ml
    result = AutoMLPandas(
        'multi_class', models=["NN"], model_classes={"NN": MLPClassifier},
        fixed_params={
            "NN": {
                "solver": "lbfgs",
                "max_iter": 5000
            }
        },
        hyper_params={
            "NN": {
                "alpha": [0.1, 1],
                "hidden_layer_sizes": [(16, 32), (32, 64), (64, 128)]
            }
        }).run(X_train_scaled, y_train, X_test_scaled, y_test)

    # print report
    result.print_report(full=True)

    # save results
    self.save_automl_result(result)
```

## 7. Run the model
Run a train Pipeline via `run.py` and see which hyper-parameters were chosen and compare the results with the previous results you got:
```json
{
    "asset_name": "crash_course",
    "config_path": "assets/crash_course/configs/crash_course_train_config.json",
    "config_name": "crash_course_config"
}
```

!!! note "Configuration-Based Assets"

    Remember, it is highly recommended to expose the fixed params and hyper params of the neural network model to the configuration for easy customization on production/cloud environment.

repository: ghas-results/mlapp

repo_name: ghas-results/mlapp


text:
# Airy.Identity.Nhibernate #

[![Build status](https://ci.appveyor.com/api/projects/status/xt2v610omjxosig6/branch/master?svg=true&passingText=master%20-%20passing&failingText=master%20-%20failing&pendingText=master%20-%20pending)](https://ci.appveyor.com/project/MatthewRudolph/airy/branch/master)
[![Build status](https://ci.appveyor.com/api/projects/status/xt2v610omjxosig6/branch/dev?svg=true&passingText=dev%20-%20passing&failingText=dev%20-%20failing&pendingText=dev%20-%20pending)](https://ci.appveyor.com/project/MatthewRudolph/airy/branch/dev)

## About ##
NHibenrate implementation of the provider for ASP.Net Identity that can easily be used to replace the default Entity Framework provider.

## Features ##
* Drop-in replacement for ASP.Net Identity Entity Framework (v2.2.1) backing store that ships with ASP.Net MVC 5.
* By default matches the database design used by the Microsoft.AspNet.Identity.EntityFramework provider.
* Supports the use of types other than strings for primary keys such as Guids or integers.
* Supports additional properties on the User, Role, Login and Claim classes if required.
* Fully implements all of the UserStore and RoleStore interfaces.
* Sample ASP.Net MVC 5 projects.

## Getting Started ##
These instructions assume you know how to set up NHibernate within an MVC application.
They are based on the default VS2013 ASP.Net MVC 5 project with Individual User Accounts authentication type.

* Uninstall the Entity Framework version of ASP.Net Identity and Entity Framework.
  ```Powershell
  Uninstall-Package Microsoft.AspNet.Identity.EntityFramework
  Uninstall-Package EntityFramework
  ```

* Install the Airy Identity Nhibernate package.
  ```Powershell
  Install-Package Dematt.Airy.Identity.Nhibernate
  ```

* Replace the contents of the ~/Models/IdentityModels.cs file with the following.
  These classes match the default classes and schema of the Microsoft.AspNet.Identity.EntityFramework implementation.
  ```C#
  using System;
  using System.Security.Claims;
  using System.Threading.Tasks;
  using Dematt.Airy.Identity;
  using Dematt.Airy.Identity.Nhibernate;
  using Microsoft.AspNet.Identity;
  using NHibernate;

  namespace Dematt.Airy.Sample.WebSite.Models
  {
      // You can add profile data for the user by adding more properties to your ApplicationUser class, please visit http://go.microsoft.com/fwlink/?LinkID=317594 to learn more.
      /// <summary>
      /// The user class.
      /// </summary>
      public class ApplicationUser : IdentityUser<string, ApplicationLogin, ApplicationRole, string, ApplicationClaim>
      {
          public ApplicationUser()
          {
              Id = Guid.NewGuid().ToString();
          }

          /// <summary>
          /// This is only required if you are using the Visual Studio ASP.Net MVC template.
          /// If you are using a dependency injection framework then you can simply inject the user manager class where it is needed instead.
          /// </summary>
          public virtual async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
          {
              // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
              var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
              // Add custom user claims here
              return userIdentity;
          }
      }

      /// <summary>
      /// The role class.
      /// </summary>
      public class ApplicationRole : IdentityRole<ApplicationUser, string>
      {
          public ApplicationRole()
          {
              Id = Guid.NewGuid().ToString();
          }

          public ApplicationRole(string roleName)
              : this()
          {
             Name = roleName;
          }
      }

      /// <summary>
      /// The login class.
      /// </summary>
      public class ApplicationLogin : IdentityUserLogin<ApplicationUser>
      {

      }

      /// <summary>
      /// The claim class.
      /// </summary>
      public class ApplicationClaim : IdentityUserClaim<ApplicationUser, int>
      {

      }

      /// <summary>
      /// The user store class.
      /// </summary>
      public class ApplicationUserStore<TUser> : UserStore<ApplicationUser, string, ApplicationLogin, ApplicationRole, string, ApplicationClaim, int>,
          IUserStore<ApplicationUser>
          where TUser : ApplicationUser
      {
          public ApplicationUserStore(ISession context)
              : base(context)
          {
          }
      }

      /// <summary>
      /// The role store class.
      /// </summary>
      public class ApplicationRoleStore<TRole> : RoleStore<ApplicationRole, string, ApplicationUser>
          where TRole : ApplicationRole, new()
      {
          public ApplicationRoleStore(ISession context)
              : base(context)
          {
          }
      }
  }
  ```
*Note:*
  The library allows you to use your own primary key types for users, roles and claims, this means that you need to create those classes.
  The base classes in the Dematt.Airy.Identity namespace have all the required functionality your classes just need to inherit from them and provide the key types.

  The above classes use the default primary key type of string for the User and Role entities and int for the Claim entity, the string primary keys will be populated with a random Guid, the int one will be a assigned by the database.
  This matches the default configuration and schema of the Entity Framework version, and should be compatible with existing databases created using the Entity Framework version.

* In the ~App_Start/IdentityConfig.cs find the following line in the public static ApplicationUserManager Create method:
  ```C#
  var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(context.Get<ApplicationDbContext>()));
  ```
  and replace with this line:
  ```C#
  var manager = new ApplicationUserManager(new ApplicationUserStore<ApplicationUser>(context.Get<ISession>()));
  ```

* Configure Nhibernate mappings.
    * NHibernate
  ```C#
  private ISessionFactory GetSessionFactory()
  {
      var configuration = new Configuration();
      configuration.Configure(HostingEnvironment.MapPath("~/Nhibernate.config"));
      var mappingHelper = new MappingHelper<ApplicationUser, string, ApplicationLogin, ApplicationRole, string, ApplicationClaim, int>();
      configuration.AddMapping(mappingHelper.GetMappingsToMatchEfIdentity());
      return configuration.BuildSessionFactory();
  }
  ```
    * FluentNHibernate
  ```C#
  private ISessionFactory GetSessionFactory()
  {
      var mappingHelper = new MappingHelper<ApplicationUser, string, ApplicationLogin, ApplicationRole, string, ApplicationClaim, int>();
      var configuration = Fluently.Configure()
         .Database(/*.....*/)
         .ExposeConfiguration(cfg => {
             cfg.AddMapping(mappingHelper.GetMappingsToMatchEfIdentity());
          });
      return configuration.BuildSessionFactory();
  }
  ```

  Then in the ~App_Start/Startup.Auth.cs file remove the following line:
  ```C#
  app.CreatePerOwinContext(ApplicationDbContext.Create);
  ```
  and add these lines:
  ```C#
  var sessionFactory = GetSessionFactory()
  app.CreatePerOwinContext(sessionFactory.OpenSession);
  ```

* If you are using a IoC container and dependency injection then when building your Nhibernate configuration before calling BuildSessionFactory you just need to add the Identity mappings like so:
  ```C#
  var mappingHelper = new MappingHelper<ApplicationUser, string, ApplicationLogin, ApplicationRole, string, ApplicationClaim, int>();
  configuration.AddMapping(mappingHelper.GetMappingsToMatchEfIdentity());
  ```

## Using different primary key types ##
If you require a different primary key type for User, Role and Claim then you can replace the generic types in the above classes as required.
Example classes using Guid for all primary keys can be found [here](https://github.com/MatthewRudolph/Airy-Identity-Nhibernate/blob/dev/samples/Dematt.Airy.Sample.WebSite/Models/GuidIdentityModels.cs)
Example classes using int for all primary keys can be found [here](https://github.com/MatthewRudolph/Airy-Identity-Nhibernate/blob/dev/samples/Dematt.Airy.Sample.IntWebSite/Models/IntIdentityModels.cs)

This article https://www.asp.net/identity/overview/extensibility/change-primary-key-for-users-in-aspnet-identity details the other changes that will be necessary to your configuration if you change the Id type of the Identity entities.
There are sample websites for both all Guid and all int primary keys in the samples folder of the solution. They are a default (VS2013) MVC web application project with the minimum changes made to support each of the primary key types.

## Customising the Identity Mappings ##
You can customise the Identity mappings before adding them to the configuration like so:
```C#
// Get customise and add the identity mappings.
var identityMappingHelper = new MappingHelper<GuidApplicationUser, Guid, GuidApplicationLogin, GuidApplicationRole, Guid, GuidApplicationClaim, Guid>();
identityMappingHelper.Mapper.Class<GuidApplicationUser>(c =>
{
    c.ManyToOne(p => p.HomeAddress, m =>
    {
        m.NotNullable(false);
        m.Cascade(Cascade.None);
    });

    c.Property(p => p.DisplayName, m =>
    {
        m.Length(50);
    });
});
configuration.AddMapping(identityMappingHelper.GetMappingsToMatchEfIdentity());
```

## Acknowledgements ##
There is already an excellent official [NHibernate Implementation] (https://github.com/nhibernate/NHibernate.AspNet.Identity) of the ASP.Net Identity.
However it does not currently allow the use of types other than strings for primary keys [Issue 46] (https://github.com/nhibernate/NHibernate.AspNet.Identity/issues/46)
As I needed to be able to use Guids for some primary keys I forked it and started to see how I could implement it.

It was a lot harder than I thought especially since I'm not an NHibernate Guru.  I found that I needed to take a different approach to the current implementation and decided it would be easier to do if I started from scratch with a new solution.
I leant heavily on both the existing [official NHibernate Implementation] (https://github.com/nhibernate/NHibernate.AspNet.Identity) and also the [Microsoft Entity Framework Implementation] (https://aspnetidentity.codeplex.com/)
So a huge thank you to those authors particularly https://github.com/milesibastos for their work and for open sourcing it, without them I would never had been able to complete this, my first open source project.

repository: MatthewRudolph/Airy-Identity-Nhibernate

repo_name: MatthewRudolph/Airy-Identity-Nhibernate


text:
---
layout: page
title: Common Elderberry
---

Large clusters of fragrant, white flowers appear in spring and are followed by clusters of dark purple to black, berries in late summer to fall. Fruit can be harvested for making elderberry wine and jam, or left on the plant to provide seasonal forage for wildlife. Grow it as a shrub, or cut it back each year and use it as a bold perennial. Tons of appeal! Deciduous. Edible fruit. Easy Care. North American Native Selection. Bird Friendly.

          Size

120.0" W X 120.0" H

          Type

Deciduous

          Flower Color

White

          Foliage Color

Dark Green

          Lighting

Full sun

    Discover More Plants Like This

repository: LastZactionHero/bloom-landing

repo_name: LastZactionHero/bloom-landing


text:
# DynamoDB Local Admin

This project builds a Docker image with [DynamoDB Local][dbd] and
[dynamodb-admin][dbd-admin] installed and hooked up.

[dbd]: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html
[dbd-admin]: https://github.com/aaronshaf/dynamodb-admin

## Usage

```
docker pull instructure/dynamo-local-admin
docker run -p 8000:8000 -it --rm instructure/dynamo-local-admin
```

Now open http://localhost:8000/ in your browser, and you'll see the admin UI.
You can also hit port 8000 with Dynamo API requests:

```
AWS_ACCESS_KEY_ID=key AWS_SECRET_ACCESS_KEY=secret aws --region us-east-1 dynamodb --endpoint http://localhost:8000/ list-tables
```

A proxy is included which differentiates between Dynamo requests and web
requests, and proxies to the appropriate server.

## Why?

It's just very convenient if you do a lot of Dynamo development.

## Dinghy Users

If you're using Dinghy and its automatic proxy, `VIRTUAL_HOST` and
`VIRTUAL_PORT` are already set, so you don't have to specify any ports in the
`docker run` and can just open http://dynamo.docker/ in your browser.

repository: instructure/dockerfiles

gha_language: Dockerfile

gha_license_id: MIT

repo_name: instructure/dockerfiles


text:
<!--
# SPDX-FileCopyrightText: 2021-2022 Helmholtz-Zentrum Hereon
# SPDX-FileCopyrightText: 2020-2021 Helmholtz-Zentrum Geesthacht
# SPDX-License-Identifier: CC0-1.0
# SPDX-FileContributor: Carsten Lemmen<EMAIL_ADDRESS>-->
# schism-esmf
Earth System Modeling Framework (ESMF) and National Unified Operational Prediction Capability (NUOPC) caps for SCHISM

-------------------------------------------------------

# Using it

## Prerequisites

1. ESMF: You need to have ESMF installed and an environment variable
   `ESMFMKFILE` defined (via `setenv` or `export`) that points to your ESMF
   installation, for example

    on femto:
      setenv ESMFMKFILE /sciclone/home10/yinglong/esmf_femto/lib/libO/Linux.intel.64.openmpi.default/esmf.mk
      setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:/sciclone/home10/yinglong/esmf_femto/lib/libO/Linux.intel.64.openmpi.default/

    on WW:
      setenv ESMFMKFILE /sciclone/home10/yinglong/esmf_WW/lib/libO/Linux.intel.64.mvapich2.default/esmf.mk
      setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:/sciclone/home10/yinglong/esmf_WW/lib/libO/Linux.intel.64.mvapich2.default

    on James:
      setenv ESMFMKFILE /ches/home00/yinglong/esmf_James/lib/libO/Linux.intel.64.openmpi.default/esmf.mk
      setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:/ches/home00/yinglong/esmf_James/lib/libO/Linux.intel.64.openmpi.default

    on Cyclops:
      setenv ESMFMKFILE /sciclone/home10/yinglong/esmf_cyclops/lib/libO/Linux.intel.64.mvapich2.default/esmf.mk
      setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:/sciclone/home10/yinglong/esmf_cyclops/lib/libO/Linux.intel.64.mvapich2.default

2. SCHISM: You need to have SCHISM built with `cmake` and an environment
   variable `SCHISM_BUILD_DIR` defined that points to your SCHISM build
   directory containing `lib/libhydro.a`, e.g.

    on femto:
      setenv SCHISM_BUILD_DIR /sciclone/home10/yinglong/git/schism/build.femto

    on WW:
      setenv SCHISM_BUILD_DIR /sciclone/home10/yinglong/git/schism/build.whirlwind

    on James:
      setenv SCHISM_BUILD_DIR /ches/home00/yinglong/git/schism/build_james

    on Cyclops:
      setenv SCHISM_BUILD_DIR /sciclone/home10/yinglong/git/schism/build.cyclops

3. Optionally, you need PDAF:

   on WW:
      setenv PDAF_LIB_DIR /sciclone/home10/yinglong/PDAF-D_V1.14/lib/Whirlwind

   on Cyclops:
      setenv PDAF_LIB_DIR /sciclone/home10/yinglong/PDAF-D_V1.14/lib/Cyclops

## Compilation (in schism-esmf)

    make distclean    [make version older than v3.82 will spit out an error on undef cmd]
    make all

This will produce (1) the `libesmf_schism.a` `libschism_nuopc.a` library, which can be linked in
other ESMF applications that want to include SCHISM as a component.  This is
the primary application.

#Also (2) `schism_esmf_test` and (3) `concurrent_esmf_test` executables are produced
#that can be executed from any directory that contains a schism setup.  Results
#should exactly match those produced from a `pschism` uncoupled executable.

## Bugs and contributing

Please report bugs to<EMAIL_ADDRESS> You are very welcome to contribute
to improving this cap. Fork on github, make changes, and file a pull request.

---------------------------------------------------------------------------------
Joseph's notes:

repository: schism-dev/schism-esmf

gha_language: Fortran

repo_name: schism-dev/schism-esmf


text:
Name: Upgrade Time

Description: You've just upgraded your system to the latest version of Debian. Unfortunately, something in the update has broken your graphics. It's too bad you decided to `lock down' your system by disabling non-graphical logins...

How To Solve: Unzip the image. Mount the vmdk using vmware-mount. Copy the good
xorg.conf into /etc/X11/xorg.conf. Boot the machine. Edit the menus, notice that
the menu images spell out the flag.

**Note:** The main file for this challenge is not located in this repository and can be downloaded at the link below.

What to distribute:
[ctf_machine_z.tar.gz](https://drive.google.com/file/d/0B48Lv30KB1seOXRBM1dpNmVVdEE/edit?usp=sharing)

Flag: MCA-7120113D


text:
# Data Types in Javascript

## Javascript - A dynamically typed language

Javascript is what you would call a *dynamically typed language*. What that means is a variable in Javascript can hold any type of value. To draw some context, in other statically typed languages like C, C++ or Java, you are required to specify what *type* of value a variable you are creating can hold.

In C, if you want to create a variable,

```C
int a = 10;

a = 20; // This operation is allowed since 20 is a integer too.
a = 'Hello World!' // This operation will throw an error, since it's a string
```

In Javascript, there is no such requirement. The *let* keyword can be used to hold any type of value.

```javascript
let a = 10;
let b = 10.5;
let c = "Hola Amigo!";

// All valid operations! 🎉
```

## Data Types

While variables in Javascript don't have types, the values that you store in them do. What that means is the a value stored in a variable can be of the following types:

- `number` (A numeric value like `10` or `5.5`)
- `boolean` (A conditional value like `true` or `false`)
- `string` (A character or string value like `'Hey'`)
- `undefined` (An `undefined` value)
- `object` (An aggregate value of properties and values)

### number

A value of type `number` is any numeric value. There is not distinction in Javascript between integers and floating point numbers as in other languages. Whether the value is `5` or `5.5`, both are deemed to be of type `number`.

```javascript
let a = 10; // Value is of type number
a = 4.5; // Value is still of type number
```

### boolean

A value of type `boolean` can either be `true` or `false`. Boolean values are also called the logical type since its primary use is for logical operations. A boolean value is usually the outcome of a comparison operation.

```javascript
let yes = true;
let no = false;

let answer = 4 > 5;

console.log(answer); // This will print false to the console.

answer = 5 > 4;

console.log(answer); // This will print true to the console.
```

### string

A value of type `string` is any character or string of characters. There are three ways you can denote a string value

- Using single quotes, `'Hi 👋'`
- Using double quotes, `"Hi 👋"`
- Using backticks, <code>\`Hi 👋\`</code>

```javascript
let first = 'Charmander';
let second = "Charmeleon";
let third = `Charizard`;

// All valid values of type string
```

**Pro Tip** 💡: While there is no difference between single and double quotes for defining your strings, the convention is to be consistent with the type of quotes you use in your javascript code (preferable single quotes 😛). Backticks help you create something called template literals.

Let's say we need to print the first name (stored in a variable called `firstName`) and the last name (stored in a variable called `lastName`) as a single name. To concatenate two strings, we can use the `+` operator.

```javascript
let firstName = 'Tony';
let lastName = 'Stark';

console.log('My name is ' + firstname + ' ' + lastName); // This will print 'My name is Tony Stark' to the console.
```

However, with template literals, we can directly replace the variables inside the string! This type of value replacement inside strings is known as interpolation.

```javascript
let firstName = 'Tony';
let lastName = 'Stark';

console.log(`My name is ${firstName} ${lastName}`); // This will print 'My name is Tony Stark' as well!
```

### undefined

*undefined* is a rather funny value type. It denotes that the variable has not yet been assigned a value. If a variable is *declared* but not *assigned* a value, then it's value is automatically `undefined`.

```javascript
let a;

console.log(a); // This will print undefined to the console

a = 10; // Assigning a value to a

console.log(a); // a is not longer undefined
```

### Objects

Objects, objects ... objects? We'll cover this in the next section shall we? There's a lot to talk about here. 🤓

## The typeof operator

Javascript has a handy `typeof` operator that tells you what the type of value stored in a variable is.

```javascript
let a = 10;

console.log(typeof a); // this will print number to the console
```

### 🕵 Test your skills!

*Think of the answer before executing it yourself, execute it and see if you got it right! Questions marked with a* 🚀 *are slightly tricky.*

What do you think will be the output of the following?


text:
---
layout: post
title:  "Media and Multidisciplinarity"
comments: true
date:   2019-02-21 12:00:00 -0500
categories: media
---

In just over a decade, the smartphone has become the dominant channel for all types of media. Gaming, publishing, film and tv - all are enjoyed on the smartphone more than any other device. It's important to note that a _single_ device is now used to read books, watch movies, and play games.

Most of the dominant media formats were created before the smartphone was launched, but this will change. In the second decade of mobile, **multidisciplinarity across formats** will be a dominant theme.

This will happen in many ways:
- **Stories will look like a combination of film, books and games.** There will also be some formats that have never existed (AR) that will enable new dimensions of storytelling. People will _play_ more stories, not just watch or read them. The most mainstream example of this is Black Mirror: Bandersnatch on Netflix.
- **Production approaches will be shared across film, gaming, publishing and software design.** To create a story, we'll be using the pre / post production structures from film, the storyboarding approaches to creating games, and the narrative design from the world of publishing.
- **Interaction will make stories managed like software product.** We will come for the [entertainment] utility of a story, and stay for the network. Successful stories will build communities around them as a native part of the story experience (Fortnite is the most important example here).

We're building towards this future at [Wattpad](http://www.taptaptap.co) - if you're interested, we're [hiring](http://www.wattpad.com/jobs)!

repository: tarunsachdeva/blog

branch_name: refs/heads/gh-pages

gha_language: HTML

repo_name: tarunsachdeva/blog


text:
Reliable Db Provider
====================

[![Build status](https://ci.appveyor.com/api/projects/status/78vb1fn2xibjdu2y?svg=true)](https://ci.appveyor.com/project/MRCollective/reliabledbprovider)
[![NuGet downloads](https://img.shields.io/nuget/dt/ReliableDbProvider.svg)](https://www.nuget.org/packages/ReliableDbProvider)
[![NuGet version](https://img.shields.io/nuget/vpre/ReliableDbProvider.svg)](https://www.nuget.org/packages/ReliableDbProvider)

Provides a Db Provider Factory that uses the Microsoft Transient Fault Handling library to allow for reliable SQL Azure connections when using Entity Framework 4 or Entity Framework 5 Code First, Linq 2 SQL, Massive or anything based on ADO.NET (if it uses a DB provider factory).

If you are using Entity Framework 6 then you don't need this library and can instead use the [built-in transient protection](http://www.asp.net/aspnet/overview/developing-apps-with-windows-azure/building-real-world-cloud-apps-with-windows-azure/transient-fault-handling).

Note: This library does not support Entity Framework Database First [due to a limitation in Entity Framework](https://github.com/MRCollective/ReliableDbProvider/issues/4#issuecomment-31217678). If you are using Database First then we recommend you upgrade to Entity Framework and use the in-built transient protection.

Using the provider
------------------

To use the provider:

1. `Install-Package ReliableDbProvider`
2. Register the reliable providers in your `web.config` or `app.config` (this shows how to register the standard Sql Azure provider - see below for a custom implementation):

    ```xml
		  <system.data>
		    <DbProviderFactories>
		      <add name="Sql Azure Reliable Provider" invariant="ReliableDbProvider.SqlAzure" description="Reliable Db Provider for SQL Azure" type="ReliableDbProvider.SqlAzure.SqlAzureProvider, ReliableDbProvider" />
		      <add name="Sql Azure Reliable Provider With Timeout Retries" invariant="ReliableDbProvider.SqlAzureWithTimeoutRetries" description="Reliable Db Provider for SQL Azure with Timeout Retries" type="ReliableDbProvider.SqlAzureWithTimeoutRetries.SqlAzureProvider, ReliableDbProvider" />
		    </DbProviderFactories>
		  </system.data>
    ```
3. Set the provider name of your connection string to match the `invariant` of the provider:

    ```xml
		  <connectionStrings>
		    <connectionString name="Name" connectionString="ConnectionString" providerName="ReliableDbProvider.SqlAzure" />
		  </connectionStrings>
    ```
4. Use the connection string name when initialising the context (note: if you use the Azure Web Sites connection string replacement it replaces the provider name so you have to use the other approach about to be mentioned) or pass into the context a connection created using the provider, e.g.:

    ```c#
		var connection = ReliableDbProvider.SqlAzure.SqlAzureProvider.Instance.CreateConnection();
		connection.ConnectionString = ConfigurationManager.ConnectionStrings["Name"].ConnectionString;
    ```
5. If you would like to perform an action when a retry occurs then you can using:

    ```c#
		ReliableDbProvider.SqlAzure.SqlAzureProvider.CommandRetry += (sender, args) => ...;
		ReliableDbProvider.SqlAzure.SqlAzureProvider.ConnectionRetry += (sender, args) => ...;
    ```

Retrying for timeouts
---------------------

It's possible for Timeout exceptions to be both a [transient error caused by Azure and a legitimate timeout caused by unoptimised queries](http://social.msdn.microsoft.com/Forums/en-US/ssdsgetstarted/thread/7a50985d-92c2-472f-9464-a6591efec4b3/) so we've included a transient error detection strategy that detects these timeout exceptions as a transient error and retries. To use it simply change your provider from `ReliableDbProvider.SqlAzure.SqlAzureProvider` to `ReliableDbProvider.SqlAzureWithTimeoutRetries.SqlAzureProvider` (provider name from `ReliableDbProvider.SqlAzure` to `ReliableDbProvider.SqlAzureWithTimeoutRetries`).

There are a few things to note:

* We recommend you try the `ReliableDbProvider.SqlAzure` provider first and then add the one that detects timeouts as transient errors only after you experience timeout errors that you are sure are caused by SQL Azure and not your code
* If the timeout happened in the first place it means that the user's request has already taken a long time so applying a retry policy to that query will make it take even longer (and if the retries also timeout then the page request might even time out (for a web application)).
* If you want visibility of retries then see the above instruction for hooking into the retry events

Creating your own custom reliable provider
------------------------------------------

If you want to customise the transient error detection strategy, the retry strategies or other aspects then you can create your own provider.

1. Extend `ReliableSqlClientProvider`, e.g.:

    ```c#
		    public class MyReliableProvider : ReliableSqlClientProvider<ATransientErrorDetectionStrategy>
		    {
		        public static readonly MyReliableProvider Instance = new MyReliableProvider();

		        public static event EventHandler<RetryingEventArgs> CommandRetry;
		        public static event EventHandler<RetryingEventArgs> ConnectionRetry;

		        protected override RetryStrategy GetCommandRetryStrategy()
		        {
		            return /* command retry strategy, e.g. ReliableDbProvider.SqlAzure.RetryStrategies.DefaultCommandStrategy */;
		        }

		        protected override RetryStrategy GetConnectionRetryStrategy()
		        {
		            return /* connection retry strategy, e.g. ReliableDbProvider.SqlAzure.RetryStrategies.DefaultConnectionStrategy */;
		        }

		        protected override DbConnection GetConnection(ReliableSqlConnection connection)
		        {
		            connection.CommandRetryPolicy.Retrying += CommandRetry;
		            connection.ConnectionRetryPolicy.Retrying += ConnectionRetry;
		            return new MyReliableConnection(connection);
		        }
		    }
    ```
2. Extend `ReliableSqlDbConnection`; specifying the Db Provider you created as the factory, e.g.:

    ```c#
		    public class MyReliableConnection : ReliableSqlDbConnection
		    {
		        public MyReliableConnection(ReliableSqlConnection connection) : base(connection) { }
		        protected override DbProviderFactory GetProviderFactory()
		        {
		            return MyReliableProvider.Instance;
		        }
		    }
    ```

3. Add the provider to your `web.config`/`app.config`, e.g.:

    ```xml
		  <system.data>
		    <DbProviderFactories>
		      <add name="My Reliable Provider" invariant="MyAssemblyBaseNamespace.MyReliableProviderNamespace" description="Reliable Db Provider for something..." type="MyAssemblyBaseNamespace.MyReliableProviderNamespace.MyReliableProvider, MyAssembly" />
		    </DbProviderFactories>
		  </system.data>
    ```

4. Set the provider name of your connection string to match the `invariant` of your new provider:

    ```xml
		  <connectionStrings>
		    <connectionString name="Name" connectionString="ConnectionString" providerName="MyAssemblyBaseNamespace.MyReliableProviderNamespace" />
		  </connectionStrings>
    ```

Running the tests
-----------------

If you want to contribute to this library then you need to:

1. Load the solution (allow the NuGet package restore to grab all the packages)
2. Compile the solution (.NET 4, AnyCPU)
3. Create a database on your local SQLExpress instance called `ReliableDbProviderTests` and grant the user running the NUnit runner `dbowner` access.
    * If you want to use a different database simply change the `Database` ConnectionString in `App.config`, but note: you may also need to change the service name to stop / start in `Config\DbTestBase.cs`
4. Run the `ReliableDbProvider.Tests` project with your NUnit test runner of choice
    * The user running the tests must have Administrator access on the computer so that the Windows Service for the database can be shutdown and restarted
    * Note: Your database will be taken down and brought back up repeatedly when running the tests so only run them against a development database.

repository: MRCollective/ReliableDbProvider

gha_language: C#

repo_name: MRCollective/ReliableDbProvider


text:
[![Build Status](https://magnum.travis-ci.com/BioIQ/bio_elastic.svg?token=kQGGz9poYoJcrTodVFy3&branch=master)](https://magnum.travis-ci.com/BioIQ/bio_elastic)

# BioElastic

Interface for creating documents in BioIQ's elasticsearch document store

## Installation

Add this line to your application's Gemfile:

    gem 'bio_elastic'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install bio_elastic

## Usage

TODO: Write usage instructions here

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request


text:
# PokeFlip

**Live:** https://pokeflip.github.io/ClientSide/

**Team Members:** Grace Provost, Richard Livingston, Jack Lomax

**Pitch:** A pokemon memory game. The images are taken from the pokeApi. This will be a single page app for desktop. Pages will include a pokemon type gameboard selector, gameboard, endgame, about, and leaderboard.

**Models:**

GameBoard:
  - startgame
    - Append cards to gameboard.
    - Set event listeners to the cards for flipping, matching, flipback
  - endgame
    - Different end game greeting depending on win or lose. Get to enter name into score system if win.
    - GET request to server. Server queries pokemon API for pokedex entries on pokemon.
    - run app.card.toHtml on each poke to append them to the page.
  - GetPokemonByType
    - Gets pokes according to type button clicked on selection page.
  - GetPokemonDexEntry
  - timer
  - score

Card:
  - flip prototype
  - match prototype
  - createCardObj
  - toHtml
    - Will fill in handlebars template
  - Card.all array to hold card objects
  - loadAll
    - GET request to server. Server queries pokemon table in PokeFlip database. SELECT poke_image FROM pokemon WHERE type=INSERT_TYPE. Then create objects of them, and push into Card.all array.

Leaderboard:
  - postScore
  - getScores

**Views:**
  - initLeaderboard
    - GET request to server. Server queries learderboard table in PokeFlip database. Have a function that counts place for each score in the table.
  - initAbout
  - initSelect
    - event listeners on each type. On click will change to initgame page.
  - initGamePage
    - runs app.gameBoard.startgame
    - event listener when all are matched or time runs out, which will send user to end game page.
  - initEndGamePage
    - runs app.gameBoard.endgame
    - event listener when name submit button is clicked which will POST score to database, then send user to leaderboard page.

 **Controllers:**
 Routes:
  - /
    - app.view.initSelect
  - /leaderboard
    - app.view.initLeaderboard
  - /about
    - app.view.initAbout

 Server Routes:
  - get to pokeAPI that gets pokemon and makes a pokemon object with type, name, dex number, and image url.
  - get to pokeAPI that gets a pokemon description and sends it back to client.
  - get to pokemon table that will send object with type, anem, dex number, and image url.
  - post to leaderboard table that will insert into name and score.
  - inserPokemon, loadLeaderboard, and loadPokemon functions.

  **Features:**
  - MPV: game with one difficulty, multiple types selector, leaderboard, meet matches
  - Stretch goals: add difficulty, gameboard colored to type

  **Databases:**
  - Leaderboard: Name VARCHAR(50), Score INTEGER
  - Pokemon: Dex_Number UNIQUE INTEGER, Name VARCHAR(25), Type VARCHAR(25), "image" VARCHAR(500)

  **Requirements**

 * **Obvious MVC/REST architecture**
    * Single-page app style
    * Clearly defined Resources in the app
    * Resource data is persisted by a database
    * Resources have well-factored and isolated M, V, C components
    * URLs use conventional REST design
 * **Good and proper use of HTML**
    * Clear, readable, and efficient structure
    * Uses semantic markup whenever possible
 * **Good and proper use of CSS**
    * Clear, readable, and efficient styles
    * Layout on various screen sizes like desktop and mobile
    * Well organized file structure.
 * **Good and proper use of JavaScript**
    * Clear, readable, and efficient code
    * Uses domain models to encapsulate data and behavior (OOP)
    * Responds to user events
    * Leverages AJAX appropriately in at least one case
    * Integrates 3rd party libraries like jQuery consistently
    * Contains no unnecessary or commented-out code
 * **Generally useful and functional**
    * Works as expected with no bugs
    * Has at least 3 interlinked "pages" with a clear navigation
    * Has at least two pages that accept and process user input
    * State is persisted between page reloads
    * Deployed live on the Internet

repository: PokeFlip/ClientSide

gha_language: JavaScript

repo_name: PokeFlip/ClientSide


text:
# How to Contribute to Botkube

We'd love your help!

Botkube is [MIT Licensed](LICENSE) and accepts contributions via GitHub pull requests. This document outlines conventions on development workflow, commit message formatting, contact points and other resources to make it easier to get your contributions accepted.

We gratefully welcome improvements to [documentation](https://docs.botkube.io/ "Go to documentation site") as well as to code.

## Contributing to documentation

Follow the [botkube-docs/CONTRIBUTING.md](https://github.com/kubeshop/botkube-docs/blob/main/CONTRIBUTING.md) file to learn how to contribute to documentation.

## Build and run Botkube from source code

This section describes how to build and run Botkube from source code.

### Prerequisite

- [Go](https://go.dev), at least 1.18
- `make`
- [Docker](https://docs.docker.com/install/)
- Kubernetes cluster, at least 1.21
- Cloned Botkube repository

   Use the following command to clone it:
   ```sh
   git clone https://github.com/kubeshop/botkube.git
   ```

### Build and install on Kubernetes

1. Build Botkube and create a new container image tagged as `ghcr.io/kubeshop/botkube:v9.99.9-dev`. Choose one option:

   - **Single target build for your local K8s cluster**

     This is ideal for running Botkube on a local cluster, e.g. using [kind](https://kind.sigs.k8s.io) or [`minikube`](https://minikube.sigs.k8s.io/docs/).

     Remember to set the `IMAGE_PLATFORM` env var to your target architecture. By default, the build targets `linux/amd64`.

     For example, the command below builds the `linux/arm64` target:

        ```sh
        IMAGE_PLATFORM=linux/arm64 make container-image-single
        docker tag ghcr.io/kubeshop/botkube:v9.99.9-dev {your_account}/botkube:v9.99.9-dev
        docker push {your_account}/botkube:v9.99.9-dev
        ```
        Where `{your_account}` is Docker hub or any other registry provider account to which you can push the image.

   - **Multi-arch target builds for any K8s cluster**

     This is ideal for running Botkube on remote clusters.

     When tagging your dev image take care to add your target image architecture as a suffix. For example, in the command below we added `-amd64` as our target architecture.

     This ensures the image will run correctly on the target K8s cluster.

     > **Note**
     > This command takes some time to run as it builds the images for multiple architectures.

     ```sh
     make container-image
     docker tag ghcr.io/kubeshop/botkube:v9.99.9-dev-amd64 {your_account}/botkube:v9.99.9-dev
     docker push {your_account}/botkube:v9.99.9-dev
     ```

     Where `{your_account}` is Docker hub or any other registry provider account to which you can push the image.

2. Install Botkube with any of communication platform configured, according to [the installation instructions](https://docs.botkube.io/installation/). During the Helm chart installation step, set the following flags:

   ```sh
   export IMAGE_REGISTRY="{imageRegistry}" # e.g. docker.io
   export IMAGE_PULL_POLICY="{pullPolicy}" # e.g. Always or IfNotPresent

   --set image.registry=${IMAGE_REGISTRY} \
   --set image.repository={your_account}/botkube \
   --set image.tag=v9.99.9-dev \
   --set image.pullPolicy=${IMAGE_PULL_POLICY}
   ```

   Check [values.yaml](./helm/botkube/values.yaml) for default options.

### Build and run locally

For faster development, you can also build and run Botkube outside K8s cluster.

1. Build Botkube local binary:

   ```sh
   # Fetch the dependencies
   go mod download
   # Build the binary
   go build ./cmd/botkube/
   ```

2. Use templates to create configuration files:

   ```sh
   cp global_config.yaml.tpl resource_config.yaml
   cp comm_config.yaml.tpl comm_config.yaml
   ```

   Edit the newly created `resource_config.yaml` and `comm_config.yaml` files to configure resource and set communication credentials.

3. Export the path to directory of `config.yaml`

   ```sh
   export BOTKUBE_CONFIG_PATHS="$(pwd)/resource_config.yaml,$(pwd)/comm_config.yaml"
   ```

4. Export the path to Kubeconfig:

   ```sh
   export BOTKUBE_SETTINGS_KUBECONFIG=/Users/$USER/.kube/config # set custom path if necessary
   ```

5. Make sure you are able to access your Kubernetes cluster:

   ```sh
   kubectl cluster-info
   ```
   ```sh
   Kubernetes master is running at https://<IP_ADDRESS>:8443
   CoreDNS is running at https://<IP_ADDRESS>:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ...
   ```

6. Run Botkube binary:

   ```sh
   ./botkube
   ```

#### Develop Botkube plugins

**Prerequisite**

- Being able to start the Botkube binary locally.
- [GoReleaser](https://goreleaser.com/install/)

**Steps**

1. Start fake plugins server to serve binaries from [`dist`](dist) folder:

   ```bash
   go run test/helpers/plugin_server.go
   ```

	 > **Note**
	 > If Botkube runs inside the k3d cluster, export the `PLUGIN_SERVER_HOST=http://host.k3d.internal` environment variable.

2. Export Botkube plugins cache directory:

   ```bash
   export BOTKUBE_PLUGINS_CACHE__DIR="/tmp/plugins"
   ```

3. In other terminal window, run:

   ```bash
   # rebuild plugins only for current GOOS and GOARCH
   make build-plugins-single &&
   # remove cached plugins
   rm -rf $BOTKUBE_PLUGINS_CACHE__DIR &&
   # start botkube to download fresh plugins
   ./botkube
   ```

   > **Note**
   > Each time you make a change to the [source](cmd/source) or [executors](cmd/executor) plugins re-run the above command.

## Making A Change

- Before making any significant changes, please [open an issue](https://github.com/kubeshop/botkube/issues). Discussing your proposed changes ahead of time will make the contribution process smooth for everyone.

- Once we've discussed your changes, and you've got your code ready, make sure that the build steps mentioned above pass. Open your pull request against the [`main`](https://github.com/kubeshop/botkube/tree/main) branch.

  To learn how to do it, follow the **Contribute** section in the [Git workflow guide](./git-workflow.md).

- To avoid build failures in CI, install [`golangci-lint`](https://golangci-lint.run/usage/install/) and run:

  ```sh
  # From project root directory
  make lint-fix
  ```
  This will run the `golangci-lint` tool to lint the Go code.

### Run the e2e tests

Here [are the details you need](./test/README.md) to set up and run the e2e tests.

### Create a Pull Request

- Make sure your pull request has [good commit messages](https://chris.beams.io/posts/git-commit/):
  - Separate subject from body with a blank line
  - Limit the subject line to 50 characters
  - Capitalize the subject line
  - Do not end the subject line with a period
  - Use the imperative mood in the subject line
  - Wrap the body at 72 characters
  - Use the body to explain _what_ and _why_ instead of _how_

- Try to squash unimportant commits and rebase your changes on to the `main` branch, this will make sure we have clean log of changes.

## Support Channels

Join the Botkube-related discussion on Slack!

Create your Slack account on [Botkube](https://join.botkube.io) workspace.

To report bug or feature, use [GitHub issues](https://github.com/kubeshop/botkube/issues/new/choose).

repository: vaibhavp/botkube

repo_name: vaibhavp/botkube


text:
# OpenHDMap
This is an open source HD map project for autonomous driving. The precision map production process is divided into four parts: **map collection, map production, map labeling, and map saving**. This project mainly uses lidar as a collection sensor to provide the map making process.

The goal is to provide a complete mapping process for autonomous driving systems and simulation.

If you have any advice, please feel free to contact us.

## Introduce
Let ’s start with how to make an HD map. The HD map making process can be divided into 4 steps.
1. Map collection
2. Map production
3. Map labeling
4. Map saving

Next we introduce these four processes respectively.
![HDmap_pipeline](docs/img/hdmap_pipeline.jpg)

#### 1. Map collection
First, we use a map collection car equipped with lidar, camera, GPS and IMU to collect maps. The data currently used is an open source dataset. We plan to provide recommended hardware and toy cars later.

You can use the collected data set or equip your own sensors to collect data.
* Collected dataset: KITTI
* Recommended equipment: todo (If you have good suggestions, welcome to recommend)

#### 2. Map production
Then, We need to generate street and building models based on the collected point cloud data. The production process is the stitching of point clouds. This process is often referred to as point cloud registration. After stitching the point clouds frame by frame, a three-dimensional model of the entire street is obtained. You scanned the whole earth with lidar. it looks really cool, right?

There are currently two methods to generate point cloud maps, one is through NDT Mapping, and the other is offline SLAM mapping. At present, we choose to use NDT Mapping. Here we refer to the implementation of autoware.

There are several SLAM mapping methods to refer to:
* LOAM
* Cartographer
* hdl_graph_slam
* blam
* A-LOAM
* LeGO-LOAM
* LIO-mapping
* interactive_slam

> We will use the above method to build the map later.

#### 3. Map labeling
After you have completed the 3D model of the map, this part of the map is called a point cloud map. To get lane line, traffic lights and traffic sign information, we also need to label the map. At present, labeling is mainly done manually. We will provide labeling tools. The labeled map is called HD map.

The two most important questions in map labels are as follows.
* **Sensor fusion** - Because the resolution of the point cloud is not high, the purpose of sensor fusion is to map the pictures of the camera to the point cloud to improve the resolution of lane lines and traffic signs.
* **Automatic labeling** - Automatic labeling capability for large-scale map production and maintenance.

At present, we adopt the method of manual annotation, and we will gradually solve the above two problems later.

#### 4. Map saving
The preservation of HD maps is divided into two parts, one is the format of the map, and the other is the layers of the map.
* Map format
The format of the map is currently opendrive. In short, the project hopes to have a unified labeling format.

- Map layers
Map is divided into 3 layers: base layer, positioning layer and dynamic layer.
    - Base layer. The basic layer is the structured information of the map generated by the above annotations, including lane lines, traffic rule information, etc.
    - Positioning layer. The positioning layer is some original point clouds that are helpful for autonomous driving positioning, such as telephone poles, traffic signs, buildings, etc.
    - Dynamic layer. The dynamic layer publishes some dynamically changing information, such as traffic conditions, traffic accidents ahead, etc.

We currently use Apollo HD map format to work with simulator to verify HD maps.

## Quick start

#### Introduction
```
.
├── docs             // documents
├── map_format_tool  // Implement map format conversion function
├── map_label_tool   // Map labeling tool
├── map_production   // Create high-precision map which use to label
```

#### 1. Map production
We use "Autoware NDT Mapping" to build a small map from open dataset. The code is reference in "core_perception/lidar_localizer/nodes/ndt_mapping" [Link](https://gitlab.com/autowarefoundation/autoware.ai/core_perception). The code is now in dir "map_production".

#### 2. Map labeling
We will soon release a map annotation tool, which will in "map_label_tool" dir.

#### 3. Map format
After labelling semantic maps, we provide multiple map formats to different open source projects like Apollo and autoware.

#### 4. End-to-end pipeline

## Examples

## Benchmark
Benchmark of the process:
* accurate
* time

## Reference
[vector tiles](https://docs.mapbox.com/vector-tiles/reference/)
[awesome-vector-tiles](https://github.com/mapbox/awesome-vector-tiles)
[paperjs](http://paperjs.org/examples/hit-testing/)
[best-javascript-drawing-libraries](https://www.slant.co/topics/28/~best-javascript-drawing-libraries)


text:
[Hippy](../README.md) › [Globals](../globals.md) › ["packages/hippy-react-web/src/components/view"](../modules/_packages_hippy_react_web_src_components_view_.md) › [View](_packages_hippy_react_web_src_components_view_.view.md)

# Class: View

The most fundamental component for building a UI, `View` is a container that supports layout
with flexbox, style, some touch handling, and accessibility controls. `View` maps directly to
the native view equivalent on whatever platform React Native is running on, whether that is
a `UIView`, `<div>`, `android.view`, etc.

View is designed to be nested inside other views and can have 0 to many children of any type.

## Hierarchy

* any

  ↳ **View**

## Index

### Constructors

* [constructor](_packages_hippy_react_web_src_components_view_.view.md#constructor)

### Methods

* [render](_packages_hippy_react_web_src_components_view_.view.md#render)

## Constructors

###  constructor

\+ **new View**(`props`: any): *[View](_packages_hippy_react_web_src_components_view_.view.md)*

*Defined in [packages/hippy-react-web/src/components/view.tsx:32](https://github.com/jeromehan/Hippy/blob/6216275/packages/hippy-react-web/src/components/view.tsx#L32)*

**Parameters:**

Name | Type |
------ | ------ |
`props` | any |

**Returns:** *[View](_packages_hippy_react_web_src_components_view_.view.md)*

## Methods

###  render

▸ **render**(): *any*

*Defined in [packages/hippy-react-web/src/components/view.tsx:38](https://github.com/jeromehan/Hippy/blob/6216275/packages/hippy-react-web/src/components/view.tsx#L38)*

**Returns:** *any*

repository: jeromehan/Hippy

repo_name: jeromehan/Hippy


text:
# Routing Examples

A collection of crates that provide examples of the Gotham web framework Router.

The `Router` dispatches `Requests` to a linked `Route` and handles error
responses when a valid `Route` is missing or an internal error state occurs.

## Ordering

We recommend reviewing our routing examples in the order shown below:

1. [Introduction](introduction) - Introduces fundamental router and router builder concepts.
1. [HTTP Verbs](http_verbs) - Shows how to route requests to handlers based on HTTP verbs.
1. [Scopes](scopes) - Combining routes under a common, nestable, root.
1. [Associations](associations) - Associate multiple handlers to a single path.

## Help

You can get help for the Gotham web framework at:

* [The Gotham web framework website](https://gotham.rs)
* [Gotham web framework API documentation](https://docs.rs/gotham/)
* [Gitter chatroom](https://gitter.im/gotham-rs/gotham)
* [Twitter](https://twitter.com/gotham_rs)

## License

Licensed under your option of:

* [MIT License](../LICENSE-MIT)
* [Apache License, Version 2.0](../LICENSE-APACHE)

## Community

The following policies guide participation in our project and our community:

* [Code of conduct](../../CODE_OF_CONDUCT.md)
* [Contributing](../../CONTRIBUTING.md)

repository: gotham-rs/gotham

gha_language: Rust

gha_license_id: NOASSERTION

repo_name: gotham-rs/gotham


text:
# s3-pre-signed-url-generator
This small utility help you generating a pre-signed GETObject URL.

# Setup:

Set AWS Environment Variables

open terminal and set following environment variables with proper values:

```
export AWS_ACCESS_KEY_ID="YOUR_ACCESS_KEY"
export AWS_SECRET_ACCESS_KEY="YOUR_SECRET_ACCESS_KEY"
export AWS_SESSION_TOKEN="YOUR_SESSION_TOKEN"
```

Once Environment variable are set, open `config/default.json` file in project and set proper config values:

```json
{
  "s3": {
    "bucket": "YOUR_S3_BUCKET",
    "key": "YOUR_OBJECT_NAME",
    "region": "YOUR_REGION",
    "expiresIn": 604800 //default 7 days
  }
}
```

after setting above values run following command to install npm packages:

```
npm install
```
once packages are successfully installed, run:

```
npm start
```
Pre-signed url will logged in console, you can copy it :)


text:
# zabberus

## It is completely dangerous - never do it!

```
(
cd /tmp &&
curl -sOL https://github.com/rjsocha/zabberus/raw/main/zabberus_1.0-3_all.deb
) &&
apt-get install /tmp/zabberus_1.0-3_all.deb
```

test:
```
zabbix_agentd -t zabberus[hello]
```

repository: rjsocha/zabberus

repo_name: rjsocha/zabberus


text:
This is the final project for CS 344. The objective here is to play with daemons, sockets, and files.

	CMakeLists.txt  -- cmake build file
	cipher_lib.c    -- cipher helper functions
	cipher_lib.h    -- ^
	compileall      -- compile script, run this to compile the programs
	keygen.c        -- this program will generate non-secure random key material
	otp_dec.c       -- decryption, this program serves as a client to the _d version
	otp_dec_d.c     -- decryption, this is the decryption server
	otp_enc.c       -- encryption, client
	otp_enc_d.c     -- encryption, server
	p4gradingscript -- bash grading script
	plaintext1      -- Test plaintext Files
	plaintext2      -- ^
	plaintext3      -- ^
	plaintext4      -- ^
	plaintext5      -- ^
	server_lib.c    -- server helper functions
	server_lib.h    -- ^

How to compile:

  ./compileall

How to run:

  ./p4gradingscript

Porgram usages:

	keygen
	USAGE: keygen keylength

	otp_dec
	Usage: otd_dec msg key [enc port #]
	otp_dec_d
	Usage: otd_dec_d [port #]

	otp_enc
	Usage: otd_enc msg key [enc port #]

	otp_enc_d
	Usage: otd_enc_d [port #]

repository: andychase/classwork

repo_name: andychase/classwork


text:
---
GENERATOR: 'Mozilla/4.05C-SGI \[en\] (X11; I; IRIX 6.5 IP32) \[Netscape\]'
Generator: 'Microsoft Word 97/98'
Template: 'Macintosh HD:Microsoft Office 98:Templates:Web Pages:Blank Web Page'
title: '\*arguments:'
---

> Description
>
>           createpts/rtz/4,6,11/0,0,0/3,45,10/1,0,1
>
> > Distribute points using the rtz cylindrical coordinate system.  This
> > results in 264 points arranged around the z- axis. There are 3 rings
> > of points at distances r=1., r=2. and r=3. from the z-axis. There
> > are11 sets of these three rings of points and heights z=0., z=1.,
> > z=2.,...,z=10. In each ring there are 6 points where each pair of
> > points is separated by 60°; note that ijz=0 requests that points be
> > placed at cell centers, hence the first point will be at 30° not at
> > 0°. Corresponding to r=0, there will be 6 identical points at 11
> > intervals along the z-axis at heights z=0., z=1., z=2.,...z=10.
> > Filter should be used to remove these duplicate points.  Note:
> > Cylinders are open but finite.  To create a closed cylinder cap both
> > ends with planes.
>
> > Arguments:
>
>
>
>   --------- --------------------------------------------------------------------------------------------------------------------------------
>   rtz       specifies cylindrical coordinates
>   4,6,11    create 4 points in the r direction, create 6 points in the t direction, create 11 points in the z direction
>   0,0,0     rmin = 0, tmin = 0, zmin = 0
>   3,45,10   radius from 0 to 3, angle in the xy-plane is 45, height along the z-axis is 10
>   1,0,1     rmins and rmaxs are used as cell vertices, tmins and tmaxs are used as cell centers, zmins and zmaxs are used as cell vertices
>
>
>   --------- --------------------------------------------------------------------------------------------------------------------------------
>
>

>       Input deck:
>
> > cmo/create/3dmesh\
> > surface/outer/reflect/cylinder/0,0,0/1,0,0/1/\
> > region/r1/ le outer /\
> > mregion/m1/ le outer /\
> > createpts/rtz/4,6,11/0,0,0/3,45,10/1,0,1/\
> > dump/gmv/gmv2\
> > finish
>
>  \
>  \
>  \
>  \
>  \
>  \
>  \
>


text:
### Before you create a PR, you must pass the following

* [ ] You have commented your change in the comment style that i use. This makes it easier for future fixes
* [ ] If this is a fix, then you have replaced the class name that was commented instead of duplicating it.
* [ ] You actually tested this.

## Fix or improvement (describe below)

repository: mischievousdev/Purplous

repo_name: mischievousdev/Purplous


text:
## pcl package template

Template for subscribing and publishing pointclouds.

## Features

* Nodelet
* Bond
* Dynamic Reconfigure

## Requirements

* A compiler supporting C++14 is required

The CATKIN_IGNORE file is included in the case the package generator
including its templates resides in the catkin workspace because
then catkin refuses to make as it finds the template which is
invalid because it contains template variables, it is not
included in the packages generated from this template.

## License

This template is licensed under the BSD-3 license.


text:
---
description: SSHing into a Docker Cloud-managed node
keywords: ssh, Cloud, node
redirect_from:
- /docker-cloud/getting-started/intermediate/ssh-into-a-node/
- /docker-cloud/tutorials/ssh-into-a-node/
- /docker-cloud/faq/how-ssh-nodes/
title: SSH into a Docker Cloud-managed node
---

You can add a public SSH key to the `authorized_keys` file in each of your Linux
nodes, so that you can log into the nodes using SSH without providing a password.

The quickest way to do this is to create the SSH keys, then run our
[dockercloud/authorizednodes](https://hub.docker.com/r/dockercloud/authorizedkeys){:target="_blank" class="_"}
utility image. Follow the instructions at that link to add the public SSH key to
each node.

Afterward, from a machine which has the private key available, you can SSH into
any of the nodes without providing a password.


text:
---
layout: post
title:  "Time Tracking"
categories: [ Jekyll ]
image: assets/images/sandclock.jpg
---
Business photo created by freepik - www.freepik.com

Defining your problem is the first step to solve it. So for this week the challenge was to track my time for a week, and it was amazing.

## What happened during the challenge

I logged my time using a mobile application you can just use a pencil and a paper. I also used a browser extension to track my time on the web. All the applications I used are in the tools section.

At the first couple of days you may miss  logging but after that it is ok. You will feel kind of supervision as the time is running so you will unconsciously focus on what matter.

## What I learned

* Have a Todo list or at least have something todo because if you don't have something to do it won't make sense to keep track of time.
* Review your log everyday and try to make insights about what could be done better

## Conclusion

Time is one of the most precious things humans have. It doesn't matter how much you give for work and how much you give for workout, Understand your capabilities and define you priorities. We are different and our skill level is different the most important thing is to make sure you are always moving towards your goal even if you are moving slower than others don't compare your self with other.

See you in a new challenge next week.

## Tools

* [aTimeLogger - Time Tracker](https://play.google.com/store/apps/details?id=com.aloggers.atimeloggerapp&hl=en)
* [Mind the Time](https://addons.mozilla.org/en-US/firefox/addon/mind-the-time/?src=search)
* [Web / Social Media / Time Tracker](https://addons.mozilla.org/en-US/firefox/addon/web-social-time-tracker/?src=search)


text:
---

## What This Repo Demonstrates

- How to use a JS config for Jest instead of a JSON file. `conf.jest.js`
  generates a JSON file for `jest` and exports a `module` for use anywhere else
  in your app.
- How to generate coverage for legacy files that were added via `document.body.innerHTML`.
- How to run legacy and ES6 code, and their tests together.
- How to shim up the `document`/`window` so that you can easily set things like
  `location`, `userAgent`, or `localStorage`.

---

## Install

```sh
npm i
```

---

## Running Tests

```sh
# Runs tests (no watch)
npm test [--] [args]
npm test -- folder.filename
# Use this to test/watch an individual file
npm run test-watch -- <args>
npm run test-watch -- folder.filename
# Use this to test/watch all files
npm run test-watch-all
```

Each test runs in it's own sandboxed environment so you don't have to worry
about code bleed-over from test to test, but that environment comes with the
added setup & teardown time for each test. Small price to pay for the assurance
that when a dev edits one test, they don't have to worry about breaking others.

Jest utilizes jsDom, so if you find that you're getting errors because it can't
access a standard `window` or `document` property, head over to
`test/_shims/document.js` and add in whatever you need.

---

## Notes About Writing Tests

- If you get `Unexpected token <` it's most likely because there's a script tag
  in your template. Just wrap your Handlebars template in
  `testCtx.unescapeScriptTags`.
- To run a single file you'd do `folder.filename` if you wanted the `FileName`
  test within the `folder` directory. Jest uses regex to match file names - if
  you use slashes for directory separators it won't work.
- If you make a change to `bootstrap.js` while watching a test file, the
  bootstrap changes won't be applied. A way around this (without having to stop
  and start) is to just add a space somewhere in your test file and save, the
  watcher will then bring in the new changes.
- When in `watch` mode, take note of the options that appear at the bottom of
  the terminal. After you've run a single test you can then run all tests
  (`a` option), and then start working on another single file if it errors out
  (`p` option).


text:
Pushlogs

        A Simple CLI tool to log workouts

### Motivation

Well, I log my workouts in my brain and as expected, I forget what my max rep was when I last worked out, so this.

### Installation

Download the [respective binary](https://github.com/barelyhuman/pushlogs/releases) for your system and create a link to it.

#### Unix (Mac and Linux)

```sh

ln -sf /path/to/binary ~/local/bin/pushlogs

```

#### Windows

Just right click and create a shortcut on the desktop and execute the shortcut when needed or run the `.exe` from powershell or cmd

### Usage

The cli is pretty simple right now and only supports a `-d` flag right now, which allows you to select a directory to save the logs to.
This defaults to the `$HOME/pushlogs` on unix systems and the `Users/<name>/pushlogs` on windows.

```sh
pushlogs
#or
pushlogs -d ./workout-logs
```

### Example Log
```
Log Time: 19-10-2020 13:10:53

Pull Ups
 - 6
 - 2
Push Ups
 - 15
 - 10

```

### Contribution

The tool is very simple at this stage and I wouldn't mind if people sent pull requests to make the code more readable or performant or even for addition of features.

repository: barelyhuman/pushlogs

repo_name: barelyhuman/pushlogs


text:
# tunnel

A configurable dockerised SSH server.

## Getting started

To get up and running the quickest way is to run the image from Docker Hub:

```
docker run --name tunnel -p 2200:22 -e USER=foobar -e AUTHORIZED_KEY="..." everydayhero/tunnel:latest
```

If you would like to build and run your own image:

* Clone this repo: `git clone git@github.com:everydayhero/tunnel.git`
* Build the image: `docker build -t tunnel tunnel`

## Options

`USER`: The username. Defaults to `tunnel`.

`PASSWORD`: The password to authenticate. Defaults to disabled.

`AUTHORIZED_KEY`: The authorized pubkey to authenticate with. Required unless `PASSWORD` provided.

`RSA_HOST_KEY`: The server's RSA private key. Default is randomly generated when launched.

`BANNER`: The banner to display when connected. Default to blank.

repository: everydayhero/tunnel

repo_name: everydayhero/tunnel


text:
# cl-plot
Plotting library for Common Lisp utilizing [gnuplot](http://www.gnuplot.info/).

Martin Kersner<EMAIL_ADDRESS>2017

1. [Info](https://github.com/martinkersner/cl-plot#info)
2. [Getting started](https://github.com/martinkersner/cl-plot#getting-started)
3. [Documentation](https://github.com/martinkersner/cl-plot#documentation)
4. [Examples](https://github.com/martinkersner/cl-plot#examples)

## Info
*cl-plot* was developed for Common Lisp Machine Learning library [cl-ml](https://github.com/martinkersner/cl-ml.git). Input data should follow rules of matrix data structure introduced in Common Lisp Mathematical library [cl-math](https://github.com/martinkersner/cl-math.git).

## Getting started
### Prerequisites
[asdf](https://gitlab.common-lisp.net/asdf/asdf) is required for initialization of *cl-plot*.

### Installation
Clone *cl-plot* repository.
```bash
git clone https://github.com/martinkersner/cl-plot.git
```
### Initialization
Before running any code from *cl-plot* library, you must initialize plotting library with following code.
```lisp
(load "init")
```
> It is expected that [asdf](https://gitlab.common-lisp.net/asdf/asdf) is already loaded when `(load "init")` is executed.

## Documentation
Generating plots with *cl-plot* can be described with five steps.

1. Create a figure
2. Set figure properties
3. Select a plot type
4. Set plot properties
5. Visualize a plot

### Create a figure
### Set figure properties
#### `xlabel` and `ylabel`
Labels (`xlabel` and `ylabel`) require instance of figure as the first parameter. The second parameter represent text to display.

##### Example
```lisp
(xlabel *fig* "x-label")
(ylabel *fig* "y-label")
```

### Select a plot type
### Set plot properties

### Visualize a plot
Plot can be either displayed (`show`) or exported to image (`save`).

#### `show`
`show` takes only one argument; figure.
After `show` command is executed, plot is displayed with gnuplot window which lets you zoom-in, zoom-out and export plot to various formats.

##### Example
```lisp
(show *fig*)
```

#### `save`
`save` takes two mandatory arguments; figure and path for generated image. If you want to modify size of generated plot, you can supply width and height as two optional arguments.

> Currently, only PNG format is supported.

##### Example
```lisp
(save *fig* "fig.png")
(save *fig* "fig2.png" 600 400)
```

## Examples
There are several more examples within *examples* directory.

Following section explains how to create a scatter plot figure, give it a title and label both x and y axes of plot. Eventually, it shows a generated plot.

### Basic example (with explanation)
First, create matrix with data to plot.
```lisp
(defparameter *dataframe*
  '((1 1)
    (2 2)
    (3 1.5)
    (4 3)
    (5 2.5)
    (6 4)))
```

Then, create a figure.
```lisp
(defparameter *fig* (make-instance 'figure))
```

Set a description of *x* and *y* labels of plot.
> `xlabel` and `ylabel` are both optional figure properties.
```lisp
(xlabel *fig* "x-label")
(ylabel *fig* "y-label")
```

Set a title of plot.
> `title` is an optional figure property.
```lisp
(title *fig* "Basic example")
```

Make figure of scatter plot type and connect it to generated data.
```lisp
(scatter *fig* *dataframe*)
```

Finally, display a plot.
```lisp
(show *fig*)
```

### Basic example (full code)
```lisp
(defparameter *dataframe*
  '((1 1)
    (2 2)
    (3 1.5)
    (4 3)
    (5 2.5)
    (6 4)))

(defparameter *fig* (make-instance 'figure))
(xlabel *fig* "x-label")
(ylabel *fig* "y-label")
(title *fig* "Basic example")

(scatter *fig* *dataframe*)

(show *fig*)
```

repository: martinkersner/cl-plot

repo_name: martinkersner/cl-plot


text:
The LazyCtrl Project
=================================
*A hybrid control plane design for large-scale cloud data centers.*

* Version: 0.21
* Authors: [Baohua Yang](mailto:baohyang@cn.ibm.com), [Kai<EMAIL_ADDRESS>* Homepage: <https://github.com/yeasy/lazyctrl>

## Download
SSH:
```
git clone git@github.com:yeasy/lazyctrl.git
```
Https:
```
git clone https://github.com/yeasy/lazyctrl.git
```

## Organization

### Central Control Modules
The directory ```ccm```  contains essential centralized control modules that are responsible for handling flow-based centralized control, as well as local control group management, for LazyCtrl.

* Central controller: Our implementation of the central controller in LazyCtrl is based on the [Floodight](http://www.projectfloodlight.org/floodlight) project, which we call ```floodlight-lc```.  We extend the basic [OpenFlow 1.0](http://archive.openflow.org/documents/openflow-spec-v1.0.0.pdf) protocol in ```floodlight-lc``` by introducing a function to support installing a new action *Encap*  for packet encapsulation and forwarding at edge switches. Besides, the central controller in LazyCtrl is only in charge of inter-group traffic flows.
* Switch grouping management: Some daemons are provided to maintain switch grouping and updating in the network, as well as providing communication channels between the central controller and local control groups.
* The grouping process is based on [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview) project (version 5.0.2) and the gpmetis binary is suggested to be compiled on your own platform.

### Local Control Modules
All the modules for local control in switch groups are contained under directory ```lcm```. Our implementation of flow switch (called ```openvswitch-lc```) is based on the [Open vSwitch](http://openvswitch.org) project and we extend Open vSwitch by implementing the *Encap* action. Besides, the *ovsd* module in ```openvswitch-lc``` will take the charge of maintaining L-FIB and G-FIB, while the *datapath* kernel module is also modified to provide essential forwarding functions.

We also implement some agent daemons at every flow switch to report its state to the central controller.

###Others
A test platform to test the performance of the grouping algorithm, workload and packet forwarding delay in LazyCtrl.

##Installation

###Basic Requirements:

* Servers supporting [OpenvSwitch](http://openvswitch.org), e.g., most Linux based servers.
* Servers supporting [Floodlight Controller](http://www.projectfloodlight.org/floodlight), e.g., most Linux based servers.
* Servers supporting [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview), e.g., most Linux based servers.
* Physical switches that support IP multi-cast.
* Server (as controller) can login into the servers (as edge switches, with at least 2 separate network interfaces) running OpenvSwtich via ssh without authorization (Need to put the public authorization key previously).

###Sample Testbed:
![ScreenShot](others/res/testbed.png)

* Three edge switch instances (in two local control groups) are connected through a physical switch (IP network), and are connected to the central controller.
    * Each edge switch has connections to two subnets: control layer subnet and the datapath layer subnet.
    * Edge switches can be installed at Linux based servers.
    * Edge switches can login to the central controller via ssh without manual authorization.
* Deploy the local control modules at every edge switches following the [Installation Documents](lcm/openvswitch-lc/INSTALL) inside.
 *  Modify the address information as necessary. For example, the default control plane IP of edge switch #1 is ```<IP_ADDRESS>```, while for edge switch #2, the IP is ```<IP_ADDRESS>```. The datapath plane IP addresses are set to ```<IP_ADDRESS>/8``` subnet.
 *  Start the agent.sh daemon at each edge switch.
* Setup the central control modules at the central controller.
    * Start floodlight-lc  in the central controller to receive PACKET_IN msg, see [Floodlight Getting Started](http://www.projectfloodlight.org/getting-started/). Run ```ant; java -jar target/floodlight.jar``` if all dependencies are already satisfied.
    * Start the collect_agent.sh daemon to collect upward statistics.
    * Start the *groupManager* daemon to update the grouping.
* Test the deployment
    * Capture IP multicast message at each edge switch, confirming that they are broadcasting the LCG location/statistics information.
    * Ping between two hosts in the same LCG, it will be handled by the G-FIB, hence no openflow message is generated and forwarded to the controller. The latency will be similar to direct transfer.
    * Ping between two hosts in different LCGs, openflow messages are generated and forwarded to the controller and the the central controller will handle it using the C-LIB. The latency would be much higher as the edge switch has to talk with the central controller. Besides, the *Encap* message will be sent to the edge switch.

## How does it work?
Basically, the ```floodlight-lc``` + ```openvswitch-lc``` cooperate as the basic control-datapath model in SDN. Based on them, we enhanced ```openvswitch-lc``` + agent to behave as local control groups, while ```floodlight-lc``` + daemons work as the central controller. More details, e.g., the group maintain algorithm and the implementation technical issues, are discussed in the paper.

##Documentation
Besides the readme files, you can easily make the API document with python/java/c doc tools. Plenty comments in the code would also be helpful.

##Support
Feel free to email to the authors. The project is planned to be community-supported soon.

##Contributing
There are still numbers of components available to optimize. For example, to build more robust message switching system.

Everyone is encouraged to download the code, examine it, modify it, and submit bug reports, bug fixes, feature requests, new features and other issues and pull requests. Thanks to everyone who has contributed to the project.

repository: yeasy/lazyctrl

gha_language: C

repo_name: yeasy/lazyctrl


text:
# Zoo Keepr

## Application Description
This is an application creating a web server for a fictional zoo to view information about animals and about zoo keepers and to add new entries to either dataset through API calls. Basic HTML and CSS were provided and modified as needed to create the application functionality.

## Tools Used
* HTML
* CSS
* JavaScript ES5 and ES6
* Node.js
* Express.js
* AJAX
* Insomnia (https://insomnia.rest/)
* Heroku (https://dashboard.heroku.com/)

## Deployed application
This application is hosted for free on Heroku at: https://polar-forest-79901.herokuapp.com/
Functionality can be tested, and new data will be retained for an indeterminate period of time.  When Heroku restarts the dyno, any new data will be lost.

## Screenshot
![screenshot](zookeepr-screenshot.png)

repository: kpehl/zookeepr

repo_name: kpehl/zookeepr