text:
## Common issues

### `` Cannot find revision `X.X.X` -- Make sure that it exists in the remote repository `https://github.com/ccdmb/predector` ``

All of our code examples specify the pipeline version number, which is to ensure that the correct dependencies are used and it's always clear what is actually being run.

Unfortunately this can cause a few issues if you have previously run the pipeline using the same computer.
You can read about this in more detail in the section "[Running different pipeline versions](#running-different-pipeline-versions)".

Try the following steps to resolve the issue.

1. Double check that the specified version number is actually a tagged version of the pipeline (https://github.com/ccdmb/predector/tags).
2. Try re-running the pipeline with the `-latest` flag included. i.e. `nextflow run -r X.X.X -latest ccdmb/predector --proteome "proteomes/*"`.
3. Try pulling the updates down from GitHub with nextflow directly with the following command: `nextflow pull ccdmb/predector`. Then try re-running the pipeline.
4. Try asking nextflow to delete it's local copy of Predector from its cache with the following command: `nextflow drop ccdmb/predector`. Then try re-running the pipeline.

If you're still having problems after this, please either email us or raise an issue on GitHub.

### Running with docker `Unable to find image 'predector/predector:X.X.X' locally`

This usually means that you haven't built the docker image locally.
Remember that we cannot distribute some of the dependencies, so you need to build the container image and move it to where you'll be running.

Please check that you have the docker container in your local registry:

```bash
docker images
```

It's also possible that you built a different environment (e.g. conda or singularity).
Check `conda info -e` or for any `.sif` files where your source archives are.

Another possibility is that you are trying to run the pipeline using a container built for a different version of the pipeline.
Please check that the version tag in `docker images` is the same as the pipeline that you're trying to run.
Update the pipeline if necessary using `nextflow pull ccdmb/predector`.

### Running with singularity `ERROR : Failed to set loop flags on loop device: Resource temporarily unavailable`.

This is caused by nextflow trying to launch lots of tasks with the same singularity image at the same time.
Updating singularity to version >= 3.5 _should_ resolve the issue.

### `Connecting to XXX... failed: Connection timed out.`

We automatically download Pfam, dbCAN, and PHI-base by default while running the pipeline.
Sometimes these sources will be unavailable (e.g. for maintenance or they've just crashed),
and sometimes the URLs to these data will change.

It is possible for you to download these data separately, and provide the files to the pipeline as described [here](https://github.com/ccdmb/predector/wiki#providing-pre-downloaded-pfam-phi-base-and-dbcan-datasets).
If you find yourself running the pipeline often it might be a good thing to keep a downloaded copy handy.

In the case that the servers are down, unfortunately we can't do much.
But if the URL appears to have changed, we would appreciate it if you could please let us know so that we can resolve the issue.

### `ERROR ~ unable to resolve class XXX`

You may encounter this error if you are using an old version of Nextflow (pre v21).
We use the updated DSL2 syntax, which will cause older versions of Nextflow to raise errors looking like this...

```
ERROR ~ unable to resolve class download_phibase
@ line 7, column 5.
       download as download_phibase;
       ^

_nf_script_9f2a833e: 8: unable to resolve class download_pfam_hmm
@ line 8, column 5.
       download as download_pfam_hmm;
       ^

_nf_script_9f2a833e: 9: unable to resolve class download_pfam_dat
@ line 9, column 5.
       download as download_pfam_dat;
       ^
```

Please update Nextflow to a more recent version (>21) to resolve this issue.

### Running/setting up conda environment: `loadable library and perl binaries are mismatched (got handshake key 0xdb80080, needed 0xde00080)`

This will usually happen if the operating system you're running on has some perl libraries in the search path for a different version of perl.
Unfortunately because conda environments are not isolated from the host operating system like containers are, there isn't much we can do to avoid this.
The good news is that it's usually an easy fix.

Search your bash environment for `PERL5LIB` or `PERLLIB`. e.g.

```
env | grep -i "perl"
```

If either of these are set, it's likely that this is how perl is finding these incompatible options.
Try `unset`-ing these paths and try running again. e.g.

```
unset PERL5LIB
unset PERLLIB
```

If you are on a computer that uses `module`s to import software (e.g. many HPC clusters), check for any loaded perl modules
as these will usually set the above variables.

```
# Check for and loaded perl modules
module list

# unload any relevant perl modules e.g.
module unload perl
```

**Note** you will need to unset these environment variables anytime you restart
a new terminal session and want to use the conda environment.
Alternatively you can remove the default imports and environment variable settings e.g. in your `~/.bashrc` file to make changes permanent.

If unsetting the variables/unloading modules doesn't work, please let us know and we'll try to resolve the issue.
We'll need info about any set environment variables before and after loading the conda environment, and the specific conda packages installed.

e.g.
```
env > env_before_load.txt
conda activate predector
env > env_after_load.txt

conda list > conda_environment.txt
```

### Error while running signalp 6 `ValueError: zero-size array to reduction operation maximum which has no identity`

This is a known issue with some sequences and certain versions of SignalP 6.
Unfortunately we can't do much about this other than report the troublesome sequence(s) to the developers.

If you contact us or raise an issue we can do that for you.
Please include the sequences that are causing the issue and the exact version of SignalP 6 that you downloaded so that we can be most helpful.
Otherwise if you use GitHub you can raise an issue yourself in [their repository](https://github.com/fteufel/signalp-6.0) (note though that the code that's up there isn't actually what it distributed).
They also list contact emails in their [installation instructions](https://github.com/fteufel/signalp-6.0/blob/main/installation_instructions.md#bugs-and-questions).

As a temporary fix you can either re-run the pipeline using the `--no_signalp6` parameter, which will not run SignalP 6 on any sequences.
Alternatively, you can manually mark this chunk (internally we chunk the input into sets of `--chunk_size` unique sequences (default 5000)) as completed. This will only skip signalp6 for an individual chunk.

1) Find the working directory of the task from the error message.
It will look like this:
```
Work dir:
  /home/ubuntu/predector_analysis/work/7e/954be70138c4c29467945fade280ab
```

2) Set the exit code to 0 and create an empty output file:

```
DIR_CONTAINING_ERROR=/home/ubuntu/predector_analysis/work/7e/954be70138c4c29467945fade280ab

echo "0" > "${DIR_CONTAINING_ERROR}/.exitcode"
touch "${DIR_CONTAINING_ERROR}/out.ldjson"
```

3) Re-run the pipeline as you did before with the `-resume` option.

This should restart the pipeline and continue as if SignalP 6 hadn't failed (though it may still fail on a different chunk).
Note however that if you skip the analysis for one chunk, the manual ranking scores (and probably the learned ranking scores in the near future) won't be reliable (because the other chunks will have more information).

### Error while running a process with `Command exit status: 137`

The error-code usually means that you have run out of memory in a task.
At the time of writing this seems to happen when running SignalP 6 on relatively small computers (e.g. with <6GB RAM available).

General strategies for reducing memory usage are to reduce the `--chunk_size` to below 1000 (say 500).
Specifically for SignalP 6 you can also try reducing the `--signalp6_bsize` to 10.
You can read more about these parameters in the [Command line parameters section](#command-line-parameters).

If you encounter this issue in the final steps when producing the output and ranking tables, it may be the case that one of your input fasta files is very large.
As noted in the [running the pipeline section](#running-the-pipeline), Predector was designed to handle typical proteomes.
The number of proteomes doesn't really matter because internally we deduplicate and divide the inputs into chunks, but if one single input fasta has say >10e5 proteins, this can cause an issue if you don't have lots of RAM (I find that about 30GB is needed for a few million proteins).
If your proteins aren't split into proteomes (e.g you're running on a set downloaded from UniProt), it's best to split them yourself to batches of about 20000, and then concatenate the final tables yourself. We can guide you through dealing with this to make use of what you have already computed, so please get in touch.

If you encounter this issue with other processes please let us know.
We've done our best to keep peak memory use low for most tasks, but there may be cases that we hadn't considered.

### Installing with Mamba, `Problem: nothing provides __glibc >=2.17,<3.0.a0 needed by...`

This appears to happen with very old versions of Mamba, and was reported to us [here](https://github.com/ccdmb/predector/issues/77).
It appears that simply updating mamba will fix the problem.

```
conda update -n base -c conda-forge mamba
```

If this does not resolve the problem, please raise another [issue](https://github.com/ccdmb/predector/issues) or [contact us](https://github.com/ccdmb/predector#contact-us).

## FAQ

We'll update these as we find new issues and get feedback.
Please raise an issue on GitHub or email us if you have an issue not covered here.

### What do Predector "effector scores" actually mean?

It's best to think of the learning to rank scores (and the manually designed ranking scores) as arbitrary numbers that attempt to make effectors appear near the top of a sorted list.
The scores will not be consistent between different versions of the model, so please be careful if you're trying to compare scores.
Similarly, like with EffectorP the scores should not be treated as a 'likelihood'.
Although you can generally say that proteins with higher scores will be more like known effectors, the difference in "effector-ness" between 0 and 1 is not necessarily the same as it is between 1 and 2 (and so on).

In the paper for version 1 we present some comparisons with EffectorP classification using a score threshold of 0, but this is not how we suggest you use these scores and the threshold may not be applicable in the future if we change how the model is trained.
In general, it's best to look at some additional evidence (e.g. homologues, expression, or presence-absence) and manually evaluate candidates in descending order of score (i.e. using Predector as a decision support system) until you have enough to work with.

In the first version of the model, the predictions between 0 and 1 can contain some odd effector predictions.
This is because the model has tried to accomodate some unusual effectors, but the decision tree rules (with discontinuous boundaries) can let some things through that obviously aren't effectors.
If you delve into the proteins with lower scores we recommended that you manually evaluate the protein properties in the ranking sheet yourself to select candidates.

With Predector we really wanted to encourage you to look at your data.
Ranking separates the bulk of good proteins from bad ones, so it's easier to decide when to stop manually evaluating candidates and settle on a list.
Think of it like searching for papers on the web.
The first page usually contains something relevant to what you're interested in, but sometimes there are some gems in the 2nd and 3rd pages.

### How should I cite Predector?

The Predector pipeline and ranking method is published in [scientific reports](https://doi.org/10.1038/s41598-021-99363-0):

Darcy A. B. Jones, Lina Rozano, Johannes W. Debler, Ricardo L. Mancera, Paula M. Moolhuijzen, James K. Hane (2021). An automated and combinative method for the predictive ranking of candidate effector proteins of fungal plant-pathogens. _Scientific Reports_. 11, 19731, DOI: [10.1038/s41598-021-99363-0](https://doi.org/10.1038/s41598-021-99363-0)

Please also cite the dependencies that we use whenever possible.
I understand that citation limits can be an issue, but the continued maintenance development of tools relies on these citations.
If you absolutely must prioritise, I'd suggest keeping EffectorP, ApoplastP, Deepredeff, TargetP, TMHMM, and one of the SignalP papers, as these do most of the heavy lifting in the pipeline.
There is a [BibTeX](http://www.bibtex.org/Format/) formatted [file with citations in the main github repository](https://github.com/ccdmb/predector/citations.bib), which can be imported into most citation managers.
The dependency citations are also listed below.

- Almagro Armenteros, J. J., Sønderby, C. K., Sønderby, S. K., Nielsen, H., & Winther, O. (2017). DeepLoc: Prediction of protein subcellular localization using deep learning. Bioinformatics, 33(21), 3387–3395. https://doi.org/10.1093/bioinformatics/btx431
- Armenteros, Jose Juan Almagro, Salvatore, M., Emanuelsson, O., Winther, O., Heijne, G. von, Elofsson, A., & Nielsen, H. (2019). Detecting sequence signals in targeting peptides using deep learning. Life Science Alliance, 2(5). https://doi.org/10.26508/lsa.201900429
- Armenteros, José Juan Almagro, Tsirigos, K. D., Sønderby, C. K., Petersen, T. N., Winther, O., Brunak, S., Heijne, G. von, & Nielsen, H. (2019). SignalP 5.0 improves signal peptide predictions using deep neural networks. Nature Biotechnology, 37(4), 420–423. https://doi.org/10.1038/s41587-019-0036-z
- Di Tommaso, P., Chatzou, M., Floden, E. W., Barja, P. P., Palumbo, E., & Notredame, C. (2017). Nextflow enables reproducible computational workflows. Nature Biotechnology, 35(4), 316–319. https://doi.org/10.1038/nbt.3820
- Dyrløv Bendtsen, J., Nielsen, H., von Heijne, G., & Brunak, S. (2004). Improved Prediction of Signal Peptides: SignalP 3.0. Journal of Molecular Biology, 340(4), 783–795. https://doi.org/10.1016/j.jmb.2004.05.028
- Eddy, S. R. (2011). Accelerated Profile HMM Searches. PLOS Computational Biology, 7(10), e1002195. https://doi.org/10.1371/journal.pcbi.1002195
- Finn, R. D., Bateman, A., Clements, J., Coggill, P., Eberhardt, R. Y., Eddy, S. R., Heger, A., Hetherington, K., Holm, L., Mistry, J., Sonnhammer, E. L. L., Tate, J., & Punta, M. (2014). Pfam: The protein families database. Nucleic Acids Research, 42(Database issue), D222–D230. https://doi.org/10.1093/nar/gkt1223
- Teufel, F., Armenteros, J. A. A., Johansen, A. R., Gíslason, M. H., Pihl, S. I., Tsirigos, K. D., Winther, O., Brunak, S., von Heijne, G., & Nielsen, H. (2021). SignalP 6.0 achieves signal peptide prediction across all types using protein language models. bioRxiv. https://doi.org/10.1101/2<IP_ADDRESS>7770
- Käll, L., Krogh, A., & Sonnhammer, E. L. L. (2004). A Combined Transmembrane Topology and Signal Peptide Prediction Method. Journal of Molecular Biology, 338(5), 1027–1036. https://doi.org/10.1016/j.jmb.2004.03.016
- Kristianingsih, R., MacLean, D. (2021). Accurate plant pathogen effector protein classification ab initio with deepredeff: an ensemble of convolutional neural networks. BMC Bioinformatics 22, 372. https://doi.org/10.1186/s12859-021-04293-3
- Krogh, A., Larsson, B., von Heijne, G., & Sonnhammer, E. L. (2001). Predicting transmembrane protein topology with a hidden Markov model: Application to complete genomes. Journal of Molecular Biology, 305(3), 567–580. https://doi.org/10.1006/jmbi.2000.4315
- Petersen, T. N., Brunak, S., Heijne, G. von, & Nielsen, H. (2011). SignalP 4.0: Discriminating signal peptides from transmembrane regions. Nature Methods, 8(10), 785–786. https://doi.org/10.1038/nmeth.1701
- Rice, P., Longden, I., & Bleasby, A. (2000). EMBOSS: The European Molecular Biology Open Software Suite. Trends in Genetics, 16(6), 276–277. https://doi.org/10.1016/S0168-9525(00)02024-2
- Savojardo, C., Martelli, P. L., Fariselli, P., & Casadio, R. (2018). DeepSig: Deep learning improves signal peptide detection in proteins. Bioinformatics, 34(10), 1690–1696. https://doi.org/10.1093/bioinformatics/btx818
- Sperschneider, J., Catanzariti, A.-M., DeBoer, K., Petre, B., Gardiner, D. M., Singh, K. B., Dodds, P. N., & Taylor, J. M. (2017). LOCALIZER: Subcellular localization prediction of both plant and effector proteins in the plant cell. Scientific Reports, 7(1), 1–14. https://doi.org/10.1038/srep44598
- Sperschneider, J., Dodds, P. N., Gardiner, D. M., Singh, K. B., & Taylor, J. M. (2018). Improved prediction of fungal effector proteins from secretomes with EffectorP 2.0. Molecular Plant Pathology, 19(9), 2094–2110. https://doi.org/10.1111/mpp.12682
- Sperschneider, J., Dodds, P. N., Singh, K. B., & Taylor, J. M. (2018). ApoplastP: Prediction of effectors and plant proteins in the apoplast using machine learning. New Phytologist, 217(4), 1764–1778. https://doi.org/10.1111/nph.14946
- Sperschneider, J., Gardiner, D. M., Dodds, P. N., Tini, F., Covarelli, L., Singh, K. B., Manners, J. M., & Taylor, J. M. (2016). EffectorP: Predicting fungal effector proteins from secretomes using machine learning. New Phytologist, 210(2), 743–761. https://doi.org/10.1111/nph.13794
- Sperschneider, J., & Dodds, P. N. (2021). EffectorP 3.0: prediction of apoplastic and cytoplasmic effectors in fungi and oomycetes. bioRxiv. https://doi.org/10.1101/2<IP_ADDRESS>4080
- Steinegger, M., & Söding, J. (2017). MMseqs2 enables sensitive protein sequence searching for the analysis of massive data sets. Nature Biotechnology, 35(11), 1026–1028. https://doi.org/10.1038/nbt.3988
- Tange, O. (2020). GNU Parallel 20200522 ('Kraftwerk'). Zenodo. https://doi.org/10.5281/zenodo.3841377
- Urban, M., Cuzick, A., Seager, J., Wood, V., Rutherford, K., Venkatesh, S. Y., De Silva, N., Martinez, M. C., Pedro, H., Yates, A. D., Hassani-Pak, K., & Hammond-Kosack, K. E. (2020). PHI-base: The pathogen–host interactions database. Nucleic Acids Research, 48(D1), D613–D620. https://doi.org/10.1093/nar/gkz904
- Zhang, H., Yohe, T., Huang, L., Entwistle, S., Wu, P., Yang, Z., Busk, P. K., Xu, Y., & Yin, Y. (2018). dbCAN2: A meta server for automated carbohydrate-active enzyme annotation. Nucleic Acids Research, 46(W1), W95–W101. https://doi.org/10.1093/nar/gky418

repository: ccdmb/predector

gha_language: Shell

repo_name: ccdmb/predector


text:
# vim-gcss

Vim syntax highlighting for [GCSS](https://github.com/yosssi/gcss)

## Installation

Copy each directory to your ~/.vim directory.

license: MIT

repository: yosssi/vim-gcss

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: yosssi/vim-gcss


text:
# Auto Pull Request Merge

Fork of [KeisukeYamashita/auto-pull-request-merge](https://github.com/KeisukeYamashita/auto-pull-request-merge)

Support Merge Method with `merge-method`, default value is `'squash'`.

branch_name: refs/heads/main

gha_language: TypeScript

gha_license_id: MIT


text:
# ReisUnpack
This is an unpacker for resource files of [Renowned Explorers: International Society](http://renownedexplorers.com/) game.

This project is using [Lzham.Net managed wrapper](https://github.com/AndrewSav/Lzham.Net) of [lzham_codec](https://github.com/richgel999/lzham_codec).
This is the compression format used internally by the game.

.Net 4 is required to run. Built with Visual Studio 2015.

repository: AndrewSav/ReisUnpack

repo_name: AndrewSav/ReisUnpack


text:
title: ComicFury/Wayofthemetagamer
url: "/comics/ComicFury_Wayofthemetagamer.html"
---
Dosage comic ComicFury/Wayofthemetagamer
-----------------------------------------

Description	Bob buys the Dungeons and Dragons book off eBay. Hilarity ensues. Plot follows. Also tropes. Lots and lots of tropes. Also no fourth wall. Actually, it's mostly about the lack of fourth wall. We probably should have mentioned that bit right at the top. Actually, yeah, move that to the top- you're writing this LIVE?

Website	http://wayofthemetagamer.webcomic.ws/

Genre	Other

Language	English

Adult content	no

Status	ok on 26.05.2013

Votes	0

[Edit this info](ComicFury_Wayofthemetagamer_edit.html) or go back to the [comic list](../comic-index.html).

repository: pataluc/dosage

repo_name: pataluc/dosage


text:
# Load config (GitHub Action)

Simple action for reading configuration provided as JSON or YAML and make it available as outputs for later use in the workflow.

## Example

Configuration (JSON):

```json
{
  "version": "1.0"
}
```

Configuration (YAML):

```yaml
version: 1.0
```

Workflow definition:

```yaml
name: Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v2

      - name: Load configuration
        id: config
        uses: klakegg/ghaction-config@master
        with:
          path: config.yaml

      - name: Verify
        env:
          VERSION: ${{ steps.config.outputs.version }}
        run: echo $VERSION
```

repository: klakegg/ghaction-config

repo_name: klakegg/ghaction-config


text:
# arduino-slack-api
An arduino library to wrap the Slack API

Currently the library supports updating your Presence and setting a Custom Status.

![img](https://i.imgur.com/UUIQj2P.jpg)

## Help support what I do!

I have created a lot of different Arduino libraries that I hope people can make use of. [If you enjoy my work, please consider becoming a Github sponsor!](https://github.com/sponsors/witnessmenow/)

### Getting Auth Token (this may change)

- Create a new Slack App [here](https://api.slack.com/apps)
- Name your app anything, set the "Development Slack Workspace" to the workspace you want to update your status in
- This will bring you to a new page, on the left hand-side there is a menu. Click "OAuth & Permissions"
- Go down to "Scopes", then under "User Token Scopes", click the "Add an OAuth Scope" button
- Add the scopes you need. Here is a list of supported features in this library and their required scopes:

| Enpoint        | scope           |
| ------------- |-------------|
| setPresence      | users:write |
| setCustomStatus      | users.profile:write |

- scroll up to the top of the page and click "install app to workspace"
- Click "Allow" on the next page
- You will now have an OAuth Access Token up the top of the page, this is uses as the SLACK_ACCESS_TOKEN

repository: jaywgraves/arduino-slack-api

repo_name: jaywgraves/arduino-slack-api


text:
SUMMARY
=======

Simulation of a ball-clock that outputs the number of
days elapsed before the clock completely cycles through and resets its orginal state.

Better stated, the program computes the time before repetition, which varies according to the total number of balls present.

USAGE
=================
The program takes input from the command line flag parameters:

	# Run 30 balls through the ball clock cycle
	BallClock.exe -balls=30
	30 balls cycle after 15 days.

TESTS
=================
To run the unit tests:
	go test ./...

repository: bradyclifford/BallClock

repo_name: bradyclifford/BallClock


text:
# PullToRefreshAndLoadMore

一个实现了下拉刷新/加载更多的android组件。现支持ListView、GridView、RecyclerView、ScrollView、NestedScrollView和ExpandableListView的下拉刷新/加载更多功能。

# 该项目参考了（万分感谢）：

* [LoadingViewFinal](https://github.com/pengjianbo/LoadingViewFinal)
* [android-Ultra-Pull-To-Refresh](https://github.com/liaohuqiu/android-Ultra-Pull-To-Refresh)

#Gradle配置
    compile 'com.tan.pulltorefreshandloadmore:pulltorefreshandloadmore:0.2'

License
-------

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

repository: tanranran/PullToRefreshAndLoadMore

repo_name: tanranran/PullToRefreshAndLoadMore


text:
Generated from mail.py on 2023-04-12 10:09:44.563425

# peeringdb_server.mail

Utility functions for emailing users and admin staff.

# Functions
---

## mail_admins_with_from
`def mail_admins_with_from(subj, msg, from_addr, fail_silently=False, connection=None, html_message=None)`

Mail admins but allow specifying of from address.

---
## mail_username_retrieve
`def mail_username_retrieve(email, secret)`

Send an email to the specified email address containing
the url for username retrieval.

Arguments:
    - email <str>
    - secret <str>: username retrieval secret in the user's session

---
## mail_users_entity_merge
`def mail_users_entity_merge(users_source, users_target, entity_source, entity_target)`

Notify the users specified in users_source that their entity (entity_source) has
been merged with another entity (entity_target).

Notify the users specified in users_target that an entity has ben merged into their
entity (entity_target).

Arguments:
    - users_source <list>: list of User objects
    - users_target <list>: list of User objects
    - entity_source <HandleRef>: handleref object, entity that was merged
    - entity_target <HandleRef>: handleref object, entity that was merged into

---

repository: peeringdb/peeringdb

gha_language: Python

repo_name: peeringdb/peeringdb


text:
# NBA Fantasy App
This application is created and intended to be a NBA fantasy application.

# Getting Started
More details on starting the application when the application gets further into developement.

# Current Goals
* [ ] Finish Planning

* [ ] Login
    * [ ] Logging in with a username/password (maybe fb/google intergration)
    * [ ] Create Account
    * [ ] Forgot Password

* [ ] Dashboard
    * [ ] Leagues
        * [ ] Shows current account roster
        * [ ] ESPN News
        * [ ] Opponents teams
    * [ ] Trades
    * [ ] Starting a league
        * [ ] Name
        * [ ] Salary Cap
    * [ ] Joining a league

* [ ] Leagues / Standalone Component
    * [ ] Show all teams currently in league and their matchup

# Current Technologies Used
Will update this list as development continues.
Front-end: Bootstrap 4.6.0, Sass (Development)

# Current Deployment
Application is currently not deployed.

StoryBook Deployment (Chromatic): https://603217f50a693a00237cb703-ovvvtvdoto.chromatic.com/

# Authors
    * Jason Ouyang
    * Ivan Yu
    * Jason Hannanto
    * Jefferson Yan

# License
This project is licensed under the MIT License.

gha_language: JavaScript


text:
iterm-colors
================

Converts iTerm2's color schemes (plist files) to a JSON array useable in term.js and others

## Install

```
npm install -g iterm-colors
```

## Theme screenshots

**blazer**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/blazer.png)

**chalkboard**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/chalkboard.png)

**dark_pastel**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/dark_pastel.png)

**desert**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/desert.png)

**espresso**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/espresso.png)

**github**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/github.png)

**grass**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/grass.png)

**homebrew**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/homebrew.png)

**hurtado**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/hurtado.png)

**idletoes**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/idleToes.png)

**kibble**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/kibble.png)

**man_page**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/man_page.png)

**monokai_soda**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/monokai_soda.png)

**neopolitan**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/neopolitan.png)

**novel**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/novel.png)

**ocean**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/ocean.png)

**pro**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/pro.png)

**red_sands**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/red_sands.png)

**seafoam_pastel**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/seafoam_pastel.png)

**solarized_darcula**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/solarized_darcula.png)

**solarized_dark**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/solarized_dark.png)

**solarized_light**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/solarized_light.png)

**symfonic**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/symfonic.png)

**terminal_basic**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/terminal_basic.png)

**vaughn**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/vaughn.png)

**zenburn**

![Screenshot](https://github.com/AaronO/iterm-colors/raw/master/screenshots/zenburn.png)

## Example

### Binary

```bash
$ iterm-colors ~/Downloads/Monokai.itermcolors
["#615d4c","#e53865","#a8ff60","#ddcf69","#6bcce6","#ef8930","#9879f9","#eeeeee","#615d4c","#e53865","#a8ff60","#ddcf69","#6bcce6","#ef8930","#9879f9","#eeeeee"]
$
```

### Library

```js
// Core fs module
var fs = require('fs');

// iterm-colors module/function
var icolors = require('iterm-colors');

// ansiColors will be an array of hex colors for each ainsi color
// in the .itermcolors file
var ansiColors = icolors(fs.readFileSync('SOME_FILE_PATH.itermcolors'));

```

### Library (bundle access)

```js
// iterm-colors module/function
var bundle = require('iterm-colors/bundle.json');

// Github's theme
bundle.github;

// Monokai theme
bundle.monokai_soda;

...
```

## Disclaimer

The original `iTerm2` colorschemes (and screenshots) were sourced from here : https://github.com/mbadolato/iTerm2-Color-Schemes.

repository: AaronO/iterm-colors

repo_name: AaronO/iterm-colors


text:
# AttachPicker

[![CI Status](https://img.shields.io/travis/Dmitriy Polyakov/AttachPicker.svg?style=flat)](https://travis-ci.org/Dmitriy Polyakov/AttachPicker)
[![Version](https://img.shields.io/cocoapods/v/AttachPicker.svg?style=flat)](https://cocoapods.org/pods/AttachPicker)
[![License](https://img.shields.io/cocoapods/l/AttachPicker.svg?style=flat)](https://cocoapods.org/pods/AttachPicker)
[![Platform](https://img.shields.io/cocoapods/p/AttachPicker.svg?style=flat)](https://cocoapods.org/pods/AttachPicker)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

AttachPicker is available through [CocoaPods](https://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'AttachPicker'
```

## Author

Dmitriy Polyakov<EMAIL_ADDRESS>
## License

AttachPicker is available under the MIT license. See the LICENSE file for more info.

repository: DPLibs/AttachPicker

repo_name: DPLibs/AttachPicker


text:
---
layout: post
title: How to get directory name of the page currently displaying
date: 2007-11-06 06:40
comments: true
categories:
- c#
- .net
- asp.net
---
If you want to know only the directory name not the full path of the page that is currently displaying you can use this code

{% codeblock lang:c#%}
string sPath = System.Web.HttpContext.Current.Request.Url.AbsolutePath;
System.IO.FileInfo oInfo = new System.IO.FileInfo(sPath);
string sRet = oInfo.Directory.Name.ToString();
Response.Write("

Directory name===" + sRet + "

");
{% endcodeblock %}

Happy Coding

Najam Sikander Awan


text:
## Table of Contents

  * [Description](#description)
  * [Installation](#installation)
  * [Usage](#usage)
  * [License](#license)
  * [Questions](#questions)

# Professional Readme Generator
![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)

## Description
The Readme generator is a command-line application that dynamically generates a professional README.md file from a user's input using the Inquirer package.

 ## Walkthrough video
  Please view the walkthrough of this application at this link: [Video Link](https://drive.google.com/file/d/1NrC2w9OwnrJpvWDwuNNUsYqvfXM8x6AU/view)

## Installation
In this application you will need to node.js, the 'fs' and Inquirer NPM packages.

## Usage
You can quickly and easily generate a README file by using a command-line application to generate one. This allows the project creator to devote more time working on the project.

## License
This project is licensed under MIT(https://opensource.org/licenses/MIT)

## Questions

contact info:
  - GitHub: https://github.com/mmelendez3
  - Email me with questions<EMAIL_ADDRESS>


text:
---
title: Stencil State Tunnel
description:
url: /docs/state-tunnel
contributors:
  - jthoms1
  - danawoodman
  - shreeshbhat
---

# Stencil State Tunnel

This project was built to provide additional functionality to developers working with stencil
components and sharing state across components and through slots. The API was inspired by React's Context.

There are many cases within component library where you will want to drill state down through props to children and children's children and so on. This project was created in order to alleviate the need for passing props deep through an application's component structure.

There is one primary use case where this tool makes sense.

**Building a collection of components** that need to share state but have no direct 'line of sight' between the component relationships (ie most likely from using `slot`).

If you are building an application then you would be better served using [stencil-redux](./redux)

1. [Create a Tunnel.](#1-create-a-tunnel)
2. [Pass state to the Tunnel's Provider Component.](#2-pass-state-to-the-tunnls-provider-component)
3. [Place your state consumption points.](#3-place-your-state-consumption-points)

## 1. Create a tunnel.

Define the structure of data to be passed through the tunnel. The first argument of [createProviderConsumer](createProviderConsumer) is a default value.
The first argument is the default value and the second argument is how the consumer works.  Mostly you will just need
to copy and paste this. 'context-consumer' is a component that is included in this package.

```tsx
// Filename: './data/message.tsx'

import { createProviderConsumer } from '@stencil/state-tunnel';

export interface State {
  message: string,
  increment?: () => void
}

export default createProviderConsumer<State>({
    message: 'Hello!'
  },
  (subscribe, child) => (
    <context-consumer subscribe={subscribe} renderer={child} />
  )
);
```

## 2. Pass state to the tunnel Provider Component.
Usually this will be at the top of your component tree. Think of this as a way to take state from the parent
component and then make it available to components further down the tree. That is essentially what the [Provider Component](Provider-Component) does.

```tsx
// Filename: './components/my-app.tsx'

import Tunnel from './data/message'; // Import the Tunnel

@Component({
  tag: 'my-app',
})
export class MyApp {

  @Prop() intro: string = 'Hello!';
  @State() message: string = '';

  count: number = 0;

  componentWillLoad() {
    this.increment();
  }

  increment = () => {
    this.count = this.count + 1;
    this.message = `${this.intro} ${this.count}`;
  }

  render() {
    const tunnelState = {
      message: this.message,
      increment: this.increment
    };
    return (
      <div>
        <header>
          <h1>Stencil App Starter</h1>
        </header>
        <Tunnel.Provider state={tunnelState}>
          <some-child-component/>
        </Tunnel.Provider>
      </div>
    );
  }
}
```

## 3. Place your state consumption points.
You can then create an exit point anywhere within your component tree that lives below the `Tunnel.Provider`. In this case we are accessing the state using a [Consumer Component](Consumer-Component). There are other approaches to consuming the information but in most cases within an application you will use a Consumer Component.

```tsx
// Filename: './components/way-down-child.tsx'

import { Component, h } from '@stencil/core';
import Tunnel from './data/message'; // Import the tunnel

@Component({
  tag: 'way-down-child',
})
export class WayDownChild {
  render() {
    return (
      <Tunnel.Consumer>
        {({ message, increment }) => (
          <div class='app-profile'>
            <button onClick={increment}>Increment Num</button>
            <p>{message}</p>
          </div>
        )}
      </Tunnel.Consumer>
    );
  }
}
```

## 4. (Alternative to consumption points) Use Tunnel.injectProps.
Another approach to getting tunnel information into your components is by injecting the props using Tunnel.injectProps.

```tsx
import { Component, h } from '@stencil/core';
import Tunnel from './data/message'; // Import the tunnel

@Component({
  tag: 'way-down-child',
})
export class WayDownChild {
  // Define the props coming into the component
  @Prop() message: string = '';
  @Prop() increment: () => void;

  render() {
    return (
      <div class='app-profile'>
        <button onClick={increment}>Increment Num</button>
        <p>{message}</p>
      </div>
    );
  }
}
/*
 * Use the injectProps method to pass from the tunnel
 * as props to the component
 */
Tunnel.injectProps(WayDownChild, ['message', 'increment']);
```

repository: dgautsch/stencil-site

repo_name: dgautsch/stencil-site


text:
# grunt-htmlclean

This [Grunt](http://gruntjs.com/) plugin is wrapper of [htmlclean](https://github.com/anseki/htmlclean).

* [gulp](http://gulpjs.com/) plugin: [gulp-htmlclean](https://github.com/anseki/gulp-htmlclean)
* [webpack](http://webpack.github.io/) loader: [htmlclean-loader](https://github.com/anseki/htmlclean-loader)

**If you want to just clean files, [Command Line Tool](https://github.com/anseki/htmlclean) is easy way.**

Simple and safety HTML/SVG cleaner to minify without changing its structure.

For example, more than two whitespaces (even if those are divided by tags) in a line are reduced.

Before:

```html
<p>The <strong> clean <span> <em> HTML is here. </em> </span> </strong> </p>
```

After:

```html
<p>The <strong>clean <span><em>HTML is here.</em></span></strong></p>
```

The whitespace that was on the right side of the `<strong>` was removed, and one on the left side was kept. And whitespaces on the both side of the `<em>` were removed.

For example, unneeded whitespaces in path data of SVG are reduced. In the case of this SVG file, 4,784 bytes were reduced:

<img src="https://rawgit.com/anseki/grunt-htmlclean/master/Ghostscript_Tiger.svg" width="300" height="300">

## Removing

htmlclean removes following texts.

+ Leading and trailing whitespaces (tabs and line-breaks are included)
+ Unneeded whitespaces between HTML/SVG tags
+ More than two whitespaces (reduced to one space)
+ HTML/SVG comments
+ Unneeded whitespaces, meaningless zeros, numbers, signs, etc. in path data of SVG (e.g. `d` attribute of `path` element, `path` attribute of `animateMotion` element, etc.)

## Protecting

Following texts are protected (excluded from [Removing](#removing) list).

+ Texts in `textarea`, `script` and `style` elements, and text nodes in `pre` elements
+ Quoted texts in tag attributes except path data of SVG
+ Texts in SSI tags (PHP, JSP, ASP/ASP.NET and Apache SSI)
+ IE conditional comments (e.g. `<!--[if lt IE 7]>`)
+ Texts between `<!--[htmlclean-protect]-->` and `<!--[/htmlclean-protect]-->`
+ Texts that is matched by [`protect`](#protect) option

## More Information

See [htmlclean](https://github.com/anseki/htmlclean).

## Getting Started

This plugin requires Grunt `~0.4.1`

If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

```shell
npm install grunt-htmlclean --save-dev
```

Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:

```js
grunt.loadNpmTasks('grunt-htmlclean');
```

## The "htmlclean" task

### Overview

In your project's Gruntfile, add a section named `htmlclean` to the data object passed into `grunt.initConfig()`.

```js
grunt.initConfig({
  htmlclean: {
    options: {
      protect: /<\!--%fooTemplate\b.*?%-->/g,
      edit: function(html) { return html.replace(/\begg(s?)\b/ig, 'omelet$1'); }
    },
    deploy: {
      expand: true,
      cwd: 'develop/',
      src: '**/*.html',
      dest: 'public_html/'
    }
  }
});
```

See [htmlclean](https://github.com/anseki/htmlclean) for options and more information.

## Working with grunt-task-helper

For example, you want to clean only changed HTML files. Then [grunt-task-helper](https://github.com/anseki/grunt-task-helper) helps it. In this case, using `handlerByContent` Function instead of this plugin is better. Because grunt parses `files` components in every tasks(targets). `handlerByContent` can be included to one task with other handlers (e.g. select changed HTML files).
See [grunt-task-helper](https://github.com/anseki/grunt-task-helper).

Example:

`Gruntfile.js`

```js
grunt.initConfig({
  taskHelper: {
    deploy: {
      options: {
        // Select files which are newer than `dest`.
        handlerByFile: 'newFile',
        // Clean the selected files.
        handlerByContent: require('grunt-htmlclean/node_modules/htmlclean')
        //handlerByContent: require('htmlclean') // If htmlclean is already installed. (Not grunt-htmlclean)
      },
      expand: true,
      cwd: 'develop/',
      src: '**/*.html',
      dest: 'public_html/'
    }
  }
});
```

repository: website-company/pbd

branch_name: HEAD

repo_name: website-company/pbd


text:
---
layout: about
title: about
permalink: /
subtitle:  PhD Student • Web Intelligence Group (WI) • UCL Centre for Artificial Intelligence • UCL

profile:
  align: right
  image: prof_pic.jpg
  image_circular: false # crops the image to make it circular
  address: >

<a href="mailto:hossein.rahmani.22<EMAIL_ADDRESS>
<a href="mailto:rahmanidashti<EMAIL_ADDRESS>
UCL AI Centre
 90 High Holborn
 University College London

news: true  # includes a list of news items
selected_papers: true # includes a list of papers marked as "selected={true}"
social: true  # includes social icons at the bottom of the page
---

 I am a first-year PhD student in Computer Science at the University College London (UCL), affiliated with Web Intelligence Group (WI) at UCL Centre for Artificial Intelligence (UCL AI Center). I am fortunate to be advised by Prof. Emine Yilmaz and Nick Craswell. I am working on problems at the intersection of Machine Learning and Information Retrieval. My research interests are mainly in recommender systems, bias and fairness, and conversational systems.

 Prior to that, I obtained my MSc in Computer Science from University of Zanjan (ZNU), where I was advised by Prof. Mohsen Afsharchi and Dr. Mitra Baratchi (co-supervisor from Leiden University) and worked on context-aware recommender systems. I received my B.Sc. degree from the University of Zanjan.

[CV] [Google Scholar]


text:
---
layout:      post
title:       "Running a Raspberry Pi cluster, a few months after"
subtitle:    ""
date:        2018-11-05 12:00:00
update-date: 2018-11-05 12:00:00
author:      "Alexandre"
comments:    True

---

After a few months running my cluster, here are my impressions.

## Successes

[Running Gogs](/2018/09/14/installing-gogs-kubernetes-raspberry-pi/) was super easy.
I am happy with the setup and started to migrate my private repositories from GitHub to it.

I set up Traefik as the `IngressController` and it's been working flawlessly. It allows me to
have public urls such as gogs.home.achntrl.com that redirect to HTTPS
with a Let's Encrypt certificate.

Huge shoutout to [Chris Evans](https://medium.com/@evnsio/managing-my-home-with-kubernetes-traefik-and-raspberry-pis-d0330effea9a) for
his instructions on how to setup Traefik and the script to automatically update DNS records.

I used [rak8s](https://github.com/rak8s/rak8s) to automate the cluster creation.
I [customized it to my configuration](https://github.com/achntrl/rak8s). I tried it by recreating the cluster
from a fresh Raspbian install and it worked well. I'm not afraid of losing my
whole cluster anymore.

I also built a Docker image for Datadog agent that I use to monitor my cluster (disclaimer: I work at Datadog, but this
is not officially supported by Datadog). The image can be found [here](https://hub.docker.com/r/achntrl/datadog-agent).

## Problems

I faced problems regarding RAM usage. Kubernetes recommends 2GB or more of RAM per machine. The Raspberry Pis only have 1GB of RAM, and we can feel it on the master node.

![]({{ site.baseurl }}/img/ram-usage.png)

All slave nodes hovered around 500MB of free RAM, but the master node was at 100MB or less. Often, the controller manager or the scheduler died (every 7 minutes on average!). It seems to be caused by pod
eviction when the RAM is low (by default it's when free RAM hit 100MB or less). I tried to push the
eviction limit to 50MB. That improved a bit but I was still seeing evictions

```console
$ k get pods -n kube-system

NAME                                          READY   STATUS    RESTARTS   AGE
coredns-576cbf47c7-slsrt                      1/1     Running   34         3d14h
coredns-576cbf47c7-w88wt                      1/1     Running   40         3d14h
etcd-k8s-master                               1/1     Running   24         3d14h
kube-apiserver-k8s-master                     1/1     Running   32         3d14h
kube-controller-manager-k8s-master            1/1     Running   715        3d14h
kube-proxy-2nfrw                              1/1     Running   2          3d14h
kube-proxy-8gnd4                              1/1     Running   0          3d14h
kube-proxy-df2jk                              1/1     Running   0          3d14h
kube-proxy-nsdbn                              1/1     Running   0          3d14h
kube-scheduler-k8s-master                     1/1     Running   539        3d14h
kube-state-metrics-5458647bbf-9zjgr           2/2     Running   0          2d22h
kubernetes-dashboard-58446cb7fb-c8dq5         1/1     Running   2          3d14h
metrics-server-5584697594-hwdnd               1/1     Running   0          2d18h
traefik-ingress-controller-64c7fdf956-pv8zc   1/1     Running   0          3d3h
weave-net-4tqwg                               2/2     Running   0          3d14h
weave-net-58ckw                               1/2     Running   6          3d14h
weave-net-5l2tz                               2/2     Running   0          3d14h
weave-net-9spwt                               2/2     Running   0          3d14h
```

It was also the cause of a high read activity on the master node at around 12MB/s and problems with a `CronJob` that wasn't properly scheduled.

To fix this, I ordered a bigger board, with 2GB of RAM to run the master node.
I went with the ASUS Tinker Board because it is also an ARM board and I was available
for next-day delivery (approx. €65).

![]({{ site.baseurl }}/img/tinker-board.jpg)

The card is more aesthetic and the SD card slot is push to eject!

Raspbian won't boot on it so I flashed Armbian on the SD card. I had to tweak the rak8s playbook
to properly disable the swap on it, but after that, no more pod eviction. I have about 1.2GB usable
on the master node and 0 kbps reads.

## Next projects

- Measure humidity and temperature in my appartment and send them to a Datadog dashboard with Dogstatsd. I ordered some NodeMCU and DHT22 on Aliexpress but they will take time to arrive :(
- Find a way to rate limit my url with basic auth to prevent brute force attack / DDoS

extension: markdown


text:
Routes 🗺
========
[![Build Status](https://travis-ci.org/min/Routes.svg?branch=master)](https://travis-ci.org/min/Routes)
[![CocoaPods Compatible](https://img.shields.io/cocoapods/v/Routes.svg)](https://img.shields.io/cocoapods/v/Routes.svg)
[![Carthage Compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)

This library is a Swift port/fork of the popular Objective-C library [JLRoutes](https://www.github.com/joeldev/JLRoutes). Much ❤ and credit goes to [joeldev](https://www.github.com/joeldev) for creating such a delightful routing library.

Routes is a pure-Swift URL routing library with a simple block-based API. It is designed to make it very easy to handle complex URL schemes in your application with minimal code.

### Installation ###

#### [Carthage](https://github.com/Carthage/Carthage) (recommended)

Add **Routes** to your `Cartfile`:
```
github "min/Routes"
```

#### CocoaPods

Add **Routes** to your `Podfile`:
```
pod 'Routes'
```

### Requirements ###
- iOS 9.0+ / tvOS 9.0+ / watchOS 2.0+
- Swift 4.2

### Getting Started ###

[Configure your URL schemes in Info.plist.](https://developer.apple.com/library/ios/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/Inter-AppCommunication/Inter-AppCommunication.html#//apple_ref/doc/uid/TP40007072-CH6-SW2)

```swift

class AppDelegate: UIResponder, UIApplicationDelegate {
    let router: Router = Router()

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        router.default.add(pattern: "/user/view/:user_id") { parameters in
            let userId = parameters["user_id"]

            // present UI for viewing user with userId
        }
        return true
    }

    func application(_ app: UIApplication, open url: URL, options: [UIApplicationOpenURLOptionsKey : Any] = [:]) -> Bool {
        return router.route(to: url)
    }
}

```

After adding a route for `/user/view/:user_id`, the following call will cause the handler block to be called with a dictionary containing `{"user_id": "min"}`:

```swift
router.route(to: "myapp://user/view/min")
```

### Handler Block Chaining ###

The handler block is expected to return a boolean for if it has handled the route or not. If the block returns `false`, Routes will behave as if that route is not a match and it will continue looking for a match. A route is considered to be a match if the pattern string matches **and** the block returns `true`.

It is also important to note that if you pass nil for the handler block, an internal handler block will be created that simply returns `true`.

### Schemes ###

Routes supports setting up routes within a specific URL scheme. Routes that are set up within a scheme can only be matched by URLs that use a matching URL scheme. By default, all routes go into the global scheme.

```swift
let router = Router()

router.default["home"] = { parameters in
    // This block is called if the scheme is not 'alpha' or 'beta' (see below)
    return true
}

router.alpha["home"] = { parameters in
    // This block is called for alpha://home
    return true
}

router.beta["home"] = { parameters in
    // This block is called for beta://home
    return true
}
```

This example shows that you can declare the same routes in different schemes and handle them with different callbacks on a per-scheme basis.

Continuing with this example, if you were to add the following route:

```swift
router.default["/global"] = { parameters in
    return true
}
```

and then try to route the URL `alpha://global`, it would not match because that route has not been declared within the `alpha` scheme but has instead been declared within the global scheme (which we'll assume is how the developer wants it). However, you can easily change this behavior by setting the following property to `true`:

```swift
router.alpha.shouldFallback = true
```

This tells Routes that if a URL cannot be routed within the `alpha` scheme (aka, it starts with `alpha:` but no appropriate route can be found), try to recover by looking for a matching route in the global routes scheme as well. After setting that property to `true`, the URL `alpha://global` would be routed to the `/global` handler block.

### Wildcards ###

Routes supports setting up routes that will match an arbitrary number of path components at the end of the routed URL. An array containing the additional path components will be added to the parameters dictionary with the key `Definition.Keys.wildcard`.

For example, the following route would be triggered for any URL that started with `/wildcard/`, but would be rejected by the handler if the next component wasn't `joker`.

```swift
router.default.add(pattern: "/wildcard/*") { parameters in
    let components = parameters[Definition.Keys.wildcard]

    guard let component = components.first, component == "joker" else {
        return false
    }

    return true
}
```

### Optional Routes ###

Routes supports setting up routes with optional parameters. At the route registration moment, Routes will register multiple routes with all combinations of the route with the optional parameters and without the optional parameters. For example, for the route `/the(/foo/:a)(/bar/:b)`, it will register the following routes:

- `/the/foo/:a/bar/:b`
- `/the/foo/:a`
- `/the/bar/:b`
- `/the`

### License ###
MIT. See the [LICENSE](LICENSE) file for details.

repository: looseyi/Routes

repo_name: looseyi/Routes


text:
# FileSystem API

This directory contains part of the browser side implementation of various
filesystem related APIs, as well as interfaces to treat various types of native
and non-native filesystems mostly the same without having to worry about the
underlying implementation.

## Related directories

[`//content/browser/fileapi/`](../../../content/browser/fileapi) contains the
rest of the browser side implementation, while
[`blink/renderer/modules/filesystem`](../../../third_party/blink/renderer/modules/filesystem)
contains the renderer side implementation and
[`blink/public/mojom/filesystem`](../../../third_party/blink/public/mojom/filesystem)
contains the mojom interfaces for these APIs.

repository: Csineneo/Vivaldi

repo_name: Csineneo/Vivaldi


text:
# Asshault

![Screenshot](http://i.imgur.com/lzGBXrD.png)

Asshault is an in-browser action game started in 2013 to play around with [game feel](https://www.youtube.com/watch?v=AJdEqssNZ-U), or [juice](https://www.youtube.com/watch?v=Fy0aCDmgnxg). Juice, among other things, comprises effects such as camera shake, particles, and sounds.

This is a for-fun project! I get to do things I don't usually get to do: animations, sprites, sounds, game ideas and the like. As such, the code is *hacked together*, and should really be refactored from the current prototypal inheritance into an entity-component system.

Some of the more interesting features and optimisation techniques I've used/experimented with here include:

* Flexible upgrade system with constraints, along with a flexbox UI for available upgrades
* 3D camera shake; affects UI (CSS)
* Triple canvases, one for decals, one for drawing, and one for fading effects trails
* Proper HTML canvas resizing based off window size
* Simple spatial hash for faster collision detection
* JSON-based asset loading
* Simple sound system for playing sounds, with an audio compressor attached
* Simple sprite management and rendering system
* Dirty detection of text for rendering on canvases (big perf hit)
* Waves/levels
* Sprite-based effects
* Animated sprites
* Highlighting in-canvas objects on hover of HTML elements
* Dynamically throttling effects to get a target 60fps

## Running locally
1. Clone
2. Open `index.html` in a browser

repository: gyng/Asshault

repo_name: gyng/Asshault


text:
# UI-Luncher-2
https://luncher2-dg.netlify.com/

### An app that gives schools and communities an easy way to work together to provide school lunches to students of families who are unable to afford them on a regular basis.

## Getting Started

  *Schools sign up and create a profile to gain access to a dashboard that allows them to setup a list and donation goal.

  *People can donate anonymously or by creating a profile if they'd like to track their donations through the app.  Donors can donate to a   single school or multiple schools in a single transaction.

  *Schools will be notified when a donation has been made and when funding is available.

## Social Media

  *Follow on Facebook, Instagram, and Twitter to keep up with ongoing news with the app and to give feedback.


text:
---
sidebar_position: 5
---

# Receipts

### With [IAPHUB](https://www.iaphub.com)

IAPHUB is a service that takes care of the ios/android receipt validation for you, you can set up [webhooks](https://dashboard.iaphub.com/documentation/webhook) in order to get notifications delivered automatically to your server on events such as a purchase, a subscription renewal...

You can use it by calling the API manually to [process your receipt](https://dashboard.iaphub.com/documentation/api/post-receipt) or use the [react-native-iaphub](https://github.com/iaphub/react-native-iaphub) module that is just a wrapper of react-native-iap with IAPHUB built-in.

### With Google Play

For Android, you need separate json file from the service account to get the
`access_token` from `google-apis`, therefore it is impossible to implement serverless.

You should have your own backend and get `access_token`.
With `access_token` you can simply call `validateReceiptAndroid()` we implemented.
Further reading is [here](https://stackoverflow.com/questions/35127086) or refer to [example repo](https://github.com/Bang9/android-get-access-token-example).

### With App Store

#### Local Validation

Local on-device cryptographic validation is not currently supported. More details are here: https://developer.apple.com/documentation/appstorereceipts/validating_receipts_on_the_device

#### Validating with the App Store

> WARNING: This method is not recommended for production usage, and Apple explicitly warn against it in their docs: https://developer.apple.com/documentation/storekit/original_api_for_in-app_purchase/validating_receipts_with_the_app_store

This can be used as a convenience method for developing and testing receipt validation through the development lifecycle.

Currently, validating receipts with the App Store is possible locally using `validateReceiptIos()`.

- The first parameter, you should pass `transactionReceipt` which returns after `buyProduct()`.
- The second parameter, you should pass whether this is `test` environment.
  If `true`, it will request to `sandbox` and `false` it will request to `production`.

```ts
const receiptBody = {
  'receipt-data': purchase.transactionReceipt,
  password: '******', // app shared secret, can be found in App Store Connect
};
const result = await RNIap.validateReceiptIos(receiptBody, false);
console.log(result);
```

For further information, please refer to [guide](https://developer.apple.com/library/content/releasenotes/General/ValidateAppStoreReceipt/Chapters/ValidateRemotely.html).

Sometimes you will need to get the receipt at times other than after purchase.
For example, when a user needs to ask for permission to buy a product (`Ask to buy`
flow) or unstable internet connections.

For these cases we have a convenience method `getReceiptIOS()` which gets
the latest receipt for the app at any given time. The response is base64 encoded.

### iOS Purchasing process right way.

Issue regarding `valid products`

- In iOS, generally you are fetching valid products at App launching process.

  If you fetch again, or fetch valid subscription, the products are added to
  the array object in iOS side (Objective-C `NSMutableArray`).

  This makes unexpected behavior when you fetch with a part of product lists.

  For example, if you have products of `[A, B, C]`, and you call fetch function
  with only `[A]`, this module returns `[A, B, C]`).

  This is weird, but it works.

- But, weird result is weird, so we made a new method which remove all valid products.

  If you need to clear all products, subscriptions in that array, just call
  `clearProductsIOS()`, and do the fetching job again, and you will receive what
  you expected.

### Example backend (Node.js)

[Here](https://github.com/mifi/in-app-subscription-example) you can find an example backend for idempotent validating of receipts on both iOS/Android and storing and serving subscription state to the client.

repository: keshavkaul/react-native-iap

repo_name: keshavkaul/react-native-iap


text:
## Instructions
Just open the solution with Visual Studio for Windows, you might need to go to 'Project -> Retarget Solution' to make it work.

# graphicsFreeGlut
Graphics coursework based on FreeGlut and OpenGL

## Camera movement
- w - to move towards looking direction
- s - to move away from looking direction
- a/d - to move left or right
- q - to move in the Up direction, relative to looking direction
- e - to move in the Down direction, relative to looking direction
- m - to position the camera inside the monument (cannot move camera when in monument, but looking around still works)
- n - to position the camera to where it was before positioning it into the monument

## Statue animation
- z - to start/pause the statue skipping animation
- x - to reset the statue animation

## Monument animation
This only works when the camera is inside the monument!

- c - to pause/start the animation for the inner most ring
- v - to pause/start the animation for the middle ring
- b - to pause/start the animation for the outer most ring

## Sun and Moon animation
- 1 - to change the daylight condition
- 2 - to visualize the sun and moon as debugging spheres

repository: powerzaba/graphicsFreeGlut

repo_name: powerzaba/graphicsFreeGlut


text:
# Contribution Guidelines

### Issue

 1. Try [master](https://github.com/SortableJS/Sortable/tree/master/)-branch, perhaps the problem has been solved;
 2. [Use the search](https://github.com/SortableJS/Sortable/search?type=Issues&q=problem), maybe already have an answer;
 3. If not found, create example on [jsbin.com (draft)](https://jsbin.com/kamiwez/edit?html,js,output) and describe the problem.

---

### Pull Request

 1. Only request to merge with the [master](https://github.com/SortableJS/Sortable/tree/master/)-branch.
 2. Only modify source files, **do not commit the resulting build**

### Setup

 1. Fork the repo on [github](https://github.com)
 2. Clone locally
 3. Run `npm i` in the local repo

### Online one-click setup

You can use Gitpod (a free online VS Code-like IDE) for contributing, With a single click it'll launch a workspace and automatically:

- clone the Sortable repo.
- install the dependencies.
- run `npm run build:umd:watch`.

[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/SortableJS/Sortable/)

### Building

 - For development, build the `./Sortable.js` file using the command `npm run build:umd:watch`
 - To build everything and minify it, run `npm run build`
 - Do not commit the resulting builds in any pull request – they will be generated at release


text:
---
title: "Download iPhone ringtones"
slug: "download-iphone-ringtones"
date: "2007-07-05T08:17:38-06:00"
author: "fak3r"
categories:
- General
tags:
- apple
---

![iPhone](http://fak3r.com/wp-content/uploads/2007/07/phone.jpg)In a sure bid to quickly tap out out his bandwidth quota, Jason Romero posts a set of iPhone ringtones.  "_Until you are ready to shell out $600 for the new iPhone, you can trick out your current phone with the ringtones taken straight off of the iPhone. Dowload them [HERE](http://jasonromero.com/?p=40)._"  I'm a fan of the 'pinball' one, that may fit well on my Razr with the help of [moto4lin](http://moto4lin.sourceforge.net/wiki/Main_Page).


text:
# recreate-release

Delete previous release by `tag_name` or `release_name`. Then call `actions/create-release` to create it again.

# Params:
[actions/create-release](https://github.com/actions/create-release)

# Example:
```yaml
jobs:
  build:
    name: Recreate Release
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Recreate Release
        uses: GongT/actions-recreate-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: latest
          release_name: Release at ${{ github.ref }}
          body: |
            Changes in this Release
            - First Change
            - Second Change
          draft: false
          prerelease: false
```

## My usage:
* [GongT/wireguard-config-distribute](https://github.com/GongT/wireguard-config-distribute)

repository: GongT/actions-recreate-release

repo_name: GongT/actions-recreate-release


text:
# BackpackUI1

Style CRUD of Backpack Generator UI

## Prerequisite

Need to install Backpack to your Laravel project first following [this instruction](https://backpackforlaravel.com/docs/3.5/installation)

## Installation

Via Composer

``` bash
$ composer require laraviet/backpackui1
```

## Usage

In generated CRUD Controller, add below lines into end of setup() method

```
$this->crud->setListView('backpackui1::theme.list');
$this->crud->removeButtonFromStack('create', 'top');
```


text:
---
layout: post
title: All I know about JavaScript functions
categories:
- javascript
tags:
- javascript
- functions
excerpt: Amost all
date: 2019-08-30 08:21 +0100

---
# Almost all

JavaScript is all about functions,  it should be called FunctionScript. Functions are just... functions, reusable pieces of code. When we use them in the context of an object ( class ), we call them methods. We never call them routines in any case, please don't.

## Simple function
Declaring simple function is straightforward in javascript. You don't need to call it main, you do not need a class around it. Just write a function declaration.

When that comes in all languages when we declare a function, elements that we declare to be passed to such function are called parameters. When we call a function, whatever we pass the time of call, we call arguments. Why? I don't know... but if someone asks you on an interview it's better to know.

```javascript
// Function declaration
function functionName(parameter1, parameter2) {
    console.log(arguments.length);
}

//calling a function
let argument1 = 1;
let argument2 = 2;
functionName(argument1, argument2)
```

There are few simple spacing rules when writing a function declaration in JavaScript. Two most important:

1. There should be **no** space after the name
2. There should be a space after the parenthesis, always.

Those simple rules help us very quickly indentify if a function is named or anonymous.
```javascript
// Function declaration
//                     never a space after name
//  statement   name  /  always spaces after ()
// /           /     /  /
function functionName() {}
```

Anonymous functions are simply functions without a name, very useful in JavaScript when programming in a functional way.

```javascript
//        always a space
//       /
function () {/* code */}
```

An anonymous function can be assigned to a variable, and therefore get a name as well.

```javascript
// Function expression
let functionWithTwoNames = function () {}
```
Functions can be also named inside objects:
```javascript
let user = {
  name: 'Joe',
  printName: function () {
	console.log(this.name);
  }
}

user.printName(); // 'Joe'
```

There is also a function constructor. This, yet another, way of creating a function in javascript is useful for code generation. We can construct a function body dynamically based on our program need and create a function on the fly.

```javascript
let buildFunction = function (operation) {
  let functionBody = `return a ${operation} b`;
  return new Function('a', 'b', functionBody);
}

let sum = buildFunction('+')
sum(1, 2); // 3

let sub = buildFunction('-');
sub(2, 1); // 1
```

Real-life example? [Microtemplating](https://johnresig.com/blog/javascript-micro-templating/) described by John Reising author of jQuery.

## Function as 'classes'
Functions are also constructors and can be used to create instances of objects using `new` operator.

```javascript
function User(name) {
    this.name = name;

    this.welcomeUser = function () {
      return "Hello " + this.name;
    }
}

let user = new User("Joe");

user.welcomeUser();

user.welcomeUser //public

```
Using the above method all class members assigned to `this` are public. Can we have private functions? Yes, we can.

```javascript
function Calculator(name) {
  function sum(p1, p2) {
    return p1 + p2;
  }
  function sub(p1, p2) {
    return p1 - p2;
  }
  this.calculate = function (p1, p2, op) {
    switch(op) {
      case '+':
        return sum(p1, p2);
        break;
      case '-':
        return sub(p1, p2);
        break;
    }
  }
}

let calc = new Calculator();

calc.calculate(2, 2, '-')

calc.sum(2, 2); //💥Boom 💀sum is not a function error
```
What we used above is a closure, it's a way in Javascript to encapsulate part of the code inside a function so the only subset of the program has access to them. For the rest of the code, those methods do not exist.

## Classes
But, javascript has `class` operator right? Why not use this. Well yes, that's what we would normally do these days. But it's important to know that `class` operator is just syntactic sugar, the output is still a function.

```javascript
class User {
  constructor(name) {
    this.name = name;
  }
  reverseName() {
    return this.name.split('').reverse().join('');
  }
  sayHi() {
    return 'Hello ' + this.reverseName();
  }
}

let user = new User('Joe')
user.sayHi();
```
Unfortunately, at this moment there are no private methods in Javascript. You still need to
Closures! There is a proposal for using `#` to mark functions and properties as private, but they are experimental and not available at the moment:

```javascript
class User {
  #name; //private
  constructor (name) {
	  this.name = name;
  }
  #sayHi() { /*...*/ } //privatre method
}
```

Above code does not execute in any of the current browsers.

## Closures

Closures, or colloquially, functions inside functions. This is bread and butter of Javascript programming, and you know to know them!

Closures deserve an article on their own, but I just mention them here since they are built using functions.

```javascript
function tagGeneratorFactory() {
  let pre = '<img src="';
  let post = '" />';
  return function tagGenerator(img) {
    return pre + img + post;
  }
}

let tg = tagGeneratorFactory();
tg("http://images.com/image.png");
```

Closures pitfalls

https://jsfiddle.net/demee/6ebsn9um/

```javascript
let numbers = [1, 2, 3, 4], i, element;

for(i = 0; i < numbers.length; i++) {
    element = document.createElement('div');

    element.innerHTML = numbers[i];

    element.addEventListener('click', function () {
        alert(numbers[i]);
        alert(i);
    });

    document.querySelector('body').appendChild(element);
};
```

IIFE (Immediately Invoked Function Expression).

```javascript
(function (global) {
    global.globalVariable = 'You should never declare global variables';
}(window || global))
```

Real life examples? Look at jQuery code.

Calling functions

```javascript
function crateOfBeer(x, y) {
  let beer = '';
  for( let i = 0; i < y; i++) {
    beer += '🍺'.repeat(x);
    beer += '\n';
  }

  return beer;
}

crateOfBeer(2,2);
crateOfBeer.call(this, 2, 2);
crateOfBeer.apply(this, [2,2])
```

gha_language: HTML


text:
# dovpanda
[![Build Status](https://travis-ci.org/guysmoilov/dovpanda.svg?branch=master)](https://travis-ci.org/guysmoilov/dovpanda)
[![Documentation Status](https://readthedocs.org/projects/dovpanda/badge/?version=latest)](https://dovpanda.readthedocs.io/en/latest/?badge=latest)

## Directions OVer PANDAs

Directions are hints and tips for using pandas in an analysis environment.
dovpanda is an overlay for working with pandas in an analysis environment.
If you think your task is common enough, it probably is, and Pandas probably has a built-in solution.
dovpanda is an overlay module that tries to understand what you are trying to do with your data, and help you
find easier ways to write your code.

## Usage
### Hints
The basic usage of `dovpanda` is its hints mechanism, which is very easy and out-of-the-box. Just import it after you import pandas
```python
import pandas as pd
import dovpanda
```
This is it. From now on you can expect `dovpanda` to come with helpful hints while you are writing you code.

### Example
```python
In [3]: df = pd.DataFrame({'a':list('xxyy'),'b':[40,50,60,70], 'time':['18:02','18:45','20:12','21:50']})
   ...: df['time'] = pd.to_datetime(df.time)
   ...: df['hour'] = df.time.dt.hour

In [4]: df.groupby('hour').b.sum()
===== Seems like you are grouping by a column named 'hour', consider setting the your
time column as index and then use df.resample('h') =====
Out[4]:
hour
18    90
20    60
21    70
Name: b, dtype: int64
```

### Notebook Support
Running `dovpanda` in a notebook environment will display rendered dismissable html.
<img width="800" alt="notebook display" src="https://user-images.githubusercontent.com/7852981/67240707-aee52e80-f45a-11e9-9f6b-8dca0b9af3d5.png">

## Advanced Usage
### Random Tips
`dovpanda.tip()` will give you a random `pandas` tip.

### Change Display
use `dovpanda.set_output` if you want to change output.

```python
In [14]: dovpanda.set_output('display')

In [15]: df.iterrows()
===== iterrows is not recommended, and in the majority of cases will have better alternatives =====
Out[15]: <generator object DataFrame.iterrows at 0x110fe4318>

In [16]: dovpanda.set_output('print')

In [17]: df.iterrows()
iterrows is not recommended, and in the majority of cases will have better alternatives
Out[17]: <generator object DataFrame.iterrows at 0x112c408b8>

In [18]: dovpanda.set_output('warning')

In [19]: df.iterrows()
WARNING:dovpanda:iterrows is not recommended, and in the majority of cases will have better alternatives
Out[19]: <generator object DataFrame.iterrows at 0x110ee7e58>

In [20]: dovpanda.set_output('off')

In [21]: df.iterrows()
Out[21]: <generator object DataFrame.iterrows at 0x1047c4d68>```

repository: guysmoilov/dovpanda

repo_name: guysmoilov/dovpanda


text:
# Better Cross-Domain Feature Disentanglement and Manipulation with Improved PuppetGAN

  Quite cool... Right?

CS 585 Final Project: PuppetGAN

## Introduction:
**PuppetGAN is** model that extends the CycleGAN idea and is **capable of extracting and manipulating features from a domain using examples from a different domain**. On top of that, one amazing aspect of PuppetGAN is that it **does not require a great amount of data**; (Giorgos Karantonis)
In addition to the MNIST dataset that the original repository used, we implemented the PuppetGAN algorithm on the SynAction and Weizamann datasets.

## Data Preparation
Training data:
- 1200 real images obtained by sampling every fourth frame in the Weizmann dataset videos
- 1200 synthetic pose images from the SynAction dataset
Validation data:
- 1000 synthetic images randomly sampled from the SynAction dataset
- 10 real images sampled from the Weizman dataset frames

In order to prepare your data for these experiments, download the SynAction and Weizmann datasets and store them in a folder. The data preparation script is syn_weiz_data.py. In this file edit the lines 49,50 to the correct paths to the folder where your data is located. You may proceed to run the script to prepare your dataset.

## Experiments and Results
We run a couple of experiments to get the PuppetGAN algorithm to correctly manipulate the poses from the SynAction images to the Weizmann images.

### Experiment 0:
In this experiment we trained the model on resized images (64x64) from the Weizmann real images without any masking.
In most of the generated images the pose is doesn’t look like it's related to the one in the corresponding synthetic image.
![6](https://user-images.githubusercontent.com/50864401/116167227-6c428900-a6c5-11eb-93eb-2ecabe2750b6.gif)

### Experiment 1:
We used a mask on the real images to get the person, we then and made a 128x128 image crop to create a region of interest around the person.The pose is a match to the synthetic image in some of the generated images where the camera perspective in both the input images is similar.
![6](https://user-images.githubusercontent.com/50864401/116167301-8da37500-a6c5-11eb-934f-6698e0404b6c.gif)

### Experiment 2:
 We increased the bottleneck dimension size of the generator to 256  to see the effects it has on the generated pose. It was an improvement over having the dimension size as 128.
 ![6](https://user-images.githubusercontent.com/50864401/116167418-c7747b80-a6c5-11eb-93f7-1b71a96febde.gif)

### Experiment 3:
We increased the bottleneck dimension size of the generator to 512  to see the effects it has on the generated pose. The apparent generated pose has significantly improved although the generated images are blurry.
![6](https://user-images.githubusercontent.com/50864401/116167490-f0950c00-a6c5-11eb-8701-3ca631c64e34.gif)

### Experiment 4:
We tightened the crop around the people in the weizman dataset to (86, 86) and resized the resulting image to (64, 64). The poses in the generated images are far richer in information than the previous versions.
![6](./.github/images/n2.gif)

### Experiment 5:
We noticed that there no activation function is being employed at the end of the discriminator, which is essentially a classifier. We added sigmoid activation function to it and also changed the loss to cross entropy from MSE. The generated poses are sharper than when sigmoid is not used.

![6 (1)](./.github/images/n1.gif)

### Training a Model
To extract frames from the weizann video dataset, run:

```bash
python3 extract_frames.py
```
All the necessary paths are annoted in the scripts, simply change them to desired values to get the frames. To prepare the dataset for training, run :

```bash
python3 syn_weiz_data.py
```

To start a new training, simply run:

```bash
python3 main.py
```

This will automatically look first for any existing checkpoints and will restore the latest one. If you want to continue the training from a specific checkpoint just run:

```bash
python3 main.py -c [checkpoint number]
```
or
```bash
python3 main.py --ckpt=[checkpoint number]
```

To help you keep better track of your work, every time you start a new training, a configuration report is created in [`./PuppetGAN/results/config.txt`](https://github.com/GiorgosKarantonis/PuppetGAN/blob/master/PuppetGAN/results/config.txt) which stores a detailed report of your current configuration. This report contains all your hyper-parameters and their respective values as well as the whole architecture of the model you are using, including every single layer, its parameters and how it is connected to the rest of the model.

Also, to help you keep better track of your process, every a certain number of epochs my model creates in `./PuppetGAN/results` a sample of [evaluation rows of generated images](https://github.com/GiorgosKarantonis/images/blob/master/PuppetGAN/mouth_baseline.png) along with [`gif` animations for these rows](https://github.com/GiorgosKarantonis/images/blob/master/PuppetGAN/mouth_baseline.gif) to visualize better the performance of your model.

On top of that, in `./PuppetGAN/results` are also stored plots of both the supervised and the adversarial losses as well as the images that are produced during the training. This allows you to have in a single folder everything you need to evaluate an experiment, keep track of its progress and reproduce its results!

Unless you want to experiment with different architectures, [`PuppetGAN/config.json`](https://github.com/GiorgosKarantonis/PuppetGAN/blob/master/PuppetGAN/config.json) is the only file you'll need. This file allows you to control all the hyper-parameters of the model without having to look at any of code! More specifically, the parameters you can control are:

* `dataset` : The dataset to use. You can choose between *"mnist"*, *"mouth"* and *"light"*.

* `epochs` : The number of epochs that the model will be trained for.

* `noise std` : The standard deviation of the noise that will be applied to the translated images. The mean of the noise is 0.

* `bottleneck noise` : The standard deviation of the noise that will be applied to the bottleneck. The mean of the noise is 0.

* `on roids` : Whether or not to use the proposed Roids.

* `learning rates`-`real generator` : The learning rate of the real generator.

* `learning rates`-`real discriminator` : The learning rate of the real discriminator

* `learning rates`-`synthetic generator` : The learning rate of the synthetic generator.

* `learning rate`-`synthetic discriminator` : The learning rate of the synthetic discriminator.

* `losses weights`-`reconstruction` : The weight of the reconstruction loss.

* `losses weights`-`disentanglement` : The weight of the disentanglement loss.

* `losses weights`-`cycle` : The weight of the cycle loss.

* `losses weights`-`attribute cycle b3` : The weight of part of the attribute cycle loss that is a function of the synthetic image that has both the Attribute of Interest and all the rest of the attributes.

* `losses weights`-`attribute cycle a` : The weight of part of the attribute cycle loss that is a function of the real image.

* `batch size` : The batch size. Depending on the kind of the dataset different values can be given.

* `image size` : At what size to resize the images of the dataset.

* `save images every` : Every how many epochs to save the training images and the sample of the evaluation images.

* `save model every` : Every how many epochs to create a checkpoint. Keep in mind that the 5 latest checkpoints are always kept during training.

### Evaluation of a Model
You can start an evaluation just by running:

```bash
python3 main.py -t
```
or
```bash
python3 main.py --test
```

Just like with training, this will look for the latest checkpoint; if you want to evaluate the performance of a different checkpoint you can simply use the `-c` and `--ckpt` options the same way as before.

During the evaluation process, the model creates all the [rows of the generated images](https://github.com/GiorgosKarantonis/images/blob/master/PuppetGAN/mouth_baseline.png), where each cell corresponds to the generated image for the respective synthetic and a real input. Additionally, for each of the evaluation images, [their corresponding `gif` file](https://github.com/GiorgosKarantonis/images/blob/master/PuppetGAN/mouth_baseline.gif) is also created to help you get a better idea of your results!

If you want to calculate the scores of your model in the `MNIST` dataset you can use my [`./PuppetGAN/eval_rotation.py`](https://github.com/GiorgosKarantonis/PuppetGAN/blob/master/PuppetGAN/eval_rotation.py) script, by running:

```bash
python3 eval_rotation.py -p [path to the directory of your evaluation images]
```
or
```bash
python3 eval_rotation.py -path=[path to the directory of your evaluation images]
```

You can also specify a path to save the evaluation report file using the option `-t` or `--target-path`. For example, let's say you have just trained and produced the evaluation images for a model and you want to get the evaluation scores for epoch 100 and save the report in the folder of this epoch. Then you should just run:

```bash
# make sure you are in ./PuppetGAN
python3 eval_rotation.py -p results/test/100/images -t results/test/100
```


text:
---
title: "Module parallel startup"
aliases: "/sofa-boot/docs/parallel-start"
---

SOFABoot will calculate the dependency tree based on the Require-Module. For example, the following dependency tree represents that Modules B and C depend on Module A, Module E depends on Module D, and Module F depends on Module E:

![undefined](module-parallel.png)

The dependency tree guarantees that Module A starts before Modules B and C, Module D before Module E, and Module E before Module F, but without defining the start orders between Modules B and C, or Modules B, C and Modules D, E and F, which can start either in serial or parallel.

SOFABoot will start the modules in parallel by default. During use, if you want to disable parallel start, you can add the following parameter to application.properties:

```java
com.alipay.sofa.boot.module-start-up-parallel=false
```

gha_language: SCSS


text:
# markdown template

## Text

It's very easy to make some words **bold** and other words *italic* with Markdown. You can even [link to Google!](http://google.com)

## Headers

# This is an <h1> tag
## This is an <h2> tag
###### This is an <h6> tag

## Emphasis

*This text will be italic*
_This will also be italic_

**This text will be bold**
__This will also be bold__

_You **can** combine them_

## Lists

- Unordered

* Item 1
* Item 2
  * Item 2a
  * Item 2b

- Ordered

1. Item 1
1. Item 2
1. Item 3
   1. Item 3a
   1. Item 3b

- Images

![GitHub Logo](/images/logo.png)
Format: ![Alt Text](url)

## Links

http://github.com - automatic!
[GitHub](http://github.com)

## Blockquotes

As Kanye West said:

> We're living the future so
> the present is our past.

## Inline code

I think you should use an
`<addr>` element here instead.

## Syntax highlighting

```javascript
function fancyAlert(arg) {
  if(arg) {
    $.facebox({div:'#foo'})
  }
}
```

## Task Lists

- [x] @mentions, #refs, [links](), **formatting**, and <del>tags</del> supported
- [x] list syntax required (any unordered or ordered list supported)
- [x] this is a complete item
- [ ] this is an incomplete item

## Tables

First Header | Second Header
------------ | -------------
Content from cell 1 | Content from cell 2
Content in the first column | Content in the second column


text:
# awesomeCrawler

> This will be the cornerstone of building the framework later

## Basic Component

- [x] Engine
- [x] Fetcher
- [x] Parser
- [ ] Storager

Engine: Core, responsible for task assignment and execution

Fetcher: Responsible for sending requests and getting website responses
> Fetcher Will Automatic decoding，When we use it, we just need to pass `Method`and `URL`

Parser: Parsing page to get data

Storager: Docking database or other

## Last
AwesomeCrawler is my first golang crawler model
Believe me, he will have many brothers and sisters
Let's look forward to it together

repository: Golzaes/awesomeCrawler

gha_language: Go

repo_name: Golzaes/awesomeCrawler


text:
# Maintainer Notes

This document contains miscellaneous notes for maintaining the package.

# Workflow

(See also https://www.swi-prolog.org/howto/Pack.txt)

If you change the github location, you'll need to send a message to
Jan Wielemaker<EMAIL_ADDRESS>to update the URL pattern to
`https://github.com/<user>/edcg/*` or similar.

  * `git clone https://github.com/kamahen/edcg.git`
    * Only needed once.
  * Verify the remote: `git remote -v`
  * `find t -name '*.pl' | xargs -L1 swipl -g run_tests -g halt`
  * Update version in files:
    * `History.md`
    * `pack.pl`
  * `git commit -m'...' -a`
  * `git tag v0.9.x`
  * `git push`
  * `git push --tags`
  * Verify the new release is in `https://github.com/kamahen/edcg/releases`
  * `swipl`
    * `pack_remove(edcg).`
    * `pack_install('https://github.com/kamahen/edcg/archive/v0.9.x.zip').`
    * `pack_remove(edcg).`
    * `pack_install(edcg). % Should get the new version`
  * Wait an hour, verify https://www.swi-prolog.org/pack/list?p=edcg

# Discussions

Discussion about modules and multi-file directives in edcg.pl:
https://swi-prolog.discourse.group/t/using-consult-in-a-directive-to-load-source-code-it-puzzles-me/2081

Discussion about the ==>> extension and guards:
https://swi-prolog.discourse.group/t/dcgs-with-single-sided-unification/3768

Note that logtalk has its own port, which avoids the `edcg:pred_info` multifile predicates.

repository: pablohirafuji/edcg

repo_name: pablohirafuji/edcg


text:
# Hipay Fullservice Sdk Magento 1 Data
[![GitHub license](https://img.shields.io/badge/license-Apache%202-blue.svg)](https://raw.githubusercontent.com/hipay/hipay-fullservice-sdk-prestashop-data/master/LICENSE.md)

The **HiPay Fullservice Data module for Magento 1** is a PHP module which allows you to add your own data to the DSP2 security requests that are made by the HiPay Fullservice module for Magento 1. The [HiPay Fullservice module for Magento 1][main-module] must be installed in your Magento 1 prior to this module.

## Getting started

Read the **[project documentation][doc-home]** for comprehensive information about the requirements, general workflow and installation procedure.

## Resources
- [Full project documentation][doc-home] — To have a comprehensive understanding of the workflow and get the installation procedure
- [HiPay Support Center][hipay-help] — To get technical help from HiPay
- [Issues][project-issues] — To report issues, submit pull requests and get involved (see [Apache 2.0 License][project-license])
- [Change log][project-changelog] — To check the changes of the latest versions
- [Contributing guidelines][project-contributing] — To contribute to our source code

[doc-home]: https://developer.hipay.com/doc/hipay-enterprise-sdk-magento_1/

[hipay-help]: http://help.hipay.com

[main-module]: https://github.com/hipay/hipay-fullservice-sdk-magento1/
[project-issues]: https://github.com/hipay/hipay-enterprise-sdk-magento1-data/issues
[project-license]: LICENSE.md
[project-changelog]: CHANGELOG.md


text:
# Oxford CLI
base on python3, a tool used to explain English word meaning, data from en.oxforddictionaries.com

[![forthebadge](http://forthebadge.com/images/badges/built-by-codebabes.svg)](http://forthebadge.com)

## screenshot
![](screenshot.gif)

## how to start

1. go to [oxford developer](https://developer.oxforddictionaries.com/) to register account , get the `Application ID` && `Application Keys`
2. add `config.py` in `config/`
3. `python3 cli.py`

## keybinding

- `tab` autocomplete
- `enter` search
- `ESC` quit
- `1-6` choose word
- `↑ && ↓` scroll up && scroll down

## TODO

1. add history && bookmark
2. ~~fix content oversize can't display~~
3. add `oxford_cli` to user command
4. ...

repository: wotmshuaisi/oxfordcli

repo_name: wotmshuaisi/oxfordcli


text:
To assist reproducing bugs, please include the following:
 * Operating System (e.g. Windows 10, MacOS 10.11, Ubuntu 16.04.2 LTS, CentOS 7)
 * Python version (e.g. 2.7, 3.5)
 * Where Python was acquired (e.g. system Python on MacOS or Linux, Anaconda on
   Windows)
 * h5py version (e.g. 2.6)
 * HDF5 version (e.g. 1.8.17)
 * The full traceback/stack trace shown (if it appears)

`h5py.version.info` contains the needed versions, which can be displayed by
```
python -c 'import h5py; print(h5py.version.info)'
```
where `python` should be substituted for the path to python used to install
`h5py` with.


text:
# build_tar

Tool to build tar files from a list of inputs.

All files here where copied over from [rules_pkg repo](https://github.com/bazelbuild/rules_pkg/tree/0.4.0/pkg).

repository: GoogleContainerTools/distroless

gha_language: Starlark

repo_name: GoogleContainerTools/distroless


text:
# Source controller

[![e2e](https://github.com/fluxcd/source-controller/workflows/e2e/badge.svg)](https://github.com/fluxcd/kustomize-controller/actions)
[![report](https://goreportcard.com/badge/github.com/fluxcd/source-controller)](https://goreportcard.com/report/github.com/fluxcd/source-controller)
[![license](https://img.shields.io/github/license/fluxcd/source-controller.svg)](https://github.com/fluxcd/source-controller/blob/main/LICENSE)
[![release](https://img.shields.io/github/release/fluxcd/source-controller/all.svg)](https://github.com/fluxcd/source-controller/releases)

The source-controller is a Kubernetes operator, specialised in artifacts acquisition
from external sources such as Git, Helm repositories and S3 buckets.
The source-controller implements the
[source.toolkit.fluxcd.io](https://github.com/fluxcd/source-controller/tree/master/docs/spec/v1beta1) API
and is a core component of the [GitOps toolkit](https://toolkit.fluxcd.io).

![overview](docs/diagrams/source-controller-overview.png)

Features:

* authenticates to sources (SSH, user/password, API token)
* validates source authenticity (PGP)
* detects source changes based on update policies (semver)
* fetches resources on-demand and on-a-schedule
* packages the fetched resources into a well-known format (tar.gz, yaml)
* makes the artifacts addressable by their source identifier (sha, version, ts)
* makes the artifacts available in-cluster to interested 3rd parties
* notifies interested 3rd parties of source changes and availability (status conditions, events, hooks)
* reacts to Git push and Helm chart upload events (via [notification-controller](https://github.com/fluxcd/notification-controller))

repository: bashims/source-controller

repo_name: bashims/source-controller