text:
[![Build Status](https://travis-ci.org/moexmen/superlogger.svg?branch=master)](https://travis-ci.org/moexmen/superlogger)
[![Gem Version](https://badge.fury.io/rb/superlogger.svg)](https://badge.fury.io/rb/superlogger)
[![Dependency Status](https://gemnasium.com/badges/github.com/moexmen/superlogger.svg)](https://gemnasium.com/github.com/moexmen/superlogger)

Superlogger - Machine-readable logging for Rails
=======

Rails' default request logging is easy to read for humans but difficult for log aggregators such as Kibana, Graylog and Splunk. Superlogger transforms the logs into JSON for easy parsing and adds useful details like Timestamp, Session ID and Request ID for tracing purposes.

Default rails logging:
```sh
Started GET "/home/index" for ::1 at 2016-04-29 17:31:12 +0800
  ActiveRecord::SchemaMigration Load (0.1ms)  SELECT "schema_migrations".* FROM "schema_migrations"
Processing by HomeController#index as HTML
  Something Load (0.1ms)  SELECT  "somethings".* FROM "somethings" WHERE "somethings"."paper" = ? AND "somethings"."stone" = ?  ORDER BY "somethings"."id" ASC LIMIT 1  [["paper", "123"], ["stone", "456"]]
  Rendered home/_partial.html.erb (0.2ms)
  Rendered home/index.html.erb within layouts/application (3.4ms)
Completed 200 OK in 135ms (Views: 130.7ms | ActiveRecord: 0.3ms)

Started GET "/assets/application.self-e80e8f2318043e8af94dddc2adad5a4f09739a8ebb323b3ab31cd71d45fd9113.css?body=1" for ::1 at 2016-04-29 17:31:12 +0800

Started GET "/assets/application.self-8f06a73c35179188914ab50e057157639fce1401c1cdca640ac9cec33746fc5b.js?body=1" for ::1 at 2016-04-29 17:31:12 +0800

```

With Superlogger:
```sh
{"level":"debug","ts":1590972589.522784,"caller":"superlogger/active_record_log_subscriber:21","sql":"SELECT \"schema_migrations\".\"version\" FROM \"schema_migrations\" ORDER BY \"schema_migrations\".\"version\" ASC","params":[],"duration":0.13}
{"level":"info","ts":1590972589.526133,"caller":"superlogger/superlogger_middleware:21","session_id":"90e90c75c72c","request_id":"34432478c89b4d8591e02e0169b40a56","method":"GET","path":"/home/index"}
{"level":"debug","ts":1590972589.546272,"caller":"superlogger/action_controller_log_subscriber:8","session_id":"90e90c75c72c","request_id":"34432478c89b4d8591e02e0169b40a56","controller":"HomeController","action":"index","params":{}}
{"level":"debug","ts":1590972589.55092,"caller":"superlogger/active_record_log_subscriber:21","session_id":"90e90c75c72c","request_id":"34432478c89b4d8591e02e0169b40a56","sql":"SELECT  \"somethings\".* FROM \"somethings\" WHERE \"somethings\".\"paper\" = ? AND \"somethings\".\"stone\" = ? ORDER BY \"somethings\".\"id\" ASC LIMIT ?","params":["123","456","1"],"duration":0.22}
{"level":"debug","ts":1590972589.574199,"caller":"superlogger/action_view_log_subscriber:6","session_id":"90e90c75c72c","request_id":"34432478c89b4d8591e02e0169b40a56","view":"_partial.html.erb","duration":0.33}
{"level":"debug","ts":1590972589.574795,"caller":"superlogger/action_view_log_subscriber:6","session_id":"90e90c75c72c","request_id":"34432478c89b4d8591e02e0169b40a56","view":"index.html.erb","duration":2.95}
{"level":"info","ts":1590972589.61165,"caller":"superlogger/action_controller_log_subscriber:20","session_id":"90e90c75c72c","request_id":"34432478c89b4d8591e02e0169b40a56","view_duration":54.59,"db_duration":0.85}
{"level":"info","ts":1590972589.611928,"caller":"superlogger/superlogger_middleware:30","session_id":"90e90c75c72c","request_id":"34432478c89b4d8591e02e0169b40a56","method":"GET","path":"/home/index","response_time":85.65,"status":200}
```

## Installation ##

Add superlogger to your application's Gemfile
```ruby
gem "superlogger"
```

Execute:
```sh
$ bundle
```

And add the following in `config/environment/production.rb`
```ruby
config.logger = Superlogger::Logger.new(STDOUT)
```

By default, Superlogger is only enabled in production environment because JSON is easy for machines to parse but difficult for humans to read. To forcefully enable Superlogger in non-production environment, set in `config/application.rb`:
```ruby
Superlogger.enabled = true
```

## Usage ##

Log as per normal using `Rails.logger`.

```ruby
Rails.logger.info foo:'true', bar: 'false'
Rails.logger.info "Meatball"
```

## Log Format ##
- `ts` = Unix Epoch timestamp
- `session_id` = Truncated to 12 characters
- `request_id` = 32 characters
- `msg` = If values given is not a hash, it is treated as `{"msg":<value>"}`
- All duration related fields are in milliseconds

repository: moexmen/superlogger

gha_language: Ruby

repo_name: moexmen/superlogger


text:
---
layout: privacy
permalink: /privacy.html
---

Privacy Policy
==============

1\. An overview of data protection
----------------------------------

### General

The following gives a simple overview of what happens to your personal information when you visit our website. Personal information is any data with which you could be personally identified. Detailed information on the subject of data protection can be found in our privacy policy found below.

The data collected on this website are processed by the website operator.

#### How do we collect your data?

Other data are collected automatically when you visit the website. These data are primarily technical data such as the browser and operating system you are using or when you accessed the page. These data are collected automatically as soon as you enter our website.

#### What do we use your data for?

Part of the data is collected to ensure the proper functioning of the website. Other data can be used to analyze how visitors use the site.

### Analytics and third-party tools

When visiting our website, statistical analyses may be made of your surfing behavior. This happens primarily using cookies and analytics. The analysis of your surfing behavior is usually anonymous, i.e. we will not be able to identify you from this data. You can object to this analysis or prevent it by not using certain tools.

2\. General information
-------------------------------------------------

### SSL or TLS encryption

This site uses SSL or TLS encryption for security reasons and for the protection of the transmission of confidential content, so that the data you transfer to us cannot be read by third parties.

3\. Data collection on our website
----------------------------------

### Cookies

Some of our web pages use cookies. Cookies do not harm your computer and do not contain any viruses. Cookies help make our website more user-friendly, efficient, and secure. Cookies are small text files that are stored on your computer and saved by your browser.

Most of the cookies we use are so-called “session cookies”. They are automatically deleted after your visit. Other cookies remain in your device's memory until you delete them. These cookies make it possible to recognize your browser when you next visit the site.

You can configure your browser to inform you about the use of cookies so that you can decide on a case-by-case basis whether to accept or reject a cookie. Alternatively, your browser can be configured to automatically accept cookies under certain conditions or to always reject them, or to automatically delete cookies when closing your browser. Disabling cookies may limit the functionality of this website.

Cookies which are necessary to allow electronic communications or to provide certain functions you wish to use (such as the shopping cart) are stored pursuant to Art. 6 paragraph 1, letter f of DSGVO. The website operator has a legitimate interest in the storage of cookies to ensure an optimized service provided free of technical errors. If other cookies (such as those used to analyze your surfing behavior) are also stored, they will be treated separately in this privacy policy.

### Server log files

The website provider automatically collects and stores information that your browser automatically transmits to us in “server log files”. These are:

*   Browser type and browser version
*   Operating system used
*   Referrer URL
*   Time of the server request
*   IP address

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Attendence Management System

This is python project to manage attendence for any orgainization.
Backend of Project is available here, Frontend will be developed in future.

# Features

1)Admin can add subject, students, professor, subjects and various departments.
2)professor can take attendence of the students of his/her subjects.
3)Attendece can be viewed in different sorted forms like professor wise, subject wise, class wise, department wise etc.

# Technologies

1)python3
2)Django Rest Framework
3)MySql database

## Installation

This application is containerized using Docker.
if you have docker-compose installed on your machine. below command will start project on your machine by hadling all the dependencies.
Run this command in root directory of project.

```bash
docker-compose up
```
if you don't have docker-compose installed on your machine. then you can start project with below process
1)install python3 dependencies using requirements.txt

```bash
pip3 install -r requirements.txt
```
2)install mysql database on your machine and provide username and password of your database in settings.py file of project

 ```bash
 DATABASES = {
        'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'databaseName',
        'USER': 'databaseUserName',
        'PASSWORD': 'databasePassword',
        'HOST': 'localhost',
        'PORT': 3306,
    }
}
```
## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.
<EMAIL_ADDRESS>
8975427620

## License
[MIT](https://choosealicense.com/licenses/mit/)


text:
# api-diff

This is a tool for comparing one json http server to another. It supports a wide variety of input formats as well as the ability to save a baseline run to compare against future runs.

This tool is probably most useful in scenarios involving search/ranking problems, where there are alogrithm and data changes over time that require manual evaluation of the wins and losses.

It also includes a script for talking to json http services with saved configurations.

## Output / Demo

### [text (console) output](https://radarlabs.github.io/api-diff/text-diff-as-html.html)

![start of text diff](https://radarlabs.github.io/api-diff/text-output-2.png)

### [html output](https://radarlabs.github.io/api-diff/diff.html)
![html diff](http://images.ctfassets.net/f2vbu16fzuly/2izT1q1tXM4UO5VmaLAcnB/f47165fe0bd1c3a01abca54d975b6938/Screen_Shot_2020-11-13_at_8.55.29_AM.png)

Note that this is an interactive evaluation form for figuring out which queries improved and which got worse. Each result is assigned an id based on the md5 hash of the query params + delta, and scores are saved to local storage. in your web browser. This means if you're doing a lot of compares, where many of the diffs are the same between runs, you won't need to re-rank them.

## tl;dr

### Try it out yourself!

This is a contrived example because our old and new servers are the same, but they return random data, so it is a good way to quickly see diffs.

## Installation

```
npm install -g @radarlabs/api-diff
```

To run any of the examples in this doc from this source tree, simply run `yarn --silent command` instead of `command`, so `yarn --silent api-diff` instead of `api-diff`

## Usage

This tool might seem like it has a zillion options, but I promise, it's not that bad!

At it's core, you need to specify two servers (old and new), and an input configuration.

## Configuration

All of the tools in this repo can load a configuration file that makes it easy to have saved defaults of servers to compare. A config file is specified via the environment variable API_DIFF_CONFIG, wth the idea that you can have multiple configs (for different services, like an api server and a geocode server) and use shell aliases to wrap the config.

The config file is specified in [hjson](https://hjson.github.io/) which allows for comments and trailing commas.

An example config looks like this
```
{
  # this will be uppercased as the prefix to api key env variables
  name: "apicom",

  # "param" or "header"
  # param means the key will be sent as a cgi param with
  #     the key authParam defined below
  # header means the key will be sent in the http
  #     Authorization header. If your server expects a header like "Bearer XXXXXXX",
  #     then set the api key to that entire string.
  authStyle: "header",

  # only required if using authStyle="param"
  # authParam: "api_key",

  # optional, if using authStyle="header"
  # authType: "Basic",

  # first keyType listed here will be the default if a
  # keyType is not specified in the commandline options to # compare
  keyTypes: ['test', 'live'],

  hosts: {
    prod: {
      host: 'https://prod.api.com',
      aliases: ['production'],
    }
    staging: {
      host: 'https://staging.api.com',
    },
    local: {
      host: 'http://localhost:8000',
      keyEnv: 'staging',
    },
    user: {
      takesArg: true,
      host: 'https://USER-staging.api.com'
      keyEnv: 'staging',
    },
  }
}
```

This defines a pretty common server setup. There is a production API at prod.api.com, that uses https (the default is http). It implicitly defines a "prod" key env in our config. There is a staging api at staging.api.com with a "staging" key env. Additionally, developers run local apis at localhost:8000, which use staging keys and should be communicated with over http (the default). Finally, each user has their own staging env at USER-staging.api.com which again uses staging keys.

### Authorization

api-diff looks in the shell environment for api keys if needed. It loads `~/.api-keys.env` into its env. For this config, that file would look like:

```
# keys are name + keyEnv + keyType + KEY
# all uppercase, joined with underscores
APICOM_PROD_TEST_KEY=XXXX
APICOM_PROD_LIVE_KEY=XXXX
APICOM_STAGING_TEST_KEY=XXXX
APICOM_STAGING_LIVE_KEY=XXXX
```

If your server requires authorization in request params, set authStyle="param" and authParam to the request parameter name the server expects. If your server uses the HTTP Authoization header, then set authStyle="header" and (optionally) authType to what auth type prefix the server expects, such as "Basic" or "Bearer" - this can be omitted if your server takes bare keys in the Authoization header.

Our config defines two types of keys - test and live. It also defines two key environments. One for "prod" and one for "staging," the host configs for "local" and "user" are both configured to look in the "staging" key env"

### Specifying a server
For compare, two servers must be specified, with --new.X and --old.X options. For the api tool, the server is specifed in the same way but without the "new/old." prefix.

Servers can be specified in two ways:

- by using host entries from our config file. So `--old.prod`, `--old.staging`, `--old.user blackmad` etc would all work based on our examples (similarly, `--new.staging`, `--new.prod`, etc)
- a combination of `--old.host` (required), `--old.key` (only if auth is needed). And similarly, `--new.host`, and `--new.key`

These can be mixed!

### Reading queries

- `--input_params` - the input file has one query per line, of the form `param1=A%20B&param2=Z`. requires `--endpoint` argument. `--method` used, defaults to GET.
- `--input_queries` - the input file has one path + params per line, like `/endpoint?param1=A%20&p2=Z`. `--method` used, defaults to GET.
- `--input_csv` - for reading csvs. Combined with `--endpoint` and `--method`
  - Assumes that the first line of the file is column headings, unless `--key_map` is used with *all numeric keys*
  - Column headings are used as parameter names
  - `--key_map` remaps column headings. `--key_map query=text` remaps the csv heading "query" to the query param "text". `--key_map 0=text 1=near` will cause the parser to assume the csv does not have named column headings (because all the keys are numbers), and will use the first column as the query param "text", the second as the query param "near"

### other options
- `--concurrency` - how many queries to run at a time per host
- `--timeout` - per query timeout, defaults to 30s
- `--unchanged` - whether or not to output unchanged queries, defaults to false
- `--ignored_fields` - fields to leave out when computing differences from server responses

### output options
- `--color` - text mode only. whether or not to colorize the output. Defaults to true if sending to stdout, false if redirecting output. Use this option to force colorized output. Suggest always using it.
- `--output_mode` - json, html or text (console output)
- `--output_file` - defaults to stdout, where to output to

repository: siranjujugi/api-diff

repo_name: siranjujugi/api-diff


text:
---
title: Parameters
index: 6
---

# Parameters

Parameters are an important aspect of Boomerang Flow, allowing for a powerful inheritance model, and can be set and represent the many different parts of the application. They are available throughout a workflow or task and are substituted at execution time.

## Parameter Syntax

You can reference parameters in a task using the `$()` syntax.

There are a number of caveats with parameters
- Must only contain alphanumeric characters, hyphens (-), and underscores (_).
- Must begin with a letter or an underscore (_).

## Parameter Availability

The following table lists the parameters and when they are available to be substitued in an execution. Additionally, Parameters have an inheritance order based on the below layering order, for example, defining a parameter with the same name at the Team and Workflow level will lead the Workflow parameter to override and replace the value for the Team parameter, unless referenced directly using scope.

The subtitution is performend by the Workflow service when a workflow is executed.

![Parameter Layering](./assets/img/Boomerang-Flow-Parameters.png)

| Parameter Scope | Available When? | Syntax | Example |
| --- | --- | --- | --- |
| Global | Throughout the workflow lifecycle. These are defined in Boomerang Flow by administrators. | `$(global.params.<parameter>)` | `$(global.params.slackChannel)` |
| Team | Throughout the workflow lifecycle. These are defined in Boomerang Flow by teams. | `$(team.params.<parameter>)` | `$(team.params.slackChannel)` |
| Workflow | Throughout the workflow lifecycle. Created and set by user through Editor Inputs | `$(workflow.params.<parameter>)` | `$(workflow.params.slackChannel)` |
| System | Specific reserved parameters available at the execution of a workflow | `$(system.params.<parameter>)` | `$(system.params.workflow-activity-id)` |
| Params | The flattened parameters with all inheritance and substitution resolved | `$(params.<parameter>)` | `$(params.slackChannel)` |
| Task Results | At completion of a task execution these parameters can be referenced by other tasks during the same workflow execution. | `$(task.<task name>.results.<parameter>)`| `$(task.My Wait For Event.results.eventPayload)` |

Whilst tasks themselves have input parameters, these are defined as part of the task template and are the only able to be referenced within the task template or by the task code itself.

## System Parameters

The following are the reserved parameters provided by Boomerang Flow

| Parameter | Syntax | Description |
| --- | --- | --- |
| task-name | `$(system.params.task-name)`
`$(params.task-name)` | This is the user specified name of the executing task. It is unique to a workflow. |
| task-id | `$(system.params.task-id)`
`$(params.task-id)` | A unique identifier for the established task in this particular workflow. |
| task-type | `$(system.params.task-type)`
`$(params.task-type)` | The categorization of a particular task. Options are `template`, `decision`, `customtask`, `approval`, `setwfproperty`, `manual`, `eventwait`, `acquirelock`, and `releaselock`. |
| workflow-id | `$(system.params.workflow-id)`
`$(params.workflow-id)` | The unique identifier for this workflow.                                          |
| workflow-name | `$(system.params.workflow-name)`
`$(params.workflow-name)` | This is the user specified name for the workflow |
| workflow-version | `$(system.params.workflow-version)`
`$(params.workflow-version)` | This is the revision or version of the workflow currently being executed. |
| workflow-activity-id | `$(system.params.workflow-activity-id)`
`$(params.workflow-activity-id)` | The unique identifier for the particular execution of the workflow. |
| workflow-activity-initiator | `$(system.params.workflow-activity-initiator)`
`$(params.workflow-activity-initiator)` | The user ID of the initiator of this activity. |
| trigger-type | `$(system.params.trigger-type)`
`$(params.trigger-type)` | The trigger that created this workflow activity or execution. |
| trigger-webhook-url | `$(system.params.trigger-webhook-url)`
`$(params.trigger-webhook-url)` | The URL including domain name and context for the webhook endpoint. Useful if you programmatically want to provide a callback URL from an endpoint triggered via your workflow. |
| trigger-wfe-url | `$(system.params.trigger-wfe-url)`
`$(params.trigger-wfe-url)` | The URL including domain name and context for the wait for event endpoint. |
| trigger-event-url | `$(system.params.trigger-event-url)`
`$(params.trigger-event-url)` | The URL including domain name and context for the event endpoint. |

### System Token Parameters

A subset of System Parameters are Tokens, which allow you to dynamically reference a token programmatically in your workflow. This can be useful if you are sending a wait for event endpoint in an email body and need to dynamically provide the token that will be used to authenticate.

| Parameter | Syntax | Description |
| --- | --- | --- |
| `<tokenlabel>` | `$(system.tokens.<tokenlabel>)` | The specific token using the token label (set at creation time) to retrieve the token. |

## Result Parameters

All tasks can have result parameters, which as mentioned above can be used by other tasks in the workflow. They are also available at the completion of a workflow via the execution status API.

### Standard Tasks

Some standard tasks will output result parameters.

### Custom Tasks

See [Custom task architecture](/boomerang-flow/architecture/overview) for more information.

As this task is a bring-your-own container, we have provided two mechanisms for setting result parameters.

| Property Type | Location                        | Description                                                                        |
| ------------ | ----------------------------- | ---------------------------------------------------------------------------------- |
| Environment Variable     | `/lifecycle/env`         | Any key value pair in the format of an environment variable can be placed in this file. At the termination of the worker, these will be turned into result parameters. |
| Files       | `/lifecycle/<file>`           | Any file in the `/lifecycle` directory at termination of the worker will be turned into a base64 encoded parameter. The key will be the filename. |

## Comparison to Tekton Parameters

Boomerang Flow parameters are very similar to what you will find in Tekton Parameters and will be familiar to some of our users.

| Tekton | Example | Boomerang Flow | Example |
| --- | --- | --- | --- |

| - | - | Global | `$(global.params.<parameter>)` or `$(params.<parameter>)` |
| - | - | Team | `$(global.params.<parameter>)` or `$(params.<parameter>)` |
| Pipeline | `$(params.<param name>)` | Workflow | `$(workflow.params.<parameter>)` or `$(params.<parameter>)` |
| Context | `$(context.pipeline.name)` | System | `$(system.params.workflow-name)` or `$(params.<parameter>)` |
| Task | `$(params.<param name>)` | Task | `$(params.<param name>)` |

Reference:
 - [Using variable substitution](https://github.com/tektoncd/pipeline/blob/master/docs/tasks.md#using-variable-substitution)
 - [Variable Substitutions Supported by Tasks and Pipelines](https://github.com/tektoncd/pipeline/blob/master/docs/variables.md)

branch_name: refs/heads/main

gha_license_id: MIT


text:
# securePassGenerator
Simple PHP tool to generate secure password

# Usage

Super Easy to get running.

- Clone repo
- Upload to server (remote or local)
- Go to folder directory from browser (e.g localhost/securePassGenerator)
- You should get password displayed on the screen

# Settings
- Go to securePassGenerator.php
- in the index function,

  generate() expects 3 parameters, total length of the password, length of upper case and length of lower case characters.

Change the figures as you like.

Ofcourse, this can be improved in many ways, if you want to improve it, please go ahead.

You can use it without setting up here: http://spg.xyluz.com

repository: xyluz/securePassGenerator

gha_language: PHP

repo_name: xyluz/securePassGenerator


text:
---
layout: page
title: Pricing
permalink: /pricing/
---

Pricing Policy

Price Range
At Griggi we have customised pricing according to the services rendered by us. The details are provided to you beforehand according to the effort, efficiency and the output of the service. Typically the range of transactions on our website varies from INR 10 to 1000.

Schedule of payment
Some of our services can be utilised for fixed durations. In such cases, it is clearly mentioned within the description of these services. The period of usage in these cases vary from 1 month to 1 year.

Price Matching
At Griggi we are committed to offering you the best possible prices. We will be glad to meet our competitor's pricing if you ever find an item that we offer, in the same color and size, available from a similar retailer.

We are unable to match prices from auction and outlet stores or websites, as well as other retailers' discount promotions, shipping offers and gift card offers.

Sale Adjustment
If an item you have purchased is reduced in price within two weeks of your order date, we will happily adjust the sale price for you. Please note that we can only make one sale adjustment per item and designer goods originally purchased on sale are excluded.

Pricing Errors
We work hard to ensure the accuracy of pricing. Despite our efforts, pricing errors may still occur. If an item's price is higher than the price displayed, we will cancel your order of that item and notify you of the cancellation.

Shopping Cart
Items in your Shopping Cart reflect the current price displayed on the item's product details page. Please note: This price may differ from the price displayed when the item was first placed in your Shopping Cart.

Our merchandise/service is offered for sale by Griggi for your personal enjoyment and not for resale. Therefore, we reserve the right to refuse to sell to any person whom we believe may be purchasing for resale.

Our Customer Service Specialists are ready to assist you—simply call<PHONE_NUMBER> 24 hours a day.

gha_language: JavaScript


text:
# Guild Wars Skill Cards

![Rust](https://github.com/regendo/guild-wars-skill-cards/workflows/Rust/badge.svg)

A tool to create playing cards for all ~1300 Guild Wars skills. Create your cards, import them into Tabletop Simulator, and draft your team build out of random draws!

## Usage

1. [Install rust.](https://www.rust-lang.org/tools/install)
2. Clone this repository.

```bash
git clone git@github.com:regendo/guild-wars-skill-cards.git
cd guild-wars-skill-cards
```

3. Compile and run the program. This may take a while—we're downloading a lot of images from the wiki and we wait between downloads to be nice. We're also doing a lot of image manipulation. However, if you need to cancel the program execution at any time, you can re-run this command to resume where you left off.

```bash
cargo run
```

4. Use the images in the `cards/decks` directory to create custom decks in Tabletop Simulator.

## Drafting

Use Tabletop Simulator's "cut" to take the desired amount of cards out of a deck, then use "split" to split that stack evenly into smaller, booster-sized stacks.

In card games like Magic the Gathering, drafting works as follows:

1. Each player opens one booster pack.
2. Each player takes ("drafts") one card from their pack, then passes the rest to the person on the left.
3. Repeat from 2. until there are no cards left in the packs.
4. Repeat from 1. until you have opened as many packs as you initially agreed on.
5. Each player builds a deck out of the drafted cards, then plays with that deck.

We can easily adapt that format to skill cards. If you draft alone, decide on a number of fake players and give each of them a booster pack (face-down). Then, whenever a fake player would draft a card, instead shuffle the face-down booster and discard one card from it. Instead of building a deck, create a team build for you and your heroes out of the drafted cards.

Use each card only once: only give Energy Surge to two of your heroes if you've actually drawn it twice. (You need to duplicate each deck if you want to draw multiple copies of cards.)

For safety reasons, remove Resurrection Signet from the card pool before drafting. Add a free Resurrection Signet to any character or hero build whenever you want.

Personally I've had a lot of fun drafting on a new character with four fake players and 10 cards per pack. I've drafted one round of one pack each when I started the game, and another round after each campaign mission I've completed.

That said, what you do with your cards is up to you. Play them however you find most fun! Create a new character under your own challenge rules or draft a lot of packs at once to fill out your exiting character's team build.

## Licenses

This program is dual-licensed under the MIT and Apache 2.0 licenses, as is recommended for rust programs.

Please note that many of the assets used to create these cards were created by other people. They are re-distributed here in accordance with their respective licenses. This program's licenses do not apply to them.

repository: regendo/guild-wars-skill-cards

gha_language: Rust

repo_name: regendo/guild-wars-skill-cards


text:
# Basic Camera Sample
## Requires
- Visual Studio 2010
## License
- MS-LPL
## Technologies
- Windows Phone 7.5
- Windows Phone 8
## Topics
- Media
- camera
## Updated
- 05/03/2013
## Description

This sample demonstrates how to activate the camera shutter and auto focus, configure picture resolution and flash settings, and use the hardware shutter button. This sample also demonstrates touch focus and a front-facing camera for the devices that support
 those features. You can develop this application step-by-step by following along with a series of topics, starting with

How to create a base camera app for Windows Phone.

You need to install Windows Phone SDK 7.1 to run this sample. To get started, go to the
Windows Phone Dev Center.

To run the sample on the device

Double-click the .sln file to open the solution.

Press F5 to start debugging the app.

When the app launches on the device, the initial page will show the camera viewfinder and the following buttons:

SH: The software shutter button. Tapping this button triggers the camera to take a picture and save it to the media library and the isolated storage container of the app.

Fl:Off: The flash selection button. Tapping this button changes the flash settings. There are up to four possible settings:
Fl:Off, Fl:On,
Fl:RER (Red Eye Reduction), and Fl:Auto.

Res: The photo resolution selection button. The selected resolution is displayed on the screen after you select it.

Change the photo settings by tapping the Fl and
Res buttons.

Take a picture by tapping the SH button. A
TextBlock on the camera viewfinder indicates the status of the saving operations to isolated storage.

After the picture has been saved, exit the app.

In the Photos Hub, find the picture that you took in the Saved Pictures folder.

Note:

This sample is packaged as a Windows Phone 7.5 project. It can be converted to a Windows Phone 8 project, by changing the target Windows Phone OS version of the project. To create a Windows Phone 8 project, you must be running the Windows Phone SDK 8.0 on
 Visual Studio 2012. You can download the latest version of the SDK from
http://dev.windowsphone.com/downloadsdk.

To convert the sample to a Windows Phone 8 project:

Double-click the .sln file to open the solution in Visual Studio.

Right-click the project in the Solution Explorer and select
Properties. This opens the Project Properties window.

In the Application tab of the Project Properties window, select
Windows Phone OS 8.0 from the Target Windows Phone OS Version dropdown. A dialog will appear asking if you want to upgrade this project to Windows Phone OS 8.0.

Select Yes to upgrade the project.

url: https://raw.githubusercontent.com/Violet26/msdn-code-gallery-microsoft/df0f5129fa839a6de8f0f7f7397a8b290c60ffbb/Official Windows Platform Sample/Basic Camera Sample/README.md


text:
---
title: IRequestCacheFactory
description: API reference for IRequestCacheFactory in Vendr, the eCommerce solution for Umbraco v8+
---
## IRequestCacheFactory

```csharp
public interface IRequestCacheFactory
```

**Namespace**
* [Vendr.Core.Cache](../)

### Methods

#### GetRequestCache

```csharp
public ICache GetRequestCache()
```

<!-- DO NOT EDIT: generated by xmldocmd for Vendr.Core.dll -->

repository: vendrhub/vendr-documentation

gha_language: Batchfile

repo_name: vendrhub/vendr-documentation


text:
Node.js saucectl Wrapper ![build](https://github.com/saucelabs/node-saucectl/workflows/saucectl%20pipeline/badge.svg)
========================

Node.js wrapper for saucectl: Sauce Labs Testrunner Toolkit.

## Install

To install `saucectl` using NPM just run:

```sh
$ npm i -g saucectl
```

In case you need to download `saucectl` from a known source or in case you use `npx saucectl` you can use environment variable:

```
export SAUCECTL_INSTALL_BINARY=http://localhost:9000/saucectl_0.32.2_mac_64-bit.tar.gz
```

The command should be globally available:

```sh
$ saucectl -v
saucectl version 0.4.0
(build 7468a24c788b4ca4d67d50372c839edf03e5df6a)
```

__Note:__ if you run the command for the first time it will initially download the binary for you. This only happens once.

---

For more information to `saucectl`, visit its main repository: [saucelabs/saucectl](https://github.com/saucelabs/saucectl).

repository: shrutika-cypress/cypress-practise

repo_name: shrutika-cypress/cypress-practise


text:
# Remote Training Tool

## About

The Remote Training Tool app is a simple tool designed to assist with facilitating a remote training class. Currently, it consists solely of a series of preset timers to display when learners should expect to be done with activities or when to return from a break. [Check out the wiki for more info](https://github.com/DTHutton/training-timer/wiki).

## Developer Info

| Site | Link |
|:---|:---|
| GitHub | [DTHutton](https://github.com/DTHutton) |
| Twitter | [@DTHutton91](https://twitter.com/DTHutton91) |
| Email | [kered.nottuh<EMAIL_ADDRESS>|

Special thanks to Wes Bos ([GitHub](https://github.com/wesbos), [Twitter](https://twitter.com/wesbos)) and his [Javascript30](https://github.com/wesbos/JavaScript30) course.

repository: DTHutton/remote-training-tool

gha_language: CSS

repo_name: DTHutton/remote-training-tool


text:
# Generate a Gantt Chart

Now you have described your [work plan](workplan.md) in a YAML or JSON
file.

You can now generate a Gantt chart as an SVG file using the command:

```shell-session
$ rpp gantt -p workplan.yml -o gantt.svg
```

Provided you also have a description of the team, you can enter:

```shell-session
$ rpp gantt -p workplan.yaml -t team.yaml -o gantt.svg
```

For instance, the description of the [EPIC project](samples/epic) yields the following Gantt chart:

![EPIC Gantt chart](samples/epic/gantt.svg)

repository: fchauvel/rpp

gha_language: TypeScript

repo_name: fchauvel/rpp


text:
Creating a file ex "index.html" with the same name but add .tpl extesion ex "index.html.tpl" will cause
the web server code to process the file as a template.

The file can be zero length.

Enable template processing for index.html then upload the sketch data.
  \> touch index.html.tpl

Files with .gz extension will be returned when the partial request file is used.
ex. /favicon.ico will be sent from favicon.ico.gz if it exists and the server
will inform the client on the stream being compressed data so it can decompress it.

Template macros:
 ${0}  - Device Version string
 ${1}  - Uptime string DDDDd:HHh:MMm:SSs
 ${2}  - This device ipv4 address HOST
 ${3}  - Web client ipv4 address
 ${4}  - Protocol [HTTP/HTTPS]
 ${5}  - Device UUID
 ${6}  -
 ${7}  -
 ${8}  -
 ${9}  -
 ${10} -

repository: stephanedenis/ArduinoAlarmDecoder

repo_name: stephanedenis/ArduinoAlarmDecoder


text:
#  FSS2021 > Community > Game Changing Propositions
[fss21 link](https://foodsystems.community/game-changing-propositions/)

- Summary Table of First wave of game-changing propositions - 19 April 2021

## AT-1: Access to safe nutritious food for all

### 1.1 Promote Food Security and Reduce Hunger

### 1.2 Improve access to nutritious foods

### 1.3 Making Food Safer

## AT-2: Sustainable consumption

### 2.1 Enabling, Inspiring and motivating people to enjoy healthy and sustainable options

### 2.2 Slashing food loss and waste and transitioning to circular economy

## AT-3: Nature positive production
### 3.1 Protect natural ecosystems
### 3.2 Managing sustainably existing food production systems
### 3.3 Restore degraded ecosystems

## AT-4: Livelihood and equality
### 4.1 Rebalancing agency within food systems
### 4.2 Eliminating worker exploitation and ensuring decent work in food systems
### 4.3 Localizing food systems

## AT-5: Resilience
### 5.1 Food systems resilience
### 5.2 Universal food access to build resilience
### 5.3 Climate resilient development pathways to food system transformaation

## Cross-cutting
### 6.1 Governance and planning

repository: LucasIsasmendi/sdg

repo_name: LucasIsasmendi/sdg


text:
---
title: Sports Committee
permalink: /officers/sports/

# FORMAT AS FOLLOWS
# ![image-left]({{ "/assets/images/officers/small/<OFFICER NAME>.png" | absolute_url }}){: .align-left}
# ## Name  <- two spaces for line breaks
# ### Class
# **(major) / (minor)**  <- again, two spaces after for line breaks
# Email Address: (email)
# (empty line)
# > (bio)
# (another empty line)
# --- (this is a section break)
---

![image-left]({{ "/assets/images/officers/20-21/small/Shane.png" | absolute_url }}){: .align-left}
## Shane Lee

<a<EMAIL_ADDRESS>style="margin: 0; padding: 0">

Junior

**Political Science and PPE**

> *yoooooo what's good mates I am an intense Amy Winehouse fan , I love getting massages and enjoy skipping shoulder days. Ahhh I also hate the show Friends, a Tommy Hilfiger feen and Timotheé Chalamet is the greatest actor of our generation.*

### **Where are you from?**
> Virginia Beach, VA

### **What fictional character do you relate with the most and why?**

> *Jules from Pulp Fiction because of that cozy wallet he had*

### **What is your favorite food?**

> *Triple Cheeseburger from Five Guys or some Shepherds pie from my madre*

### **What is your life motto?**

> *Pressure busts pipes*

### **What's your favorite dressing to put on sushi?**

> *Most definitely Honey Mustard*

---

![image-left]({{ "/assets/images/officers/20-21/small/Kyle.png" | absolute_url }}){: .align-left}
## Kyle Brown

Sophomore

****

> Follow @fitxfasa on Instagram

repository: lacson/vtfasa-website-legacy

repo_name: lacson/vtfasa-website-legacy


text:
---

## SECTION - PERFORMANCE TESTING

A discussion section

---

## Performance Testing

- is performance testing an API important?
- what does it mean?
- what risks are there for APIs?
- what tools have you used?
- how would you performance test an API?

---

## Possible Open Source Tools

- Artillery
    - https://artillery.io/docs/getting-started/
- JMeter
    - https://jmeter.apache.org/
    - https://github.com/flood-io/ruby-jmeter
    - http://gettaurus.org/
- Gatling
    - https://gatling.io/

---

## Artillery Example

- `brew install node`
- `npm install -g artillery`
- To run through a proxy

~~~~~~~~
 HTTP_PROXY='http://localhost:8080' artillery run example.yml
~~~~~~~~

- to generate output

~~~~~~~~
artillery run example.yml -o output.json
~~~~~~~~

- to generate a report

~~~~~~~~
artillery report output.json
~~~~~~~~

---

## Artillery Example - example.yml

~~~~~~~~
config:
  target: 'http://localhost:4567/listicator'
  phases:
    - duration: 20
      arrivalRate: 10
  processor: "./javascript-helpers.js"
scenarios:
  - flow:
    - get:
        url: "/lists"
    - function: "millisTitle"
    - post: # create a list
        headers:
          Authorization: "Basic YWRtaW46cGFzc3dvcmQ="
        url: "/lists"
        json:
          title: "{{ title }}"
        capture:
          - header: "location"
            as: "newlistguid"
    - get:
        url: "{{ newlistguid }}"
        ifTrue: "newlistguid"
~~~~~~~~

---

## JavaScript Helpers .js

~~~~~~~~
module.exports = {
    millisTitle: millisTitle
  }

function millisTitle(context, events, done){
    context.vars['title'] =  'my title ' +
                             new Date().valueOf();
    return done();
}
~~~~~~~~

---

## Model Based Testing Approaches - Bots

- custom approach
- can potentially be performed in other tools when you understand how they work
- for RestMud I created player bots
   - implement different play strategies
   - maintain their own state
   - run in separate threads
- I use for exploratory multi user testing

see see [github.com/eviltester/restmud/tree/master/src/restmudbots](https://github.com/eviltester/restmud/tree/master/src/restmudbots)

---

## A Simple Model Based Test Bot

~~~~~~~~
@Test
public void createAMultiUserRestMudTestBot(){

    RestMudTestBot myFirstBot = new RestMudTestBot(
                "http://restmud.herokuapp.com")
            .setUserName("zzzamd64Windows811488121657822");
    myFirstBot.needsToRegisterOnSystem(true);
    myFirstBot.setRegistrationSecretCode("secretcode");
    myFirstBot.setPassword("password");
    myFirstBot.register();
    myFirstBot.login();

// ...
~~~~~~~~

---

## A Simple Model Based Test Bot Continued

~~~~~~~~
    myFirstBot.addActionStrategy(
            new WalkerStrategy().canOpenDoors(true));
    myFirstBot.addActionStrategy(new MadHoarderStrategy());
    myFirstBot.addActionStrategy(new RandomTakerStrategy());
    myFirstBot.addActionStrategy(new RandomUseStrategy());
    myFirstBot.addActionStrategy(
            new AllDoorOpenerStrategy());

    myFirstBot.addWaitingStrategy(
            new RandomWaitStrategy().waitTimeBetween(0,100));

    for(int x=0;x<2000;x++) {
        myFirstBot.executeARandomActionStrategy();
        myFirstBot.waitAWhile();
    }
}
~~~~~~~~

---

## Code Structure Walkthrough

- `RestMudTestBot` - basic object that represents a player
- `ThreadedRestMudTestBot` - represents a player as a thread
- Bots use strategies which are either
   - Action strategies - `RestMudBotStrategy`
   - Waiting strategies - `RestMudBotWaitingStrategy`
- A Simple API abstraction `RestMudApi`
- A generic command abstraction `CommandExecutor`
- I used also for testing end point case testing with the `ChangeCaseifier`

see see [github.com/eviltester/restmud/tree/master/src/restmudbots](https://github.com/eviltester/restmud/tree/master/src/restmudbots)

---

## Performance / Stress Testing Recap

- Can be a very 'static' process
- Strategic Performance Testing can be hard to maintain
- Code Based DSLs:
  - easy to version control and maintain
  - support tactical testing
- Performance Testing can be exploratory
- Continuous Testing should limit variation to allow comparison between runs
- Bot Modelling - custom, flexible

---

## Suggested Exercises

- Experiment with Artillery
    - install node
    - install Artillery
    - try the script in the `performance/artillery` folder
    - run it through a proxy
    - expand the script, create a new script
        - make more calls
        - create new users
        - etc.
- Examine the bots in see [github.com/eviltester/restmud/tree/master/src/restmudbots](https://github.com/eviltester/restmud/tree/master/src/restmudbots)

repository: muusee/automating-rest-api

repo_name: muusee/automating-rest-api


text:
JSONselect-php
==============

Port of JSONselect to PHP, for more information check http://jsonselect.org/

This implementation is heavily based on https://github.com/lloyd/JSONSelect/blob/master/src/jsonselect.js

### Setup Tests
```
git submodule init
git submodule update
```

### Run Tests
```
cd src
php test.php
```

repository: tripsta/JSONselect-php

repo_name: tripsta/JSONselect-php


text:
# slhpa-web-app-test

- cd *the_parent_directory_of_your_repository*
- git clone https://github.com/chrisxkeith/slhpa-web-app-test.git
- cd slhpa-web-app-test
- pip install -r requirements.txt

Download appropriate selenium drivers

- https://sites.google.com/a/chromium.org/chromedriver/downloads
- https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/
- https://developer.apple.com/documentation/webkit/testing_with_webdriver_in_safari

Add driver locations to path.

python test.py

Source for website : https://github.com/jeffb4real/SLHPA-Web-App/

repository: chrisxkeith/slhpa-web-app-test

gha_language: Python

repo_name: chrisxkeith/slhpa-web-app-test


text:
# Beaconator
[![release](https://img.shields.io/github/release/capt-meelo/Beaconator?label=version&color=brightgreen)](https://github.com/capt-meelo/Beaconator/releases)
[![license](https://img.shields.io/github/license/capt-meelo/Beaconator?color=lightgrey)](https://github.com/capt-meelo/Beaconator/blob/main/LICENSE)
[![issues](https://img.shields.io/github/issues/capt-meelo/Beaconator?color=red)](https://github.com/capt-meelo/Beaconator/issues)
[![stars](https://img.shields.io/github/stars/capt-meelo/Beaconator)](https://github.com/capt-meelo/Beaconator/stargazers)
[![forks](https://img.shields.io/github/forks/capt-meelo/Beaconator?color=yellow)](https://github.com/capt-meelo/Beaconator/network)

Beaconator is an aggressor script for Cobalt Strike used to generate either **staged** or **stageless** shellcode and packing the generated shellcode using your tool of choice.

Currently, it supports the following tools:

**Staged Beacon Generator**
- [Alaris](https://github.com/cribdragg3r/Alaris)

**Stageless Beacon Generator**
- [PEzor](https://github.com/phra/PEzor)
- [ScareCrow](https://github.com/optiv/ScareCrow)

# How to Use
## Beaconator
1. Load the `beaconator.cna` file via `Cobalt Strike > Script Manager`.
2. Access Beaconator from the menu bar by clicking the `Generate Beacon` menu.

## Staged Beacon Generator
### Alaris
1. Clone the repo.
```
git clone https://github.com/cribdragg3r/Alaris.git
```
2. Open `beaconator.cna` and change the value of the `$ALARIS_DIR` variable and point it to where **Alaris** is located.

## Stageless Beacon Generator
### PEzor
1. Install **PEzor** using the following:
```
git clone https://github.com/phra/PEzor.git
cd PEzor
./install.sh
```
2. Add PEzor's `$PATH` variable in your `~/.profile` or `~/.bashrc` (if using Bash), **OR** `~/.zprofile` or `~/.zshrc` (if using ZSH).

### ScareCrow
1.  Clone the repo and build ScareCrow.
```
git clone https://github.com/optiv/ScareCrow.git
cd ScareCrow
go build ScareCrow.go
```
3. Open `beaconator.cna` and change the value of the `$SCARECROW_DIR` variable and point it to where **ScareCrow** is located.

# Screenshots
### Beaconator
![option-staged.png](./images/option-staged.png "Staged Option") ![option-stageless.png](./images/option-stageless.png "Stageless Option")

### Alaris
![alaris-options.png](./images/alaris-options.png "Alaris Options")
![alaris-console.png](./images/alaris-console.png "Alaris Console Output")

### PEzor
![pezor-options.png](./images/pezor-options.png "PEzor Options")
![pezor-console.png](./images/pezor-console.png "PEzor Console Output")

### ScareCrow
![scarecrow-options.png](./images/scarecrow-options.png "ScareCrow Options")
![scarecrow-console.png](./images/scarecrow-console.png "ScareCrow Console Output")

## Credits
- [@JFaust_](https://twitter.com/JFaust_) for developing [Alaris](https://github.com/cribdragg3r/Alaris).
- [@phraaaaaaa](https://twitter.com/phraaaaaaa/) for developing [PEzor](https://github.com/phra/PEzor).
- [@Tyl0us](https://twitter.com/Tyl0us) for developing [ScareCrow](https://github.com/optiv/ScareCrow).

repository: Seeeyouu/Beaconator

repo_name: Seeeyouu/Beaconator


text:
RaphaelJS.group
===============

A plugin which brings SVG group elements into Raphael JS framework.

Short documentation

First take a look at the source code of the 'index.html' file for adding the script in the page.

Initiating a group:

  var group = new r.group('container',array);

Where:
    'r' is the Raphael JS canvas,
    'container' is the HTML element ID where the SVG was created with Raphael JS
    and 'array' is an array of Raphael JS objects

Available methods

 * group.remove
 * group.translate
 * group.rotate
 * group.scale
 * group.push
 * group.getAttr
 * group.toFront
 * group.clipPath
 * group.animate

Copyright 2013 George I.

Licensed under the MIT License


text:
# DISCLAIMER
**WARNING**: This project is intended for ***educational purposes*** and having fun with Quarkus/crypto/GraalVM/PKI. You should ***not*** use it to run your own production CA!

# Description
Quarkus CA demonstrates:
 * How to build your own CA using nothing but Java.
 * That implementing a PKI (Public Key Infrastructure) is a complex but certainly possible using the proper libraries
  (whether it's a good idea or not is a different matter).
 * How to use Quarkus.
 * How to use JCA cryptographic operations on Quarkus.
 * How to use Bouncy Castle to issue certificates.

# Usage
To start the Quarkus development environment:
```
./mvnw compile quarkus:dev
```
Quarkus CA is now running and can be reached on http://localhost:8080. Upon its first boot, it generates the CA key and (self-signed) certificate, which is used to iussue
certificates. You can now issue server certificates using the web interface (PIN/password: **changeit**).

## Building the native image
Quarkus CA can also run as a native image built by GraalVM. To build it, run ***package*** using the ***native*** profile:
```
./mvnw package -Pnative
```

## Configuration
The following properties can be passed:

| Property                  | Default value | Description |
|---|---|---|
| ca.commonName             | Quarkus CA    | Name of the CA. |
| ca.key.size               | 2048          | RSA key size of keys generated by the CA. |
| ca.certificate.validity   | 365           | Number of days that certificates (issued by the CA) are valid. |

## Enabling HTTPS
Upon first boot, a SSL/TLS server certificate is generated for the CA. To enable HTTPS (on port 8081) and use this certificate, pass the following properties to the CA:
```properties
quarkus.http.ssl-port=8081
quarkus.http.ssl.certificate.key-store-file=ca-web.jceks
quarkus.http.ssl.certificate.key-store-password=changeit
```
Passing these to the native image:
```
target/quarkus-ca-runner \
 -Dquarkus.http.ssl-port=8081 \
 -Dquarkus.http.ssl.certificate.key-store-file=ca-web.jceks \
 -Dquarkus.http.ssl.certificate.key-store-password=changeit
```

license: Unlicense

repository: reinkrul/quarkus-ca

gha_language: Java

gha_license_id: Unlicense

repo_name: reinkrul/quarkus-ca


text:
# Judea, Judah

## Facts:

The term “Judea” refers to an area of land in ancient Israel. It is sometimes used in a narrow sense and other times in a broad sense.

* Sometimes “Judea” is used in a narrow sense to refer only to the province located in the southern part of ancient Israel just west of the Dead Sea. Some translations call this province “Judah.”
* Other times “Judea” has a broad sense and refers to all the provinces of ancient Israel, including Galilee, Samaria, Perea, Idumea and Judea (Judah).
* If translators want to make the distinction clear, the broad sense of Judea could be translated as “Judea Country” and the narrow sense could be translated as “Judea Province,” or “Judah Province” since this is the part of ancient Israel where the tribe of Judah had originally lived.

(Translation suggestions: [How to Translate Names](../../translate/translate-names))

(See also: [Galilee](../names/galilee.md), [Edom](../names/edom.md), [Judah](../names/judah.md), [Judah](../names/kingdomofjudah.md), [Samaria](../names/samaria.md))

## Bible References:

* [1 Thessalonians 2:14](rc://en/tn/help/1th/02/14)
* [Acts 2:9](rc://en/tn/help/act/02/09)
* [Acts 9:32](rc://en/tn/help/act/09/32)
* [Acts 12:19](rc://en/tn/help/act/12/19)
* [John 3:22-24](rc://en/tn/help/jhn/03/22)
* [Luke 1:5](rc://en/tn/help/luk/01/05)
* [Luke 4:44](rc://en/tn/help/luk/04/44)
* [Luke 5:17](rc://en/tn/help/luk/05/17)
* [Mark 10:1-4](rc://en/tn/help/mrk/10/01)
* [Matthew 2:1](rc://en/tn/help/mat/02/01)
* [Matthew 2:5](rc://en/tn/help/mat/02/05)
* [Matthew 2:22-23](rc://en/tn/help/mat/02/22)
* [Matthew 3:1-3](rc://en/tn/help/mat/03/01)
* [Matthew 19:1](rc://en/tn/help/mat/19/01)

## Word Data:

* Strong’s: [[G02453]]

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# Simple React App with Authentication

A simple react app with user authentication. Home and MyAccount pages require login. If an unauthenticated user visits Home or MyAccount, they will be navigated back to Login. MyAccount has a Login/Logout History table that displays user info including date and time.

## Application Architecture
This application is built using ReactJS. Each screen is divided into separate components.

### Styling
Material-UI has been in constructing every component.

### Other npm modules
*	axios
*	@mui/material
*	react-router-dom

## Installation

1.	Extract the HistoryApp-main.zip file.
2.	Open the terminal and navigate to HistoryApp-main project directory by entering the following command

```bash
cd HistoryApp-main
```
3.	Run the following command to install dependencies

```bash
npm install
```

To run the application:

1.	Open the terminal and navigate to HistoryApp-main project directory
```bash
cd HistoryApp-main
```
2.	Run the following command to spin up the server
```bash
npm start
```

## To Do
* Add unit and component tests for all components

## Contributing
Pull requests are welcome.

## License
[MIT](https://choosealicense.com/licenses/mit/)


text:
# Question 13

### C program to find the factorial of the given number.

## Difficulty Level

Easy

## Sample Input

      Enter a number: 3

## Sample Output

      Factorial of 3 is: 6


text:
# on_stop

The `on_stop` handler is invoked when a task calls the stop method or receives a `SIGTERM` signal.

## Definition

```python
def on_stop(
    self,
    task: sergeant.objects.Task,
) -> None
```

Possible use cases include:

- Send a log message
- Create a metrics collector
- Close open sessions when the worker is being stopped

repository: Intsights/sergeant

repo_name: Intsights/sergeant


text:
# @chitchatjs/workout-buddy

A fully working complex skill using chitchat.js.

Published here - https://www.amazon.com/Kevindra-WorkoutBuddy/dp/B07JJT6XNL

Framework - https://chitchat.js.org

## Setup

```sh
# <fork>

# From the root of the project
npm i

# Compile typescript
npm run build

# Build CJS - builds all the contents and deployment package
cjs build

# Deploy
cjs deploy

```

## Test

```sh
cd pkg
ask dialog -l en-US

U:> open sample workout buddy
A:> welcome ...
```

repository: chitchatjs/workout-buddy

repo_name: chitchatjs/workout-buddy


text:
# TD-ScreenSpaceFluid
![](img/layout1.jpg)
## Ref
http://developer.download.nvidia.com/presentations/2010/gdc/Direct3D_Effects.pdf

https://www.geeks3d.com/20100809/siggraph-2010-screen-space-fluid-rendering-for-games/

## To-do
- Optimization (done in one or two `GLSL MAT`)
- Volumetric Absorption

## Author

Yea Chen (yeataro)

https://github.com/yeataro

yeataro@gmail.com

repository: yeataro/TD-ScreenSpaceFluid

repo_name: yeataro/TD-ScreenSpaceFluid


text:
## AWS Security Group Demo Module

This Terraform module adds a security group rule that allows traffic from a node. This is a simplistic module created for Consul-Terraform-Sync demoing purposes.

## Feature
This module uses the AWS Terraform provider to create a new security group rule, allowing ingress TCP traffic on all ports from an EC2 instance.

## Requirements

### Ecosystem Requirements
| Ecosystem | Version |
|-----------|---------|
| [consul](https://www.consul.io/downloads) | >= 1.7 |
| [consul-terraform-sync](https://www.consul.io/docs/nia) | >= 0.1.0 |
| [terraform](https://www.terraform.io) | >= 0.13 |

### Terraform Providers

| Name | Version |
|------|---------|
| aws | >= 3.56 |

## Setup

1. Create an AWS security group.

## Usage

| Input Variable | Required | Description |
|-------------------|----------|-------------|
| security_group_id | true | The ID of the security group |

**User Config for Consul Terraform Sync**

example.hcl
```hcl
task {
  name           = "security-group-demo-task"
  description    = "allow all ingress TCP traffic to a security group"
  source         = "mkam/security-group-demo/aws"
  version        = "0.1.0"
  providers      = ["aws"]
  services       = ["web", "app"]
  variable_files = ["security_input.tfvars"]
}

driver "terraform" {
  required_providers = {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "3.56.0"
    }
  }
}

terraform_provider "aws" {
  region = "us-west-1"
}
```

**Variable file**

Optional input variable file defined by a user for the task above.

security_input.tfvars
```hcl
security_group_id = "sg-123"
```

repository: mkam/terraform-aws-security-group-demo

repo_name: mkam/terraform-aws-security-group-demo


text:
# swoole-tadpole

HTLM5 + WebSocket + PHP(swoole) , [http://tadpole.laravel.band/home](http://tadpole.laravel.band/home)

## Installation

first, make sure you have installed mongodb and swoole extension on your php.

clone from github and install dependence

```
$ git clone https://github.com/zhaohehe/swoole-tadpole.git
$ composer install
```

then copy config file

```
$ cp config.example.php config.php
```
set socket server host and port

run your redis server, then start socket server

```
$ php socket.php
```

## License
The pad is licensed under the MIT license.

repository: zhaohehe/swoole-tadpole

repo_name: zhaohehe/swoole-tadpole


text:
# pyeem
Python Library for Processing EEM Spectra including training and vizualization of convolutional neural networks to identify chemicals or components present in samples.

## pyeem functions
#### (under development)
* Import meta-data
* Import Spectra from instument file(s)
   - EEMs
   - Absorbance Measurements
* Subtract blanks
* Remove Scatter
  - Using interpolation
  - Replace with fixed value (i.e. zero)
* Ramam normalize
* Crop EEM
* Inner filter effect correction
* **EEM Vizualization**
  - Contour plots
* **Convolutional Neural Network (CNN)**
  - Data augmentation
  - Network Training
  - Result Vizualization (Parity Plots)
  - Salinecy Maps and Vizualizations

repository: jayruth/pyeem

repo_name: jayruth/pyeem


text:
# Multi-trajectory search algorithm in pure Julia

## Description

Multiple trajectory search (MTS) is a derivative-free heuristic optimization method presented by [Lin-Yu Tseng and Chun Chen, 2008](https://sci2s.ugr.es/sites/default/files/files/TematicWebSites/EAMHCO/contributionsCEC08/tseng08mts.pdf).
The `MTS` algorithm is implemented in the `NonconvexSearch.jl` package. This module implements all the optimization methods in the paper.

## Quick start

Using default `MTSOptions()`. `MTS` is used for optimization.

```julia
using Nonconvex
Nonconvex.@load MTS

alg = MTSAlg()
LS1_options = MTSOptions()
m = Model(f)
lb = [0, 0]
ub = [5, 5]
addvar!(m, lb, ub)
result = optimize(model, alg, x0, options = options)
```

gha_language: Julia


text:
---
title: "Kohana PHP Error"
date: 2011-09-24
description: "Hello Toto post"
---

Installing a Kohana application is pretty straight forward. There is a php install script that verifies the environment to make sure all goes smoothly once up and running.

You have to make sure the `application/cache` and `application/logs` directories are writable by the server, and this one thing goes unnoticed by the script. So you might run your application and run into this error:

`Kohana Error: The log directory is not writable`

If you are running Apache in Ubuntu, you would have to:

    sudo chown www-data:www-data application/{cache,logs}
    chmod 0770 application/{cache,logs}

If you make logs owned by www-data, but you had folders inside that are not, it will fail and not complain anywhere. You would get a PHP error such as:

` PHP Fatal error:  Exception thrown without a stack frame in Unknown on line 0.`

The mistake with the previous command was that it assumed the folders were empty. We can add the `-R` parameter and it should be all good in all cases.

branch_name: HEAD


text:
# Fitness_Tracker
  ## Table of Content
   1. [Description](#Description)
   2. [Installation](#Installation)
   3. [Usage](#Usage)
   4. [Screenshot](#Screenshot)
   5. [Credit](#Credit)
   6. [Questions](#Questions?)
   7. [License](#Licensing)

  ## Description
  The fitness tracker app will allow users to track workout routines. Users will be able to add any resistance and/or cardio based routines and track their progress through the user dashbord.

  ## Installation
  [**Visit deployed link on heroku**](https://stark-lowlands-17260.herokuapp.com/)

  ## Usage
  Click on 'New Workout' to add a new routine or 'Continue Workout' to continue any existing routines.

  ## Screenshot
 <img src= 'Assets\images\Fitness_Tracker.jpg' width="750" height="350">

  ## Credit
  - UofT Bootcamp Assistant Instructor: **Luca Beyrute**
  - UofT Bootcamp Tutor: **Ben Abbot**

  ## Questions? You can reach me at:
  - Github: https://github.com/kcrawford101
  - Email<EMAIL_ADDRESS>
  ## Licensing
  This project is licensed under:
* [MIT License](LICENSE.txt)

  ![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)


text:
# Publishing your book online

Now that you've built the HTML for each **page**, it's
time to stitch together these pages into HTML for a **book**
and host it online. This means building the left Table of Contents and
stitching each of your pages together.

You've got two options to do this.

1. **Option 1: GitHub builds and hosts your book with GitHub Pages**:

   When you run `jupyter-book create` it generates the structure of a Jekyll
   template. GitHub Pages can automatically build a website from a Jekyll template,
   and you can use this to automatically generate the HTML for your book.

2.  It also gives you more functionality than using
   GitHub Pages to build your book. However, it also requires you to install
   Ruby (an open source programming language) or to run Ruby with a containerization
   platform like Docker or Singularity.

We'll cover each option below.

## When should you build the HTML locally?

You might ask: if GitHub pages can build my site automatically from the intermediate files, why
build it locally? The main reason for this is that you get more flexibility by building locally
and serving raw HTML, as opposed to auto-building the site with GitHub-pages.

If you wish to use any **extra Jekyll plugins**, such as the `jekyll-scholar` plugin that
enables you to add citations and bibliographies, then you need to build your site
locally as HTML. GitHub Pages doesn't let you enable any extra plugins if it auto-builds your site.
In addition, if you'd like to **host your book's HTML anyhwere other than GitHub Pages**,
then you'll need to build the book's HTML on your own.

### Prerequisites

Ensure that your the HTML has been built for each page of your book
(see [the previous section](03_build.html)). There should be a collection of HTML
files in your book's `_build/` folder.

## Publish your book online with GitHub Pages

Once you've built the intermediate files for your book (in `_build`) or built the HTML
for your book (in `_site`), you can push your book contents to GitHub so that
others can access your book. To do so, follow these steps:

0. Confirm that each page's HTML is built. You should see a
   collection of HTML files/folders in the `_build` folder.
1. Commit and push the changes to your repository.
2. Enable GitHub site building for your repository.

   From your GitHub repository, click `Settings` then scroll down to the
   `GitHub Pages` section. You should see the message `Your site is published at <YOUR-URL>`.
   Ensure that you're building from the correct folder.

3. Go to the URL listed at `<YOUR-URL>` and you should see your live site.

That should be all that is needed for GitHub Pages to automatically build
and publish your site. Any time you push changes to the `_build/` folder
(by running `jupyter-book build` locally and pushing the changes to GitHub),
your book content will update.

## Build the book's site HTML locally

This section covers how to build the HTML for your book locally, instead of
using GitHub Pages.

In order to locally build your book's HTML with Jekyll, you'll take one of two approaches:

1. Install a copy of the Ruby language (which is a free open-source language, but can be a pain to install).
2. Use a container software (Docker or Singularity) along with a Docker image that we've
   prepared for you
   [from this Dockerfile](https://github.com/jupyter/jupyter-book/blob/master/jupyter_book/Dockerfile).

We recommend installing Ruby with one of the supplied methods first, and if this fails,
try installing with a container tool such as Docker.

### Install Ruby and build your book HTML

The most straightforward way to build your book's HTML is to install
Ruby and Jekyll.

In this case, you'll need Ruby, an open-source programming language, to build your book's
HTML. You won't need to know how to program in Ruby, we'll just use some tools that utilize
Ruby's libraries.

There are a few different methods for installing Ruby, and their ease will depend
on the operating system that you're using (in general, `*nix` platforms are more
straightforward to use for installing Ruby).

In the following sections we'll cover a few ways to install Ruby, they are roughly ordered
from most-straightforward to most-difficult. Once you've finished those steps,
head to [install ruby plugins](#install-ruby-plugins) and follow the directions.

#### Using the `conda-forge` recipe `rb-github-pages`

The easiest way to install Ruby on *nix systems is to use
the *`conda`* package manager. On some systems the following should work:

```bash
conda install -c conda-forge rb-github-pages
```

This will install pre-compiled binaries for the Ruby package GitHub pages, Jekyll, and all of their dependencies. If this works for you, you can skip straight to [the section using `make install`](#install-ruby-plugins).

#### Using the official Jekyll instructions

The [Jekyll Documentation](https://jekyllrb.com) provides their own set of instructions
for how to install Ruby locally on your system. These are a bit more involved, but in
general should work for many operating systems. Here are a few links to OS-specific
instructions.

* [MacOS Instructions](https://jekyllrb.com/docs/installation/macos/)
* [Ubuntu Instructions](https://jekyllrb.com/docs/installation/ubuntu/)
* [Linux (non-Ubuntu) Instructions](https://jekyllrb.com/docs/installation/other-linux)
* [Windows Instructions](https://jekyllrb.com/docs/installation/windows/)

#### Install base Ruby with `conda`

If you are on a platform for which the `rb-github-pages` package isn't available, you can also try install Ruby and a C++ compiler manually using *`conda`*, as follows:

```bash
conda install -c conda-forge ruby
```

Once you have Ruby installed, the conda-built clang compiler for your
system needs to be installed. Details depend on your OS and are shown below.

##### Install clang compilers

###### On OSX

Two steps are needed on OSX. First, install the *`conda`'s* clang compiler:

```bash
conda install -c conda-forge clangxx_osx-64
```

If you are running OSX 10.14 (Mojave) you also need to install system libraries in
the default *nix locations by running

```bash
open /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg
```

###### On Linux

Install *`conda`'s* clang compiler:

```bash
conda install -c conda-forge gxx_linux-64
```

#### Install Ruby plugins

Regardless of the approach used above, you'll next install
the Ruby plugins for your specific
book. To do so, change into your book's directory, and run

```bash
make install
```

which will install the following things:

* Bundler (a Ruby dependency management tool) if it is not already installed
  (e.g. by running `conda install -c conda-forge rb-github-pages`)
* A collection of Jekyll plugins for your book

You can then preview your book's site locally by running this command:

```
make serve
```

This should run Jekyll, building your site, and then open up a port on your computer with a live version of the book.

### Building your book HTML with Containers

If the above steps do not work for you, then you can try building your
book's HTML with containers.

[Containers](https://www.docker.com/resources/what-container) can
provide an easier installation for many systems.
If you are developing on a system where you have administrator privileges
(i.e., you have `root` permissions), we recommend you use [Docker](https://docs.docker.com/get-started/).

We also provide instructions for using [Singularity](https://www.sylabs.io/guides/2.6/user-guide/quick_start.html),
an alternate containerization software for systems where you do not have administrator privileges.
To learn more about using containers, please see the
[Docker for scientists guide](https://neurohackweek.github.io/docker-for-scientists/).

#### Docker

First, you'll need to make sure you have Docker installed.
There are [installation instructions for each operating system](https://hub.docker.com/search/?type=edition&offering=community)
to guide you through this process.

Once Docker is available on your system, you can build the image locally with:

```bash
docker pull emdupre/jupyter-book
```

You can then access this image with the following command.
Make sure to specify the full path to your Jupyter Book, rather than the relative path!

```bash
docker run --rm --security-opt label:disable  \
   -v /full/path/to/your/book:/srv/jekyll \
   -p 4000:4000 \
   -it -u 1000:1000 \
   emdupre/jupyter-book bundle exec jekyll serve --host <IP_ADDRESS>
```

If you navigate to `http://<IP_ADDRESS>:4000/jupyter-book/` in your browser,
you should see a preview copy of your book.
If you instead see an error, please try to update your local book;
see [the Jupyter Book FAQ section](https://jupyter.org/jupyter-book/guide/04_faq.html#how-can-i-update-my-book)
for more details on how to do so.

You'll find the HTML for your book in the `_site/` folder.

#### Singularity

If you are on a system where you do not have administrator privileges (such as a shared
computing cluster), you will not be able to use Docker.
Instead, you can use Singularity.
First, you'll need to check with your resource manager that Singularity is available
on your system.

You can then create a Jupyter Book Singularity image using:

```bash
singularity build jupyter-book.simg docker://emdupre/jupyter-book
```

Next, you can access this image with the following command.
Make sure to specify the full path to your Jupyter Book, rather than the relative path!

```bash
singularity run -B /full/path/to/your/book:/srv/jekyll \
    --pwd /srv/jekyll \
    jupyter-book.simg bundle exec jekyll serve
```

And that's it! If you navigate to `http://<IP_ADDRESS>:4000/jupyter-book/` in your browser,
you should see a preview copy of your book.

### Hosting your book's HTML online

If you're choosing to build the HTML for your book by hand, there are a few options for
where you should store the book. The two most common approaches are:

* **Use the `gh-pages` or `master` branch of a GitHub repository**. In this case, the build
  process is very similar to [using GH-pages to build the HTML for your site](https://jupyter.org/jupyter-book/guide/03_build.html#publish-your-book-online-with-github-pages).
  However, there is one caveat: you must include a file called `.nojekyll` along with the HTML
  files of your book. This tells GitHub **not** to use Jekyll to build the HTML.
* **Use a static site hosting service like Netlify**. There are many services that will simply
  host a collection of static HTML files for you in a public URL. The most common is
  [the Netlify CMS service](https://www.netlifycms.org/). Follow the instructions on this site
  for information on how you should upload your HTML files to work with Netlify.

repository: annefou/jupyter-book

repo_name: annefou/jupyter-book


text:
# Struct visibility

Structs have an extra level of visibility with their fields. The visibility
defaults to private, and can be overridden with the `pub` modifier. This
visibility only matters when a struct is accessed from outside the module
where it is defined, and has the goal of hiding information (encapsulation).

```rust,editable
mod my {
    // A public struct with a public field of generic type `T`
    pub struct OpenBox<T> {
        pub contents: T,
    }

    // A public struct with a private field of generic type `T`
    pub struct ClosedBox<T> {
        contents: T,
    }

    impl<T> ClosedBox<T> {
        // A public constructor method
        pub fn new(contents: T) -> ClosedBox<T> {
            ClosedBox {
                contents: contents,
            }
        }
    }
}

fn main() {
    // Public structs with public fields can be constructed as usual
    let open_box = my::OpenBox { contents: "public information" };

    // and their fields can be normally accessed.
    println!("The open box contains: {}", open_box.contents);

    // Public structs with private fields cannot be constructed using field names.
    // Error! `ClosedBox` has private fields
    //let closed_box = my::ClosedBox { contents: "classified information" };
    // TODO ^ Try uncommenting this line

    // However, structs with private fields can be created using
    // public constructors
    let _closed_box = my::ClosedBox::new("classified information");

    // and the private fields of a public struct cannot be accessed.
    // Error! The `contents` field is private
    //println!("The closed box contains: {}", _closed_box.contents);
    // TODO ^ Try uncommenting this line
}
```

### See also:

[generics][generics] and [methods][methods]

[generics]: ../generics.md
[methods]: ../fn/methods.md

repository: rust-lang/rust-by-example

repo_name: rust-lang/rust-by-example


text:
---
hrs_structure:
  division: '1'
  volume: '7'
  title: '20'
  chapter: 353H
  section: 353H-4
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0353H-0004
    parent: HRS0353H
    name: 353H-4 Model programs; department of public safety
weight: 35025
title: Model programs; department of public safety
full_title: 353H-4 Model programs; department of public safety
---
**[§353H-4] Model programs; department of public safety.** Subject to funding by the legislature, the department of public safety shall enhance the State's comprehensive offender reentry system by developing model programs designed to reduce recidivism and promote successful reentry into the community. Components of the model programs shall include but are not limited to:

(1) Highly skilled staff who are experienced in working with offender reentry programs;

(2) Individualized case management and a full continuum of care to ensure successful reentry;

(3) Life skills development workshops, including budgeting, money management, nutrition, and exercise; development of self-determination through education; employment training; special education for the learning disabled; social, cognitive, communication, and life skills training; and appropriate treatment programs, including substance abuse and mental health treatment;

(4) Parenting and relationship building classes. The department shall institute policies that support family cohesion and family participation in offenders' transition to the community, and, where possible, provide geographical proximity of offenders to their children and families; and

(5) Ongoing attention to building support for offenders from communities, community agencies, and organizations. [L Sp 2007, c 8, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
+++
title = "htmx 1.1.0 has been released!"
date = 2021-01-06
[taxonomies]
tag = ["posts", "announcements"]
+++

## htmx 1.1.0 Release

I'm happy to announce the [1.1.0<EMAIL_ADDRESS>of htmx.

This is a surprisingly big release, but the star of the show isn't htmx itself, but rather the new
[preload<EMAIL_ADDRESS>which allows you to preload requests into the cache,
cutting down on latency.  (This extension is used in the htmx website!)

There are also new examples, including [keyboard<EMAIL_ADDRESS>and
[drag and drop list reordering with Sortable.js](@/examples/sortable.md).

### Changes

* Newly added [preload<EMAIL_ADDRESS>allows you to preload resources for lower
  latency requests!
* Support the `ignore:` modifier for extensions
* Updated form variable order inclusion to include the enclosing form *last* so that, in the presence of multiple
  values, the most relevant value is the most likely to be selected by the server
* Support for the<EMAIL_ADDRESS>javascript function, to issue an htmx-style ajax
  request from javascript
* Removed the following htmx request headers for better cache behavior: `HX-Event-Target`, `HX-Active-Element`,
  `HX-Active-Element-Name`, `HX-Active-Element-Value`
* Added the<EMAIL_ADDRESS>attribute, which allows
  you to preserve elements across requests (for example, to keep a video element playing properly)
* The<EMAIL_ADDRESS>now surfaces a small api
  for refreshing path dependencies manually in javascript
* Now support the `from:` clause on<EMAIL_ADDRESS>to
  allow an element to respond to events on other elements.
* Added the `htmx:beforeProcessNode` event, renamed the (previously undocumented) `htmx:processedNode` to `htmx:afterProcessNode`
* Added `closest` syntax support for the<EMAIL_ADDRESS>attribute
* Added `on load` support for the newest version of [hyperscript](https://hyperscript.org)
* Added the `htmx.config.allowEval` configuration value, for CSP compatibility
* Bug fixes & improvements

Enjoy!

repository: bigskysoftware/htmx

repo_name: bigskysoftware/htmx


text:
#This is a VUE shopping cart project

Home Page:
1. Header : used Header from Mint-UI
2. Tabbar:  used tabbar from MUI
    a. update icon. (copy css and ttf to project folder)
    b. add cart icon 'mui-icon mui-icon-extra mui-icon-extra-cart'
3. content area add router-view

update tabbar to router-link

# load pictures for slides.
1. use vue-resource
2. use vue-resource this.$http.get get slide info
3. save data
4. use v-for render slide item

update grid area

update News route

# create news page
1. create page  (use media-list from MUI)
2. use vue-resouce get data
3. render real data

# display news detail page
1. update each item to router-link.  use ID to identify the page
2. create component for detail page  NewsInfo.vue
3. create route

# create news detail page and render data

# create comment component "comment.vue"
1. create comment.vue component template
2. manually import comment component when need this component
   + `import comment  from './comment.vue`'
3. regist comment component on 'components'
4. create new name when regist sub component. and use this name on page

# get all comments and display

# show more comments
1. bind Click event for "more" button, request next page's data
2. click button "more", let pageIndex++, then use this.getComments() get new data
3. use "concat" method to add new comments. (keep old comments)

# create comments
1. two-way data bindings on textarea
2. bind click even for button
3. check comment content. if empty, "Toast" messasge and let user edit content.
4. use vue-resource send a request to server
5. if send comment success. Refresh comments, show new comment.
    + if use getComments methods. may only get the last page comment.
    + so, manually add the latest comment. Then, use unshit method add new data to comments.

# change Share button to route link and display related component

# create photo list,  component page, and related style
1. top nav bar
    + use tab-top-webview-main.html from MUI
    + remove mui-fullscreen Class
    + slide not working. Need JS component.
        1. import mui.js
        2. check MUI website and init
    + import mui.js. But receive error: TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them. Webpack should use strict mode on bundle.js.
    + solution:
        1. install @babel/plugin-transform-modules-commonjs @babel/plugin-transform-strict-mode
        2. .babelrc add `["@babel/plugin-transform-modules-commonjs", { "strictMode": false }]`
    + top slide bar not working when enter from home page. should init slide after DOM load. So, move related code to "mounted"
    + at the bottom, the tabbar not working. because the sytel mui-tab-item conflict. rename this Class at App.vue and lib/mui/css/mui.css
    + render category list
# create photo list
    1. use lazy load.
    3. set lazy load style.

# list picture to detail page
1. change li to router-link

# create picture detail page and render date.

# show preview picture
1. use vue-preview plugin
2. get all pictures list, use v-for render data
3. picture data should have w and h

# create shopping list page

# Test project on mobile device
1. Mobile and PC should be in same network. (mobile can visit PC IP)
2. In project, open package.json. At "dev" script, add --host. set --host value (PC IP)


text:
AI Engine Development

    See Vitis™ Development Environment on xilinx.com

    See Vitis™ AI Development Environment on xilinx.com

## Software-Emulation Debug Walkthrough

## Introduction

Generally, software emulation is the first step to building and testing the system in a functional process through the custom host code you create rather than the simulator test host code.

Software emulation for a system with an AI Engine can be useful in:

* Checking initial system behavior with a limited known data set
* Functional integration and debugging of the processing system (PS), programmable logic (PL), and ADF graph using the GNU debugger (GDB)
* Testing the system with the external traffic generator using Python or C++
* Running system with C-based models for register-transfer level (RTL) kernels
* Applying AI Engine simulation options through the x86 options file in `Work/options`

## Features

The following are some of the software emulation features this section covers.

Build for Software Emulation Using the Vitis IDE

Explains how to create system project, build for sofware emulation, and run.

Using the Vitis IDE for Software Emulation Debug

Explains how to debug for software emulation using the Vitis IDE.

Debug in the Command Line

Explains how to use the GDB to debug in the command line using the option `-kernel-dbg true`.

# Section 1

## Build for Software Emulation Using the Vitis IDE

Before getting into this section, it is expected that you created an AI Engine application in the Vitis IDE and ran x86simulation [Build and Simulate in Vitis IDE](../X86_Simulation/README.md#Build-and-simulate-in-Vitis-IDE).

Create a system project manually using the steps mentioned in [Port Command Line Project to the Vitis IDE System Project](../CreateIDESystemProj.md), and download the Vitis IDE exported project ([Download Vitis IDE project](../README.md#Download-Vitis-IDE-project)).

If you are using the `PeakDetect.ide.zip` package, make sure to open the system project settings by double-clicking **PeakDetect_system -> PeakDetect_system.sprj**, and set the `sysroot`,`Root FS` and `Kenrel Image` path. For more information, refer to [System Project Settings](../CreateIDESystemProj.md#System-Project-settings).

1. To build the system project, right-click **PeakDetect_System** and select **Build Project**. The top-level project uses an incremental build approach that recognizes the state of the subprojects and only rebuilds projects that need to be updated.
2. Once the build completes, right-click **PeakDetect_System**, select **Run As** -> **Run Configurations**, add the environment variables, and hit **Apply** -> **Run**.
![environment variables](./Images/environment_variables.PNG)

3. In the **Launch on Emulator** window, click the **Start Emulator and Run** button. This starts the Quick Emulator (QEMU) emulation environment and boots Linux. The Emulation console shows a transcript of the QEMU launch and Linux boot process.

    Alternatively, you can also start emulation by selecting the **Vitis -> Start/Stop Emulator** option. One advantage with this is, you can specify the emulator arguments. For example, you can specify options for the AI Engine simulator that runs the graph application as follows:

    `-x86-sim-options ${FULL_PATH}/x86sim.options`

    ![emulator start stop](./Images/emulator_start_stop.PNG)

4. You can observe the Linux boot and application run message in the console as follows:
![emulation console](./Images/emulation_console.PNG)

5. You can stop emulation by clicking the **Vitis -> Start/Stop Emulator** option, and hit **Stop**.

# Section 2

## Using the Vitis IDE for Software Emulation Debug

This section walks you through debugging the Vitis IDE for software emulation. Before going through this section, it is expected to complete the [Debug Using the Vitis IDE Debugger](../X86_Simulation/README.md#Debug-using-Vitis-IDE-debugger) section which gives quick idea on how to use the Vitis IDE debugger.

1. Once the build completes, you can right-click the system project, **PeakDetect_system** and select **Debug As** -> **Launch SW Emulator**.
2. In the **Launch on Emulator** window, select **Start Emulator and Debug**.
3. You can observe the Linux boot and application run messages in the console. Once the boot completes and application run starts, the debugger stops after the `main()` function as follows.
![debugger bp](./Images/debugger_bp.PNG)

4. Also observe in the **Breakpoints** view, two other breakpoints that the tool automatically adds on to the `mm2s` and `s2mm` kernels.
5. Place some breakpoints in your AI Engine source code, and try to observe the intermediate values. Open the `src/kernels/peak_detect.cc` file at line 31.
6. Click the **Resume** button, and now the debugger waits at the breakpoint in `mm2s`. Optionally, you can also try placing the breakpoint in the `mm2s` function.
7. Click **Resume** again, and observe debugger and console output, waiting at the `s2mm` kernel. Continue clicking **Resume** until the breakpoint in `peak_detect.cc` hits. Now, do **step-over** and observe values in variables view as follows.
![variable view](./Images/variable_view.PNG)

    Also note an error message if you try to access the vector variable values. This is not fully supported in software emulation and recommended to use the `x86simulator` to inspect the variable values.
8. After your debug, remove all breakpoints, and click **Resume** to complete the run and stop emulation.

    >**NOTE:** All the limitations from `x86simulator` are applicable in software emulation.

## Debug in the Command Line

This sections walk you through debugging for software emulation using the GDB in the command line.

1. Clone the git repository, and locate the `Makefile` to build the system for software emulation.
2. Set the environment variables as described in [Introduction](../README.md#Introduction).
3. Do `make all` or `make aie`,`make kernels`,`make xsa`,`make host` and`make package` one after the other to complete the build for software emulation.

    >**NOTE:** Make sure to compile the host application using the option `-g` to debug using the GDB.

4. To debug using the GDB, invoke the lauch emulation script using the option, `-kernel-dbg true`.

    ```
    ./sw/launch_sw_emu.sh -kernel-dbg true
    ```

    The option `-kernel-dbg true` will set up the emulator to run `gdb` at the execution of the application.

5. Observe the QEMU emulation environment and Linux boot.
6. Run the following commands in the `QEMU` shell.

    ```
    export LD_LIBRARY_PATH=/mnt/sd*1:/tmp:$LD_LIBRARY_PATH
    export XCL_EMULATION_MODE=sw_emu
    export XILINX_XRT=/usr
    ```

7. Run the PS application using `./host.exe a.xclbin`.

    This will start running the host application and launch the GDB in a separate terminal as follows:
![gdb console](./Images/gdb_console.PNG)

8. Place breakpoints in the `s2mm`, `mm2s`, and `peak_detect` functions as follows, and run the application:

    ```
    (gdb) b s2mm
    Function "s2mm" not defined.
    Make breakpoint pending on future shared library load? (y or [n]) y
    Breakpoint 1 (s2mm) pending.
    (gdb) b mm2s
    Function "mm2s" not defined.
    Make breakpoint pending on future shared library load? (y or [n]) y
    Breakpoint 2 (mm2s) pending.
    (gdb) b peak_detect:24
    No symbol table is loaded.  Use the "file" command.
    Make breakpoint pending on future shared library load? (y or [n]) y
    Breakpoint 3 (peak_detect:24) pending.
    ```

9. Now type `r` to run the program, and observe it stops at the breakpoint in `mm2s`.

    ```
    [Switching to Thread 0x7fffef7fe700 (LWP 45539)]

    Breakpoint 2, mm2s (mem=0x7ffff0007000, s=..., size=448)
        at /wrk/xhdhdnobkup4/viswanad/2023_1/11_4_git_viswa/Vitis-Tutorials/AI_Engine_Development/Feature_Tutorials/20-debug-walkthrough-new/2_cmd/_x/link/int/xo/mm2s/mm2s/cpu_sources/mm2s.cpp:34
    34              for(int i = 0; i < size; i++) {
    (gdb)
    ```

10. You can press `Ctrl`+`XA` in the GDB console, which opens the source code where the debugger stopped. Toggle using the same keyboard shortcut to come back to the original console.
11. Tpe `c` to continue execution, and observe it stops at the `s2mm` function now.
12. Type `c` again, and observe the breakpoint now hits at `peak_detect` function.
13. Type `next` to debug line by line, and observe variable values, e.g, max_out using `print max_out`.
14. Use all the `gdb debug` options and debug as mentioned in [x86simulation with the GDB](../X86_Simulation/README.md#x86simulation-with--the-GDB) section.
15. Type `d` to delete all breakpoints and `r` to complete the run.
16. Observe `Test Passed` in the Linux console.

## Support

GitHub issues will be used for tracking requests and bugs. For questions, go to [support.xilinx.com](https://support.xilinx.com/).

Copyright © 2020–2023 Advanced Micro Devices, Inc

Terms and Conditions

repository: Xilinx/Vitis-Tutorials

gha_language: C

repo_name: Xilinx/Vitis-Tutorials