text:
# Commands that take time to finish

    > craft fine sword
    You start crafting a fine sword.
    > north
    You are too focused on your crafting, and can't move!
    You create the blade of the sword.
    You create the pommel of the sword.
    You finish crafting a Fine Sword.

In some types of games a command should not start and finish immediately.

Loading a crossbow might take a bit of time to do - time you don't have when
the enemy comes rushing at you. Crafting that armour will not be immediate
either. For some types of games the very act of moving or changing pose all
comes with a certain time associated with it.

There are two main suitable ways to introduce a 'delay' in a [Command](../Components/Commands.md)'s execution:

- Using `yield` in the Command's `func` method.
- Using the  `evennia.utils.delay` utility function.

We'll simplify both below.

## Pause commands with `yield`

The `yield` keyword is a reserved word in Python. It's used to create [generators](https://realpython.com/introduction-to-python-generators/), which are interesting in their own right. For the purpose of this howto though, we just need to know that Evennia will use it to 'pause' the execution of the command for a certain time.

```{sidebar} This only works in Command.func!

This `yield` functionality will *only* work in the `func` method of
Commands. It works because Evennia has especially catered for it as a convenient shortcut. Trying to  use it elsewhere will not work. If you want the same functionality  elsewhere you should look up the [interactive decorator](../Concepts/Async-Process.md#the-interactive-decorator).
```

```{code-block} python
:linenos:
:emphasize-lines: 15

class CmdTest(Command):

    """
    A test command just to test waiting.

    Usage:
        test

    """

    key = "test"

    def func(self):
        self.msg("Before ten seconds...")
        yield 10
        self.msg("Afterwards.")
```

- **Line 15** : This is the important line.  The `yield 10` tells Evennia to "pause" the command
and to wait for 10 seconds to execute the rest.  If you add this command and
run it, you'll see the first message, then, after a pause of ten seconds, the
next message.  You can use `yield` several times in your command.

This syntax will not "freeze" all commands.  While the command is "pausing", you can execute other commands (or even call the same command again).  And other players aren't frozen either.

> Using `yield` is non-persistent. If you `reload` the game while a command is "paused", that pause state is lost and it will _not_ resume after the server has  reloaded.

## Pause commands with `utils.delay`

The `yield` syntax is easy to read, easy to understand, easy to use.  But it's non-persistent and not that flexible if you want more advanced options.

The `evennia.utils.delay` represents is a more powerful way to introduce delays. Unlike `yield`, it
can be made persistent and also works outside of `Command.func`.  It's however a little more cumbersome to write since unlike `yield` it will not actually stop at the line it's called.

```{code-block} python
:linenos:
:emphasize-lines: 14,30

from evennia import default_cmds, utils

class CmdEcho(default_cmds.MuxCommand):
    """
    Wait for an echo

    Usage:
      echo <string>

    Calls and waits for an echo.
    """
    key = "echo"

    def echo(self):
        "Called after 10 seconds."
        shout = self.args
        self.caller.msg(
            "You hear an echo: "
            f"{shout.upper()} ... "
            f"{shout.capitalize()} ... "
            f"{shout.lower()}"
        )

    def func(self):
        """
         This is called at the initial shout.
        """
        self.caller.msg(f"You shout '{self.args}' and wait for an echo ...")
        # this waits non-blocking for 10 seconds, then calls self.echo
        utils.delay(10, self.echo) # call echo after 10 seconds

```

Import this new echo command into the default command set and reload the server. You will find that it will take 10 seconds before you see your shout coming back.

- **Line 14**: We add a new method `echo`. This is a _callback_ - a method/function we will call after a certain time.
- **Line 30**: Here we use `utils.delay` to tell Evennia "Please wait for 10 seconds, then call "`self.echo`". Note how we pass `self.echo` and _not_ `self.echo()`!  If we did the latter, `echo` would fire _immediately_. Instead we let Evennia do this call for us ten seconds later.

You will also find that this is a *non-blocking* effect; you can issue other commands in the interim and the game will go on as usual. The echo will come back to you in its own time.

The call signature for `utils.delay` is:

```python
utils.delay(timedelay, callback, persistent=False, *args, **kwargs)
```

```{sidebar} *args and **kwargs

These are used to indicate any number of arguments or keyword-arguments should be picked up here. In code they are treated as a `tuple` and a `dict` respectively.

`*args` and `**kwargs` are used in many places in Evennia. [See an online tutorial here](https://realpython.com/python-kwargs-and-args).
```
If you set `persistent=True`, this delay will survive a `reload`. If you pass `*args` and/or `**kwargs`, they will be passed on into the `callback`. So this way you can pass more complex arguments to the delayed function.

It's important to remember that the `delay()` call will not "pause" at that point when it is
called (the way `yield` does in the previous section). The lines after the `delay()` call will
actually execute *right away*. What you must do is to tell it which function to call *after the time
has passed* (its "callback"). This may sound strange at first, but it is normal practice in
asynchronous systems. You can also link such calls together:

```{code-block}
:linenos:
:emphasize-lines: 19,22,28,34

from evennia import default_cmds, utils

class CmdEcho(default_cmds.MuxCommand):
    """
    waits for an echo

    Usage:
      echo <string>

    Calls and waits for an echo
    """
    key = "echo"

    def func(self):
        "This sets off a chain of delayed calls"
        self.caller.msg(f"You shout '{self.args}', waiting for an echo ...")

        # wait 2 seconds before calling self.echo1
        utils.delay(2, self.echo1)

    # callback chain, started above
    def echo1(self):
        "First echo"
        self.caller.msg(f"... {self.args.upper()}")
        # wait 2 seconds for the next one
        utils.delay(2, self.echo2)

    def echo2(self):
        "Second echo"
        self.caller.msg(f"... {self.args.capitalize()}")
        # wait another 2 seconds
        utils.delay(2, callback=self.echo3)

    def echo3(self):
        "Last echo"
        self.caller.msg(f"... {self.args.lower()} ...")
```

The above version will have the echoes arrive one after another, each separated by a two second
delay.

- **Line 19**: This sets off the chain, telling Evennia to wait 2 seconds before calling `self.echo1`.
- **Line 22**: This is called after 2 seconds. It tells Evennia to wait another 2 seconds before calling `self.echo2`.
- **Line 28**: This is called after yet another 2 seonds (4s total). It tells Evennia to wait another 2 seconds before calling, `self.echo3`.
- **Line34** Called after another 2 seconds (6s total). This ends  the delay-chain.

```
> echo Hello!
... HELLO!
... Hello!
... hello! ...
```

```{warning} What about time.sleep?

You may be aware of the `time.sleep` function coming with Python. Doing `time.sleep(10) pauses Python for 10 seconds. **Do not use this**, it will not work with Evennia. If you use it, you will block the _entire server_ (everyone!) for ten seconds!

If you want specifics, `utils.delay` is a thin wrapper around a [Twisted Deferred](https://docs.twisted.org/en/twisted-22.1.0/core/howto/defer.html). This is an [asynchronous concept](../Concepts/Async-Process.md).
```

## Making a blocking command

Both `yield` or `utils.delay()` pauses the command but allows the user to use other commands while the first one waits to finish.

In some cases you want to instead have that command 'block' other commands from running. An example is crafting a helmet: most likely you should not be able to start crafting a shield at the same time. Or even walk out of the smithy.

The simplest way of implementing blocking is to use the technique covered in the [How to implement a Command Cooldown](./Howto-Command-Cooldown.md) tutorial. In that tutorial we cooldowns are implemented by comparing the current time with the last time the command was used. This is the best approach if you can get away with it. It could work well for our crafting example ... _if_ you don't want to automatically update the player on their progress.

In short:
    - If you are fine with the player making an active input to check their status, compare timestamps as done in the Command-cooldown tutorial. On-demand is by far the most efficent.
    - If you want Evennia to tell the user their status without them taking a further action, you need to use `yield` , `delay` (or some other active time-keeping method).

Here is an example where we will use `utils.delay` to tell the player when the cooldown has passed:

```python
from evennia import utils, default_cmds

class CmdBigSwing(default_cmds.MuxCommand):
    """
    swing your weapon in a big way

    Usage:
      swing <target>

    Makes a mighty swing. Doing so will make you vulnerable
    to counter-attacks before you can recover.
    """
    key = "bigswing"
    locks = "cmd:all()"

    def func(self):
        "Makes the swing"

        if self.caller.ndb.off_balance:
            # we are still off-balance.
            self.caller.msg("You are off balance and need time to recover!")
            return

        # [attack/hit code goes here ...]
        self.caller.msg("You swing big! You are off balance now.")

        # set the off-balance flag
        self.caller.ndb.off_balance = True

        # wait 8 seconds before we can recover. During this time
        # we won't be able to swing again due to the check at the top.
        utils.delay(8, self.recover)

    def recover(self):
        "This will be called after 8 secs"
        del self.caller.ndb.off_balance
        self.caller.msg("You regain your balance.")
```

Note how, after the cooldown, the user will get a message telling them they are now ready for
another swing.

By storing the `off_balance` flag on the character (rather than on, say, the Command instance
itself) it can be accessed by other Commands too. Other attacks may also not work when you are off balance. You could also have an enemy Command check your `off_balance` status to gain bonuses, to take another example.

## Make a Command possible to Abort

One can imagine that you will want to abort a long-running command before it has a time to finish.
If you are in the middle of crafting your armor you will probably want to stop doing that when a
monster enters your smithy.

You can implement this in the same way as you do the "blocking" command above, just in reverse.
Below is an example of a crafting command that can be aborted by starting a fight:

```python
from evennia import utils, default_cmds

class CmdCraftArmour(default_cmds.MuxCommand):
    """
    Craft armour

    Usage:
       craft <name of armour>

    This will craft a suit of armour, assuming you
    have all the components and tools. Doing some
    other action (such as attacking someone) will
    abort the crafting process.
    """
    key = "craft"
    locks = "cmd:all()"

    def func(self):
        "starts crafting"

        if self.caller.ndb.is_crafting:
            self.caller.msg("You are already crafting!")
            return
        if self._is_fighting():
            self.caller.msg("You can't start to craft "
                            "in the middle of a fight!")
            return

        # [Crafting code, checking of components, skills etc]

        # Start crafting
        self.caller.ndb.is_crafting = True
        self.caller.msg("You start crafting ...")
        utils.delay(60, self.step1)

    def _is_fighting(self):
        "checks if we are in a fight."
        if self.caller.ndb.is_fighting:
            del self.caller.ndb.is_crafting
            return True

    def step1(self):
        "first step of armour construction"
        if self._is_fighting():
            return
        self.msg("You create the first part of the armour.")
        utils.delay(60, callback=self.step2)

    def step2(self):
        "second step of armour construction"
        if self._is_fighting():
            return
        self.msg("You create the second part of the armour.")
        utils.delay(60, step3)

    def step3(self):
        "last step of armour construction"
        if self._is_fighting():
            return

        # [code for creating the armour object etc]

        del self.caller.ndb.is_crafting
        self.msg("You finalize your armour.")

# example of a command that aborts crafting

class CmdAttack(default_cmds.MuxCommand):
    """
    attack someone

    Usage:
        attack <target>

    Try to cause harm to someone. This will abort
    eventual crafting you may be currently doing.
    """
    key = "attack"
    aliases = ["hit", "stab"]
    locks = "cmd:all()"

    def func(self):
        "Implements the command"

        self.caller.ndb.is_fighting = True

        # [...]
```

The above code creates a delayed crafting command that will gradually create the armour. If the
`attack` command is issued during this process it will set a flag that causes the crafting to be
quietly canceled next time it tries to update.

repository: evennia/evennia

gha_language: Python

repo_name: evennia/evennia


text:
### [CVE-2020-15126](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-15126)
![](https://img.shields.io/static/v1?label=Product&message=parse-server&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-863%3A%20Incorrect%20Authorization&color=brighgreen)

### Description

In parser-server from version 3.5.0 and before 4.3.0, an authenticated user using the viewer GraphQL query can by pass all read security on his User object and can also by pass all objects linked via relation or Pointer on his User object.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon

license: MIT

repository: trickest/cve

branch_name: refs/heads/main

extension: md

gha_language: HTML

gha_license_id: MIT

license_type: permissive

repo_name: trickest/cve


text:
# B3HistoricalQuotes
Parser for Brazilian Stock Exchange (B3) historical quotes.

You can download yearly historical quotes data files from B3's website, from 1986 up to the current year:
* http://www.b3.com.br/pt_br/market-data-e-indices/servicos-de-dados/market-data/historico/mercado-a-vista/series-historicas/

The current year historical quotes data file is updated daily.

## Sample Code

```csharp
  var year = 2019;
  var symbol = "PETR4";

  var quotes = new QuotesFileReader().ReadFile("Resources/COTAHIST_A" + year + ".ZIP");

  Console.WriteLine("DATE\tCLOSING");
  foreach (var q in quotes[symbol])
      Console.WriteLine("{0:yyyy-MM-dd}\t{1:00.00}", q.Date, q.Close);
```

## Licensing

This code is released under the MIT License:

Copyright (c) TCGV.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

branch_name: refs/heads/master


text:
---
layout: "page"
title: "On the Community of School and University"
path: "/pubs/A20/brodhead1.html"
---

On the Community of School and University

By Richard H. Brodhead

The New Haven Teachers Institute might be described as a program in which
two groups having a great deal in commonthe faculties of Yale
University and of New Haven's public high and middle schoolscome
together to discover and build on their common interests.  Whether they
teach older or younger students, in public or private institutions, such a
description might continue, all of the participants of the Institute are
members of one profession; and whether they teach at the most advanced or
the most elementary levels, they all work in the same disciplines, and so
inevitably share assumptions and commitments.  What could be more natural
than for them to pool their thinking?

Alternatively, the New Haven Teachers Institute might be described as a
program in which two groups having next to nothing in common conspire to
invent interests that they might be said to share.  The work these groups
do, this account would emphasize, might go by the same name, but in fact
the terms on which they practice their profession put deep gulfs between
them.  One is used to teaching the extremely privileged, the other,
commonly, the extremely unprivileged; one assumes students already highly
prepared, the other students who need to be prepared; one associates its
discipline with recent elaborations of specialized knowledge, the other
with traditional and basic skills; and of course a host of other
differences follow from these.  When these groups come together, this
account would conclude, it is less likely to be because they feel united
in their labors than because they are troubled by the lack of such a
unity.  And if they assume in advance that they have large areas of common
ground, they are likely to be unpleasantly surprised.

The anomaly of the Teachers Institutebut also, I think, the reason
why it worksis that both of these contradictory descriptions fit it
equally well.  Half of the paradox of the Institute is that when its
participants approach each other expecting to find a community of
experience, they find, instead, how different their work-lives are.  In my
own case, while I certainly knew in a general way that the classes the
teachers in my seminar taught were quite unlike my own, I was still
constantly surprised by the particulars of their educational situations,
and by the reminders they offered that our everyday worlds were worlds
apart. Most of my teachers, I learned, locked their classrooms while
teaching:  where I teach, of course, control of students' physical
behavior is so perfected as to be invisible.  I sometimes find college
freshmen immature in their literary responses; looking at one teacher's
photos of his sixth graders reminded me that his audience was immature in
a much more fundamental sense.  I am sure I am not the only Institute
instructor who found that the more I learned about who and what and where
and how my teachers taught, the more out of place I felt. What did I, of
all people, know about the situations these teachers faced day after day?
And what possible application could what I did with my students have in
scenes so utterly remote?

Anxieties of this sort are built into the role of an instructor in the
Institute; and no doubt our teacher-students have their own corresponding
versions of these anxieties.  What helps alleviate them is that the other
half of the Institute's paradox is also true:  namely that when its
participants approach each other expecting to be irrevocably divided, they
are always discovering that there is, after all, real community between
themthat their professions (in the sense of both what they do and
what they believe in) are in fact not unrelate; and that the other's work
might strengthen his own.

The Institute builds on the simultaneous oneness and difference of its
constituent halves in the way it organizes their work together.  The
faculty leader of the seminar makes no pretense to know how, exactly, the
students at the far end of the process ought to be taught; but he does
pretend to know, and in an especially expert way, something that might
enrich and enliven the educational program that is offered to them.  In
the seminar he invites his teacher-students into some portion of his
expertise, then asks them to figure out how they can adapt what they learn
there to the needs and uses of their classes.

To say this is to suggest that the role of the faculty in the Teachers
Institute is a peculiar one.  On the one hand, he must be the instructor
of his seminar.  To bring its members to the point where they can think
their subjects and protocols through in
a genuinely new way, he must be willing really to teach them:  to lead
them to new materials, and above all to open out new frames of
understanding for them.  But on the other hand, he must also not be
the instructor in any usual sense.  His goal here, is less to teach his
students than to enable their teaching of their students. They are not in
his seminar to learn his subject, but to remake it into their subject.  In
this sense his real function is not that of expert or authority but that
of co-collaborator, working, with his high- and middle-school
counterparts, to reinvent the terms on which their shared field can be
communicated to others.

Back to
Table of Contents of the Fall 1996 Issue of On Common
Ground


text:
--------------------------------------------------------------------------------

## Treebank Statistics (UD_Estonian)

There are 13 `PUNCT` lemmas (0%), 13 `PUNCT` types (0%) and 6282 `PUNCT` tokens (18%).
Out of 16 observed tags, the rank of `PUNCT` is: 12 in number of lemmas, 12 in number of types and 2 in number of tokens.

The 10 most frequent `PUNCT` lemmas: ., ,, ", !, ?, :, -, ..., (, )

The 10 most frequent `PUNCT` types:  ., ,, ", !, ?, :, -, ..., (, )

The 10 most frequent ambiguous lemmas:

The 10 most frequent ambiguous types:

## Morphology

The form / lemma ratio of `PUNCT` is 1.000000 (the average of all parts of speech is 1.545328).

The 1st highest number of forms (2) was observed with the lemma “"”: ", :.

The 2nd highest number of forms (2) was observed with the lemma “-”: -, —.

The 3rd highest number of forms (2) was observed with the lemma “.”: ., ....

`PUNCT` does not occur with any features.

## Relations

`PUNCT` nodes are attached to their parents using 1 different relations: [et-dep/punct]() (6282; 100% instances)

Parents of `PUNCT` nodes belong to 11 different parts of speech: [VERB]() (4619; 74% instances), [NOUN]() (679; 11% instances), [ADJ]() (373; 6% instances), [ADV]() (176; 3% instances), [PROPN]() (162; 3% instances), [PRON]() (131; 2% instances), [NUM]() (69; 1% instances), [AUX]() (53; 1% instances), [ADP]() (10; 0% instances), [INTJ]() (9; 0% instances), [X]() (1; 0% instances)

6282 (100%) `PUNCT` nodes are leaves.

The highest child degree of a `PUNCT` node is 0.

repository: PhyloStar/UDTelugu

repo_name: PhyloStar/UDTelugu


text:
# DynamicAccessors

[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/spiritsc/dynamic_accessors/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
[![Build status](https://secure.travis-ci.org/spiritsc/dynamic_accessors.png)][travis]
[![Coverage Status](https://coveralls.io/repos/spiritsc/dynamic_accessors/badge.png)](https://coveralls.io/r/spiritsc/dynamic_accessors)

[travis]: http://travis-ci.org/spiritsc/dynamic_accessors

TODO: Write a gem description

## Installation

Add this line to your application's Gemfile:

    gem 'dynamic_accessors'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install dynamic_accessors

## Usage

TODO: Write usage instructions here

## Contributing

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


text:
# Foundry Squarespace Template

A fully custom Squarespace template for Foundry. Read more about [how and why we switched to Squarespace on our blog](https://www.foundrymakes.com/blog/how-and-why-we-switched-to-squarespace) to better understand the approach we used when building our site.

## Requirements

- Node / NPM
- [Squarespace Server](https://developers.squarespace.com/local-development/)
- Squarespace account with [Developer Mode enabled](https://developers.squarespace.com/beginner-tutorial/) for the website you will be using

## Develop

1. `npm install`
2. `npm install -g @squarespace/server`
3. You'll need to authenticate with your Squarespace once before the dev script will work so `squarespace-server https://site-name.squarespace.com --auth`
4. After authenticating, you can stop the server.
5. `npm run dev` to restart the server with Browsersync live reload enabled. Now changes you make to code will automatically reload in your browser and you can easily view the local site on mobile and tablet devices. Just be sure you use the Browsersync link.

![Browsersync link](assets/images/terminal.png?raw=true "Terminal Window")

## Caveats

As described on [our blog](https://www.foundrymakes.com/blog/how-and-why-we-switched-to-squarespace), this is not a true local development environment. All the content is pulled down from your site via the Squarespace API upon starting the development server. So you will need to make content changes via the Squarespace CMS and those changes will only display locally upon restarting the server. Furthermore, changes to collection files (like `blog.conf`, `blog.item`, `blog.list`) will not display locally until you commit and push changes to Squarespace. It's pretty annoying.

And this might be obvious but the template will not look right without content. It'll work, but there will be a lot of whitespace. Here's a look at how our pages are structured in Squarespace.

![Squarespace pages](assets/images/sqs-pages.png?raw=true "Squarespace pages")

## Squarespace Documentation

For further reading please consult the [Squarespace Template Overview](https://developers.squarespace.com/template-overview/) and other documentation on the Squarespace developers website. See the [Developer Getting Started](https://developers.squarespace.com/getting-started) page for an step-by-step guide for getting started with the Squaresapce Developer Platform.

### JSON-T

Squarespace template files are written in [JSON Template](https://developers.squarespace.com/what-is-json-t), also known as JSON-T. It is a simple yet expressive template language. JSON-T files have different extensions depending on the type of file, for example `.list`, `.item`, and `.region`.

### LESS

Squarespace natively supports LESS files (.less). The files are processed through the [LESS](http://lesscss.org/ preprocessor. LESS extends CSS with dynamic behavior such as variables, mixins, operations and functions.

### Template Folder Structure

Squarespace template files are organized using the following folder structure:

- **assets**: design assets — example: images, fonts and icons
- **blocks**: reusable blocks of JSON-T (AKA partials) — ex: navigation.block
- **collections**: collection files — [collection].list, [collection].item, [collection].conf
- **scripts**: Javascript files — site.js
- **styles**: stylesheet files — styles.css, styles.less
- [**root**]: sitewide files — site.region, template.conf

### /site.region

Typically this file is used as the global site template – containing the site header, footer, and sidebars. This is like the `index.html` of your site. Every template must have at least one `.region` file. Simple templates will have a single `.region`, more advanced templates will have multiple `.region` files describing header, body, and footer variants. Regions files live in the root directory of a template.

See the [Layouts & Regions documentation](https://developers.squarespace.com/layouts-regions/) for more details.

### /template.conf

Contains the configuration settings for the template. This is where you can name your template, specify layouts, add navigation sections, specify stylesheets, and other general site options. Template configuration files must live in the root directory of a template.

See the [Template Configuration documentation](https://developers.squarespace.com/template-configuration/) for more details.

repository: FoundryMakes/foundrymakes-squarespace

repo_name: FoundryMakes/foundrymakes-squarespace


text:
# ISL
Indian Sign Language Translation

## Problem Statement
Build an automatic ISL translator i.e given an input video of someone signing a word, the model should be able to predict which word is being signed.

## Current Solution

* Visualize video as sequence of images

* Convert each image to skeletal figure
![alt text](https://github.com/goru001/isl/blob/master/isl.png)

* Use Pattern matching
  * Convert the skeletal image to feature vector of 512 dimension by using Resnet-18 pretrained model
  * Find cosine distance between images of two videos which occur in the middle of the video's image sequence. If cosine distance is greater than 95, then we consider the two images to be similar. and the video sequence with which the similar images occur the most, those two videos are considered to have similar label.

## Results

### No. of Classes: 29
`'letter', 'train', 'transportation', 'mouse', 'thank_you', 'season', 'it', 'old', 'bill', 'bus', 'fast', 'soap', 'ring', 'you', 'boat', 'television', 'they', 'dry', 'week', 'hello', 'laptop', 'clock', 'truck', 'spring', 'how_are_you', 'shirt', 'happy', 'science', 'quiet'`

### No. of videos: 73

### Avg. No. of videos per class: 2-3

### Accuracy
~51% - One other thing to note that in lot of cases where `true_label` was not the `predicted_label`, it's score was actually at no. 2 or 3 of all classes.

## Next Steps
* Add data augmentation to sequence of images of videos and improve the results
* Add more words into vocabulary

## Credits
Used [pytorch-openpose](https://github.com/Hzzone/pytorch-openpose) extensively for skeletal conversions. You'll have to download the model trained in that repo to get similar results


text:
## JabbR [![Build Status](https://travis-ci.org/JabbR/JabbR.png)](https://travis-ci.org/JabbR/JabbR)
JabbR is a chat application built with ASP.NET using SignalR.

![jabbr.net](https://raw.githubusercontent.com/JabbR/JabbR/ea5a15e6bc8c0d5dba2a69053c340e8c4755459e/Content/images/screenshot.png)

### Features and Bugs
If you want to discuss the features join discussion in the [meta](https://jabbr.net/#/rooms/meta) room on jabbr.

## JabbR Features and Commands

### Public and private chat rooms
Quickly join a public chat room with

    /join [roomName]

And join any private room with an invite code

    /join [roomName] [inviteCode]

### Gravatar
Assign a gravatar to your nick. Be recognized, even in JabbR!

    Type /gravatar [email] - to set your gravatar.

### Notifications
* Integrated into Chrome to provide you with popup desktop notifications.
* Live Twitter mentions powered by twitterbot, so that you never miss out on the conversation.
* Audio notifications.

### Content Provider Support
Inline image and content support for your favorite sites:

* Bash Quote DB
* BBC News
* CollegeHumor
* Dictionary.com
* GitHub Issues
* GISTs
* Google Docs
* imgur
* join.me
* Mixcloud
* NerdDinner
* Nuget Packages
* Pastie
* Screencast
* SlideShare
* SoundCloud
* Twitter
* Uservoice
* UStream
* Vimeo
* Youtube

#### And if you ever happen to get lost...
    Type /? - to show the full list of JabbR Commands

### Getting started with the code
We use the nightly builds of the ASP.NET WebStack, so while master always contains stable code, if you don't have the packages on your machine already, they might have been deleted from the myget source which will cause errors during a build.  As such, you likely want to work on the [dev branch](https://github.com/JabbR/JabbR/tree/dev), which is updated more frequently.

To perform your first build, grab the source, and open a visual studio command prompt and run build.cmd from the main directory.  JabbR.sln should now open and run in Visual Studio without problems.  Note that you may need to update the web.config to point to a valid SQL Server installation.  The first created user is assigned the admin role.  Any questions or issues can be raised in the [meta](https://jabbr.net/#/rooms/meta) room on jabbr.

#### Getting Involved
We welcome contributions from experienced developers.  You can get involved by logging bugs in github, hacking on the source, or discussing issues / features in the [meta](https://jabbr.net/#/rooms/meta) room.

repository: yadyn/JabbR

gha_language: C#

repo_name: yadyn/JabbR


text:
## TODO

* Do something about cycles. Probably not a huge issue, since JSON-originated
  data won't have cycles anyway.
  * https://github.com/douglascrockford/JSON-js/blob/master/cycle.js

* Detect when an object is a collection, and only show the schema of one
  member.

* Detect when an array is a tuple, not a collection, and show the schema of
  each member.

* Rewrite the recursive pretty-printer, to get prettier output that `inspect`.

* Add UUID as specially-detected datatype.

repository: sehrgut/node-splain

repo_name: sehrgut/node-splain


text:
Haddock: Documentation Generated from Source
============================================

[Haddock][] ([docs]) generates documentation from Haskell source code,
producing HTML, LaTeX or Hoogle index output. It's used to generate
most of the documentation on [Hackage].

Stack can build docs with `stack build --haddock` or `stack haddock`.

### Selection

Documentation is generated for everything export by a module, even if
imported from another module and re-exported. The export order
determines the order in the documentation, regardless of order in
source files.

### Markup

- Rendered documentation starts only after `|` or `^` in comment.
- Blank lines separate paragraphs.
- The following special chars must be prefixed by a backslash `\` to
  be literal: `` \/`'"<@$ ``. Also `>` and `>>>` at beginning of line
  and `*-` at beginning of paragraph.
- SGML-style character refs: `&#` followed by a decimal number and
  `&#h` followed by a hexadecimal number, both closed with a
  semicolon. E.g., lower-case lambda is any of `λ`, `λ`
  `λ`.
- Code blocks: stand-alone `@` on either side of text or a paragraph
  (internal markup interpreted, e.g., `@x / y / z@` gives "x _y_ z")
  or prefix each line with `>` (completely literal).
- REPL: Prefix line with `>>>` and put results on subsequent
  non-indented lines below. Use `<BLANKLINE>` for empty result lines.
- Properties: prefix line with `prop>`: `-- prop> a + b = b + a`.
- Linked identifiers:
  - Surround local or qualified identifiers with single quotes:
    `'foo'' will be type 'T' or 'M.T'`. Quotes not surrounding valid
    identifiers are interpreted literally. (For compatibility, `` `T'
    `` is also accepted.
  - Surround module names with double quotes, `module "Foo"`.
- Emphasis `/.../`, bold `__...__`, and monospace `@...@` all allow
  other markup inside them (including linked identifiers); escape a
  closing char with backslash.
- Lists: a new paragraph with lines prefixed by `*`, `(1)`, `2.`, etc.
  List items not of the same time must be started with a new
  paragraph. Wrap lines under the bullet; use 4 spaces for new
  indentation level.
- Definition lists: `[@foo@]: Description of<EMAIL_ADDRESS>- Links/embedded (URLs may be relative):
  - URLs: `<http://...>`; also automatically detected.
  - Inline links: `[link text](http://...)`
  - Images: `![description](http://...)`
- Math/LaTeX: `\[ frac{1}{2\pi i} \]`. (Displayed via [MathJax] in HTML.)

XXX document grid tables, anchors, headings, metadata:
<https://haskell-haddock.readthedocs.io/en/latest/markup.html#grid-tables>.

### Declarations

Start a comment before a declaration with `|` or after a declaration
with `^` to annotate that declaration;

    -- | Double an Integer.
    -- This can be slow, but will not overflow.
    double :: Integer   -- ^The number to be doubled
           -> Integer   -- ^The result
    double i = 2*i

    data Item a
      Empty         -- ^Item containing nothing.
      Item
        { type :: String        -- ^Used by next processor
        , contents :: String    -- ^Data to process
        }

Module documentation has specific fields:

    {-|
    Module      : W
    Description : Short description
    Copyright   : (c) Some Guy, 2013
                      Someone Else, 2014
    License     : GPL-3
    Maintainer<EMAIL_ADDRESS>    Stability   : experimental
    Portability : POSIX

    Here is a longer description of this module, containing some
    commentary with @some<EMAIL_ADDRESS>    -}

### Documentation Structure

XXX continue documenting this from
<https://haskell-haddock.readthedocs.io/en/latest/markup.html#controlling-the-documentation-structure>

<!-------------------------------------------------------------------->
[Hackage]: https://hackage.haskell.org/
[Haddock]: https://www.haskell.org/haddock/
[MathJax]: https://www.mathjax.org/
[docs]: https://haskell-haddock.readthedocs.io/en/latest/

repository: keitaroemotion/sedoc

repo_name: keitaroemotion/sedoc


text:
# Maxime's dotfiles

## Installation

### Using Git and the bootstrap script

Clone this repository in `~/Projects`. The bootstrapper script will pull in the latest version and symlink the files to your home folder.

```bash
git clone https://github.com/maximebiloe/dotfiles.git && cd dotfiles && bash symlink-dotfiles.sh
```

### Add custom commands without creating a new fork

If `~/.extra` exists, it will be sourced along with the other files. You can use this to add a few custom commands without the need to fork this entire repository, or to add commands you don’t want to commit to a public repository.

### Install Homebrew formulas

Install [Homebrew](http://brew.sh/)

```bash
./etc/brew.sh
./etc/cask.sh
```

## Thanks to…

* [@julienbourdeau](https://github.com/julienbourdeau/dotfiles/)

repository: maximebiloe/dotfiles

repo_name: maximebiloe/dotfiles


text:
---
name: Submit an issue
about: Report a bug to help us improve
title: "[Title]: [Brief description]"
---

<!--

Note that anything written between these symbols will not appear in the actual, published issue. They serve as instructions for filling out this template.  Please use the 'preview' tab above this textbox to verify formatting before submitting.

Instructions:
- Start by replacing the content in "[Title]" and give a "[Brief description]" of the issue above
- Please remove any unused, optional sections below.

-->

## Observed behavior
<!-- Briefly describe the current behavior, including screenshots or other references when applicable -->

## Expected behavior
<!-- Briefly describe the expected behavior that did not occur -->

## User-facing consequences
<!-- Implications and real-world consequences for learners, coaches, admins, and other users of the application -->

## Errors and logs
<!-- Example below:  -->

```
01:10 info: something happened
01:12 error: something bad happened
```

## Additional information
<!-- Include screenshots, code or notes to help us better understand the issue -->

## Steps to reproduce the issue
1. Step one
2. Step two
3. ...

## Usage Details
<!-- Please give details about how you were using Studio. -->
 - OS:
 - Browser:
 - URL:
 - Other information that may be relevant:

repository: learningequality/studio

branch_name: refs/heads/unstable

repo_name: learningequality/studio


text:
# LERN
[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/cristianmontenegrop/LERN)
[![GitHub license](https://img.shields.io/badge/license-MIT-green.svg)](https://lern-demo.herokuapp.com/)

## Table of Contents

* [Demonstration](#Demonstration)
* [Description](#Description)
* [Installation](#installation)
* [Usage](#usage)
* [Questions](#questions)
* [Contributing](#contributing)
* [Developer Team](#developers)
* [Future](#future)
* [License](#license)

## Demonstration

[![Foo](https://media.giphy.com/media/kDa16MsN0LF9WiupyO/giphy.gif)](https://lern-demo.herokuapp.com/)

## Description

Users of LERN are able to create and view educational courses created by fellow LERNers. Register for free, teach a course,
and/or learn more about subjects such as Business & Finance, Nature, History, and much more. LERN was a collaborative
project by a team of full stack developers graduating from UW's Full Stack Coding Bootcamp. The website utilizes Create-React-App,
React Hooks, MVC design pattern, CRUD operations for database driven content, and many more node packages.

## Technologies

- MongoDB with Mongoose
- Express
- React
- Node
- Material-UI
- JSON Web Tokens with Bcrypt
- Multer
- gridfs
- Axios
- Nodemon
- Travis CLI
- Heroku

## Installation
 To install necessary dependencies, run the following commands:
 'npm i'

## Usage
execute local version: 'npm start', create build for production: 'npm build'

undefined

## Contributing
If you wish to contribute in any way, please slack me here: https://join.slack.com/t/newworkspace-dfn1975/shared_invite/zt-k727lmi9-y4XTpsjANSSib4DbZaF~pA

## Questions
 If you have any questions slack me here: https://join.slack.com/t/newworkspace-dfn1975/shared_invite/zt-k727lmi9-y4XTpsjANSSib4DbZaF~pA

## Developers

https://github.com/thedanitor
https://github.com/jaredhennessy
https://github.com/cbragg9
https://github.com/cristianmontenegrop

## Future

Additional features/ technologies for future direction of the web app:

- UI Improvement
- Additional authentication features
- Course formatting options
- Embedded video for courses
- Modify courses, users
- Additional course and user statistics
- Donate to fellow LERNers

## License

This project is licensed under the MIT license.

repository: cristianmontenegrop/LERN

repo_name: cristianmontenegrop/LERN


text:
# Cheval

Gem generator

## Installation

Add this line to your application's Gemfile:

    gem 'cheval'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install cheval

## Usage

cheval new GEM_NAME

## Contributing

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

repository: clucas/cheval

repo_name: clucas/cheval


text:
# FontKit

FontKit is a JavaScript/WebAssembly library for working with fonts,
backed by industry-strength
[Freetype](https://www.freetype.org/) and
[Harfbuzz](http://harfbuzz.org/).

> This is a project in its early stages of development

## Building

The only requirement for building fontkit is
[Docker](https://www.docker.com/get-docker)

```
./build.sh
```

Output is generated in the `build` directory.

For available options, run `./build.sh -help`

repository: rsms/fontkit

repo_name: rsms/fontkit


text:
# Scanny

A network discovery tool

Find other devices on the same local network using ARP requests.

Based on Zaid Sabih's tutorial in <https://www.udemy.com/course/learn-python-and-ethical-hacking-from-scratch>

## Table of Contents

[Requirements](##Requirements)
[Installation](##Installation)
[Configuration](##Configuration)
[Execution](##Execution)
[Contribution](##Contribution)

## Requirements

- Python 3

- Pip and the `scapy` library

- a target network

## Installation

```bash
git clone https://github.com/abraidotti/Scanny
cd Scanny
```

## Configuration

None

## Execution

Make sure to specify an IP with a CIDR block. `/24` works best.

```bash
python3 scanny.py --target <IP_ADDRESS>/24
```

## Contribution

If you'd like to contribute, file a pull request or github issue to discuss.

TODO:

- add some color

repository: abraidotti/Scanny

repo_name: abraidotti/Scanny


text:
# Hydropus atriceps (Murrill) Singer SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Lloydia 9: 118 (1946)

#### Original name
Gymnopus atriceps Murrill

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Brainf-ck
This is a `BRAINF-CK LANGUAGE INTERPRETER` written on c++.Brainfuck is a minimalist language made by Urban Müller in 1993 just for fun and challenging coders.

## SYNTAX
BRAINF-CK LANGUAGE has `EIGHT SYMBOLS` in total:

| SYMBOL | ACTION        |
|:------:|:--------------:|
| `>`  | Increment the data pointer (to point to the next cell to the right).
| `<`    | Decrement the data pointer (to point to the next cell to the left).
| `+`    | Increment (increase by one) the byte at the data pointer.
| `-`    | Decrement (decrease by one) the byte at the data pointer.
| `.`    | Output the byte data pointer pointing at
| `,`    | Accept one byte of input, Store its value in the pointing byte.
| `[`    | If the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command, jump it forward to the command after the matching ] command.
| `]`    | If the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching [ command.

> The file reader ignores everything after # in a line. It is not a brainfuck directive. Simply they are not passed to the interpreter. So you can write comments after #.
## Output Mode
The default output mode of this interpreter is __Memory Format__. In memory format output is printed as follows:
```MEM[12] = 65```
You can change the output mode via a directive using $.Put $ and write the mode name after it. Only writting first letter of the mode also works. All output modes supported yet are
| Output Type   | Command        | Demo Output  |
| :------------ |:-------------- | :-----------:|
| MEMORY TYPE*  | $M or $MEMORY  | MEM[2] = 65  |
| DECIMAL       | $D or $DECIMAL |      65      |
| ASCII         | $A or $ASCII   |       A      |

\* - is the default output mode

## How to run brainfuck codes
- From terminal:</br>
  - Write `$ g++ brainfuck.cpp -o brainfuck` once to compile the brainfuck interpreter.
  - Write `$ ./brainfuck filename.bf` to interpret the filename.bf brainf-ck code.
  - or Write `$ ./brainfuck` only after that type your code in the terminal output.

## Examples
# Hello World
`$ g++ brainfuck.c -o brainfuck`</br>
`$ ./brainfuck hello.bf`
```
$ASCII
#  Source : Wikipedia
#  This program prints "Hello World!" and a newline to the screen, its
#  length is 106 active command characters. [It is not the shortest.]
#
#  This loop is an "initial comment loop", a simple way of adding a comment
#  to a BF program such that you don't have to worry about any command
#  characters. Any ".", ",", "+", "-", "<" and ">" characters are simply
#  ignored, the "[" and "]" characters just have to be balanced. This
#  loop and the commands it contains are ignored because the current cell
#  defaults to a value of 0; the 0 value causes this loop to be skipped.
++++++++                # Set Cell #0 to 8
[
    >++++               # Add 4 to Cell #1; this will always set Cell #1 to 4
    [                   # as the cell will be cleared by the loop
        >++             # Add 2 to Cell #2
        >+++            # Add 3 to Cell #3
        >+++            # Add 3 to Cell #4
        >+              # Add 1 to Cell #5
        <<<<-           # Decrement the loop counter in Cell #1
    ]                   # Loop until Cell #1 is zero; number of iterations is 4
    >+                  # Add 1 to Cell #2
    >+                  # Add 1 to Cell #3
    >-                  # Subtract 1 from Cell #4
    >>+                 # Add 1 to Cell #6
    [<]                 # Move back to the first zero cell you find; this will
                        # be Cell #1 which was cleared by the previous loop
    <-                  # Decrement the loop Counter in Cell #0
]                       # Loop until Cell #0 is zero; number of iterations is 8
The result of this is:
Cell no :   0   1   2   3   4   5   6
Contents:   0   0  72 104  88  32   8
Pointer :   ^
>>.                     # Cell #2 has value 72 which is 'H'
>---.                   # Subtract 3 from Cell #3 to get 101 which is 'e'
+++++++..+++.           # Likewise for 'llo' from Cell #3
>>.                     # Cell #5 is 32 for the space
<-.                     # Subtract 1 from Cell #4 for 87 to give a 'W'
<.                      # Cell #3 was set to 'o' from the end of 'Hello'
+++.------.--------.    # Cell #3 for 'rl' and 'd'
>>+.                    # Add 1 to Cell #5 gives us an exclamation point
>++.                    # And finally a newline from Cell #6
```
Output:
```Hello World!```

## `BONUS`:
This interpreter comes with a transpiler which takes a string and outputs a brainf-ck code which prints the givern string.

repository: JonayedMohiuddin/Brainf-ck

repo_name: JonayedMohiuddin/Brainf-ck


text:
# Hilton (Angular KickStart App)

### Getting Started

Install **node.js**. Then **gulp** and **bower** if you haven't yet.

    $ npm -g install gulp bower

After that, cd into the project directory and run:

    $ npm install
    $ bower install
    $ gulp serve

You are now ready to go, your applcation is available at **http://<IP_ADDRESS>:3000**.

**Every file you add, edit or delete into the `/client` folder will be handled by the build system**.

When you are ready to build a production release there is a task for that:

    $ gulp serve:dist

This task will lint your code, optimize css js and images files, run unit tests. After the task has successfully finished, you can find an optimized version of your project inside the  `/build/dist` folder.


text:
# Daedalea solubilis Velen., 1926 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Mykologia (Prague) 3: 102 (1926)

#### Original name
Daedalea solubilis Velen., 1926

### Remarks
null

path: /life/Fungi/Basidiomycota/Agaricomycetes/Polyporales/Meruliaceae/Bjerkandera/Bjerkandera adusta/ Syn. Daedalea solubilis/README.md


text:
# Environ Manager - Client

## Introduction
I wanted to create a simple, networked system that I could customize as needed
to monitor environmental factors for enclosed environments (terrariums, grow
chambers, etc.). Essentially, I wanted a custom IoT solution I could understand
at a low level and manage myself without abstraction layers (Alexa Skills, Automation
Hubs, and the like). It should be able to save info to a server for further analysis.
Secondarily, it should be able to react to changes in the environment and correct them.

This is meant to be used in a client/server system with remote sensor/control
hardware. See:
- https://github.com/LinkedMink/environ-manager-hw-rpi
- https://github.com/LinkedMink/environ-manager-server
- https://github.com/LinkedMink/environ-manager-client

Disclaimer: This project was mainly intended as a learning aid and for private use.

## Scripts
To run the application, install cross-env globally.

```bash
npm install -g cross-env
```

In the project directory, you can run:

### `npm start`
Runs the app in the development mode.

Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

The page will reload if you make edits.

You will also see any lint errors in the console.

### `npm test`
Launches the test runner in the interactive watch mode.

See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.

### `npm run build`
Builds the app for production to the `build` folder.

It correctly bundles React in production mode and optimizes the build for the best performance.

The build is minified and the filenames include the hashes.

Your app is ready to be deployed!

See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.

### `npm run eject`
**Note: this is a one-way operation. Once you `eject`, you can’t go back!**

If you aren’t satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.

Instead, it will copy all the configuration files and the transitive dependencies (Webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own.

 The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it.

### `npm run lint`
Run the linter on the src directory.

### `npm run startProduction`
Serve the production bundle that results from `npm run build`. The built bundle can run on any web server,
but the serve package has been included to keep Node.js as a single dependency.

### `npm run containerize`
Package the application as a docker container. Optionally set REACT_APP_SERVER_BASE_URL to the API server
address to prefill the login form.

## Deployment - Docker
There is no requirement to run on docker, but the project has been configured to do so if desired. Install
the development dependencies.

```bash
npm install -g cross-env
npm install
```

Containerize the client application. You may set server URL at build time, so the login form is prefilled.
The app is designed to be server agnostic.

repository: LinkedMink/environ-manager-client-web

repo_name: LinkedMink/environ-manager-client-web


text:
```sh
┌──────────────────────────────────────────────┐
│ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │
│ ░░░░ ╔═══╗ ░░░░░ AWESOME BASH COMMANDS ░░░░░ │
│ ░░░░ ╚═╦═╝ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │
│ ░░░ ╒══╩══╕ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │
│ ░░░ └────°┘ ░░ A curated list of awesome ░░░ │
│ ░░░░░░░░░░░░░░░░░ Bash useful commands ░░░░░ │
│ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │
└──────────────────────────────────────────────┘
```

# Awesome Bash Commands [![](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome)

> A curated list of awesome [Bash](https://www.gnu.org/software/bash/) useful commands. Inspired by [awesome-shell](https://github.com/alebcay/awesome-shell) and [bash-handbook](https://github.com/denysdovhan/bash-handbook).

## Table of Contents
- [Files and directories](#files-and-directories)
- [Paths](#paths)
- [Devices](#devices)
- [Users and Groups](#users-and-groups)
- [Date & Time](#date--time)
- [Network](#network)
- [Miscellaneous](#miscellaneous)
- [Other Awesome Lists](#other-awesome-lists)

### Files and directories

#### List files sorted by extension

```sh
ls -l -X
# Or
ls -l --sort=extension
```

#### Count number of files within a directory

```sh
ls -1 ./my-directory | wc -l
```

_Note: use `-a` to include also dot files._

#### Create a symbolic link for one directory or file

```sh
ln -s /var/www/html ~/www
ln -s ~/my/large/path/file.txt ~/myfile.txt
```

#### Change permissions for a symbolic link only

```sh
chmod -h 770 ~/www
chown -h www-data:www-data ~/www
```

#### Find octal permissions of one file or directory

```sh
stat -c "%a %n" /var/www/html
# 770 /var/www/html
```

#### Add sticky permissions to one directory and subdirectories

```sh
find /var/www/html -type d -exec chmod g+s {} \
```

_Note: Any new file created will have the same permissions as the root folder_

#### Create one empty file in current directory and subdirectories

```sh
find ./my/current/directory -type d -exec touch {}/.gitignore \;
```

#### Delete one specific file of current directory and subdirectories

```sh
find ./my/current/directory -name ".gitignore" -type f -delete
```

#### Delete all content of one directory but except one in specific

```sh
find ./my-directory -mindepth 1 ! -regex '^./my-directory/data\(/.*\)?' -delete
```

#### Copy file content to clipboard
Copy shell command output to clipboard

```sh
cat myfile.txt | xclip -selection c
```

#### Copy entire directory to destination

```sh
cp -avr /my/current/directory /destination/directory
# Or
rsync -av /my/current/directory /destination/directory
```

#### Copy entire directory files only to destination with exclude option

```sh
rsync -har --progress --exclude .git /current/directory/. /destination/directory
```

#### Transfer an entire directory content to a remote destination

__Note:__ It's necessary to setup a SSH connection. You can use a [SSH Config file](https://www.cyberciti.biz/faq/create-ssh-config-file-on-linux-unix/).

```sh
rsync -hrtpluz --progress --stats my-current-directory/. my-remote-server:/var/data/my-remote-dir
```

Options used above:

```sh
-h,                  output numbers in a human-readable format
-r                   recurse into directories
-t, --times          preserve modification times
-p, --perms          preserve permissions
-l, --links          copy symlinks as symlinks
-u, --update         skip files that are newer on the receiver
-z, --compress       compress file data during the transfer
--progress           show progress during transfer
--stats              give some file-transfer stats
```

#### Show the space usage of file or directory

Show the space usage of file or directory (recursive) in human readable format.

```sh
du -sh /var/log/dnf.librepo.log
# 4,1M	/var/log/dnf.librepo.log

du -sh /var/log
# 2,2G	/var/log
```

#### Show size of one symbolic link (file or directory)

```sh
du -Hsh $(which dart)
# 21M	/usr/local/bin/dart
```

#### Show space usage of directories and files ordered by size

```sh
du -sh /var/data/software/app/* | sort -rh
# 1.1G	/var/data/software/app/backups
# 223M	/var/data/software/app/logs
# 125M	/var/data/software/app/attachments
# 70M	/var/data/software/app/recovery
# 1.2M	/var/data/software/app/shared-home
# 592K	/var/data/software/app/viewfile
# 12K	/var/data/software/app/journal
# 4.0K	/var/data/software/app/bundled-plugins
# 0	    /var/data/software/app/lock
```

#### Show top ten of biggest directories

```sh
du -hS /home/user/some/directory | sort -rh | head -10
# 90G	/home/user/some/directory/big-dir
# 10G	/home/user/some/directory/subdir/another-big-dir
# ...
```

#### Delete all files in directory by pattern

```sh
find /usr/local/apache/logs/archive/ -name '*2017.gz' -delete
```

#### Move files by pattern

_This command move all `*.js` files into `*.ts` files (move equivalent)_

```sh
find src/ -type f -name "*.js" -exec bash -c 'mv {} `echo {} | sed -e "s/.js/.ts/g"`' \;
```

#### Compress files by pattern using tar and gzip

Command bellow compress a group of files by pattern using tar and gzip compression into a new file like `FILE_NAME.tar.gz`.
No sorting guaranteed.

```sh
# Input files:
# src/file1.log.01
# src/file1.log.02
# src/file1.log.03

find src/ -type f -name "file1.log.*" -exec bash -c "tar cf - {} | gzip -9 > {}.tar.gz" \;

# Or using find -exec

find src/ -maxdepth 1 -type f -name "file1.log.*" -exec sh -c "tar cf - {} | gzip -9 > tarballs/{}.tar.gz && echo '{} (compressed)'" \;

# Output files:
# src/file1.log.01.tar.gz
# src/file1.log.02.tar.gz
# src/file1.log.03.tar.gz
```

#### Optimizing Tar/Gzip archive size by changing content files order

```sh
find directory/* -print | rev | sort | rev | \
      tar --create --no-recursion --files-from - | \
      gzip -c > directory.tar.gz
```

Motivated by https://news.ycombinator.com/item?id=24221498

**Alternative sorting in ascending way:**

```sh
find . -type f -name  "file1.log.*" | sort -n | xargs -I{} sh -c "tar cf - {} | gzip -9 > {}.tar.gz && echo '{} (compressed)'" \;
```

__Tip:__ Use `-maxdepth` flag in order to limit directory levels finding.

#### Compress a directory using tar and gzip

```sh
tar -zcvf my_dir.tar.gz my-dir/
```

#### List content of a tar and gzip file without extracting it

```sh
tar -tvf my_dir.tar.gz | less
```

#### Create a temporary directory with prefix

```sh
mktemp -dt "my-prefix"
```

#### Clean temporary directory

```sh
rm -rf /tmp/* /tmp/.*
```

#### Calculate gzip size of one no compressed file

```sh
gzip -c FILENAME.txt | wc -c | awk '{
if ($1 > 1000 ^ 3) {
  print($1 / (1000 ^ 3)"G")
} else if ($1 > 1000 ^ 2) {
  print($1 / (1000 ^ 2)"M")
} else if ($1 > 1000) {
  print($1 / 1000"K")
} else {
  print($1)"b"
}}'

# 560K
```

#### Split out a specific file into more small files by number of lines

```sh
split -d -l 200000 ./big_file.log small_file.log.

# Output files in current directory:
# small_file.log.01
# small_file.log.02
# small_file.log.03
# ....
```

_Notes:_

- `smallfile.log.` is a custom suffix for file names.
- `200000` is a custom number of lines per file.

#### Get only the number of lines of one specific file

```sh
wc -l big_file.log | sed -E "s/([a-z\-\_\.]|[[:space:]]*)//g"

# 9249133
```

### Paths

#### Show the full path of a command

```sh
which bash
# /usr/bin/bash

which git node
# /usr/bin/git
# /usr/bin/node
```

#### Show the resolved path of a symbolic link

```sh
realpath ~/www
# /usr/share/nginx/html
```

#### Determine the current directory

```sh
pwd
# /home/my/current/directory
```

### Devices

#### Display file system disk space usage with total

Show the file system disk space usage in human readable format.

```sh
df -h --total
# Filesystem      Size  Used Avail Use% Mounted on
# devtmpfs        487M     0  487M   0% /dev
# tmpfs           497M     0  497M   0% /dev/shm
# tmpfs           497M  508K  496M   1% /run
# tmpfs           497M     0  497M   0% /sys/fs/cgroup
# /dev/vda1        30G  2.7G   26G  10% /
# tmpfs           100M     0  100M   0% /run/user/0
# total           2.2T  600G  100G  20% -
```

#### Display system memory information with total

```sh
free -h --total
#               total        used        free      shared  buff/cache   available
# Mem:           200G         60G        100G        262M         30G        180G
# Swap:            0B          0B          0B
# Total:         200G         60G        100G
```

or

```sh
cat /proc/meminfo
# MemTotal:       183815530 kB
# MemFree:        101918660 kB
# MemAvailable:   123712410 kB
# ....
```

_Tip: Pipe `grep` to filter your results. E.g `cat /proc/meminfo | grep MemTotal`_

#### Mount a FAT32 USB device

```sh
mount -t vfat /dev/sdb1 /media/usb
```

#### Increase temporary directory size

```sh
mount -o remount,size=5G /tmp/
```

#### Find out a block device by label

```sh
blkid --label MY_MICROSD
# /dev/sdc1

lsblk --output name,serial,uuid,partuuid,label,partlabel $(blkid --label MY_MICROSD)
# NAME SERIAL UUID          PARTUUID       LABEL        PARTLABEL
# sdc1        4BGE-7510     ec123nba-02    MY_MICROSD
```

### Users and Groups

#### Switch user and execute command immediately

```sh
sudo -Hu root fish
```

#### Add an existing user to existing group

```sh
usermod -a -G ftp john
```

### Date & Time

#### Show extended ISO format Date ([ISO 8601](http://en.wikipedia.org/wiki/ISO_8601))

```sh
date "+%Y-%m-%dT%H:%m:%S"
# 2018-09-13T10:09:26
```

### Network

#### Show current IP address

```sh
ifconfig | awk '/<UP,BROADCAST,RUNNING,MULTICAST>/ { getline; print $2 }'
# or
ifconfig | grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" | grep -v <IP_ADDRESS> | awk '{ print $2 }' | cut -f2 -d: | head -n1
```

### Miscellaneous

#### Show GNU/Linux distribution and operating system

a) Using `hostnamectl`:

```sh
hostnamectl | grep -E "(.+)(System|Kernel|Arch)(.+)"
#  Operating System: Arch Linux
#            Kernel: Linux 5.1.7-arch1-1-ARCH
#      Architecture: x86-64
```

b) Using `cat /etc/os-release`:

```sh
cat /etc/os-release
# NAME="Arch Linux"
# PRETTY_NAME="Arch Linux"
# ID=arch
# BUILD_ID=rolling
# ANSI_COLOR="0;36"
# HOME_URL="https://www.archlinux.org/"
# DOCUMENTATION_URL="https://wiki.archlinux.org/"
# SUPPORT_URL="https://bbs.archlinux.org/"
# BUG_REPORT_URL="https://bugs.archlinux.org/"
# LOGO=archlinux
```

#### Generate random numbers

a)

```sh
od -vAn -N64 < /dev/urandom | tr '\n' ' ' | sed "s/ //g" | head -c 32
#<PHONE_NUMBER>1002504516642404031105
```

b)

```sh
env LC_CTYPE=C tr -dc "0-9" < /dev/urandom | head -c 32 | xargs
#<PHONE_NUMBER>2247151969921987764342
```

_Change `head` value to truncate the result's length._

#### Generate random alphanumerics

a) Alphanumeric only

```sh
base64 /dev/urandom | tr -d '/+' | head -c 32 | xargs
# 3udiq6F74alwcPwXzIDWSnjRYQXcxiyl
```

b) Alphanumeric with a custom chars set

```sh
env LC_CTYPE=C tr -dc "A-Za-z0-9_!@#\$%^&*()-+=" < /dev/urandom | head -c 32 | xargs
# yiMg^Cha=Zh$6Xh%zDQAyBH1SI6Po(&P
```

_Change `tr -dc` char set to get a custom result._

#### Generate a random hash

```sh
od -vAn -N64 < /dev/urandom | tr '\n' ' ' | sed "s/ //g" | openssl dgst -sha256 | sed "s/-//g"
# 7adf57e0a90b32ce0e1f446268dbd62b583c649a2e71a426519c6e9c0006b143
```

_Openssl digest algorithms supported: `md5`, `md4`, `md2`, `sha1`, `sha`, `sha224`, `sha256`, `sha384`, `sha512`, `mdc2` and `ripemd160`_

#### Generate a random UUID

```sh
uuidgen | tr "[:lower:]" "[:upper:]"
# D2DA7D0C-ABAA-4866-9C97-61791C9FEC89
```

#### Generate 1 million of unique random phone numbers
This command generate one million of unique random phone numbers (random permutations) fast using GNU/Linux [shuf](https://www.gnu.org/software/coreutils/manual/html_node/shuf-invocation.html) command.
Use `sed` command for customize each number format. For example for add some prefix or suffix. Remember `shuf` is not limited to numbers only.

```sh
shuf -i 100000000-999999999 -n 1000000 | sed -e 's/^/51/' > gsm.txt
```

#### Download a file using Curl and get its stats

These commands below downloads a file using Curl and get its download stats into a `curl-download-stats.log` file.
Place the script content into a custom file `.sh` and run just it.

```sh
#!/bin/bash

curl -Skw "\
CURL download testing\n\
=====================\n\
URL:                    %{url_effective}\n\
Response code:          %{response_code}\n\
Download size:          %{size_download}B\n\
Download speed:         %{speed_download}B/s\n\
Time connect:           %{time_connect}s\n\
Time name lookup:       %{time_namelookup}s\n\
Time pretransfer:       %{time_pretransfer}\n\
Time start transfer:    %{time_starttransfer}s\n\
Time redirect:          %{time_redirect}s\n\
Time total:             %{time_total}s\n" \
-Lo /dev/null --url \
https://ger.mirror.pkgbuild.com/iso/2020.02.01/archlinux-2020.02.01-x86_64.iso \
> curl-download-stats.log
```

__Notes:__

- For get the file into a location just replace `/dev/null` with the corresponding file path.
- For customize the write-out format take a look at https://ec.haxx.se/usingcurl/usingcurl-verbose/usingcurl-writeout

### Other Awesome Lists
- [awesome-shell](https://github.com/alebcay/awesome-shell)
- [awesome-fish](https://github.com/jbucaran/awesome-fish)
- [awesome-zsh](https://github.com/unixorn/awesome-zsh-plugins)

## Contributions
Please check out [the contribution file](contributing.md).

## License

[![CC0](http://i.creativecommons.org/p/zero/1.0/88x31.png)](http://creativecommons.org/publicdomain/zero/1.0/)

To the extent possible under law, [José Luis Quintana](http://git.io/joseluisq) has waived all copyright and related or neighboring rights to this work.

repository: zilpeakshay/awesome-bash-commands

repo_name: zilpeakshay/awesome-bash-commands


text:
# 1 use bind mounts

Bind mounts have been around since the early days of Docker. Bind mounts have limited functionality compared to volumes. When you use a bind mount, a file or directory on the host machine is mounted into a container. The file or directory is referenced by its full or relative path on the host machine. By contrast, when you use a volume, a new directory is created within Docker’s storage directory on the host machine, and Docker manages that directory’s contents.

The file or directory does not need to exist on the Docker host already. It is created on demand if it does not yet exist. Bind mounts are very performant, but they rely on the host machine’s filesystem having a specific directory structure available. If you are developing new Docker applications, consider using named volumes instead. You can’t use Docker CLI commands to directly manage bind mounts.

# 2 start a container with a bind mount
~~~
sudo docker run -d --name divemount --mount type=bind, source=/home/"$(USER)"/temp, target=/app/temp friendlyhello
~~~

# 3 see what happened in /app/temp in container
~~~
sudo docker exec -it divemount bash
~~~

bind directory in host machine into the container


text:
## Skelton

## ARCHIVED

This project has been inactive for years, and has been retired.

<hr/>

Example skeleton for Node-RED UI, with apologies to fans of the late great Red Skelton.

The work represents an experimental playground for a static code analysis project based on the results
generated by [FindBugs](http://findbugs.sourceforge.net).

![Screenshot](/src/images/skelton2.png?raw=true "Skelton screenshot")

## Generator

The generator used for the initial skeleton was [generator-react-webpack](https://github.com/newtriks/generator-react-webpack).

## Caveats

The project is in its earliest stages, and until this caveat is removed from the README it cannot even be counted on to successfully build.

The choice of source analysis target project (Tomcat 6.0.41) was made with the greatest respect for the project and its developers. An older version was chosen to permit comparisons with later editions.

## Loading Data

The database can be reproduced from the data directory with the following steps:

1: Change to the data directory at the command line (i.e. relative to this directory)

    cd data

2: Run the mongodb shell

    mongo

3: Create (or use) the findbugs database

    use findbugs;

4: Load the data with the import script

    load('import.js');

## Regarding Analysis

The file in our data directory called "Analysis-July30.json" was generated by running FindBugs against the
data found in the [tomcat 6.0.41 source code](https://archive.apache.org/dist/tomcat/tomcat-6/v6.0.41/src/apache-tomcat-6.0.41-src.tar.gz).

This application builds a client application that displays that source code, but rather than include this in the project
please create a directory under "src" (relative to this readme) called "javasrc", and in it please extract the contents
of the tomcat source code. On Linux, this might look like this:

```
mkdir src/javasrc
cd src/javasrc
cp ~/Downloads/apache-tomcat-6.0.41-src.tar.gz .
tar xzf apache-tomcat-6.0.41-src.tar.gz
```

Crucially, the resulting tree should contain the following folder:

    ./src/javasrc/apache-tomcat-6-0.41-src/java

The build process will copy the java source code into the correct destination folder.

## Useful Links

The following links contain reference material or libraries that have been useful in this project.

* [generator-react-webpack](https://github.com/newtriks/generator-react-webpack)
* [highlight.js](https://highlightjs.org/)
* [highlights.js docs](http://highlightjs.readthedocs.org/en/latest/)
* [Days-Hours Heatmap](http://bl.ocks.org/oyyd/859fafc8122977a3afd6)
* [House Hunting on Trulia](http://www.trulia.com/vis/tru247/)
* [r-layout](https://github.com/Zinggi/RLayout)
* [rangy - a javascript range and selection library](https://github.com/timdown/rangy)
* [Overriding Text Selection Color with CSS](https://css-tricks.com/overriding-the-default-text-selection-color-with-css/)
* [Selecting over SPAN tags](http://stackoverflow.com/questions/3904400/how-to-highlight-user-selected-text-within-a-piece-of-text-which-has-already-bee?rq=1)
* [Safe user selection (across elements)](http://stackoverflow.com/questions/304837/javascript-user-selection-highlighting?rq=1)

## Resources to consider

* [React Boilerplate](https://github.com/mbrio/react-boilerplate)
* [PRISM](http://prismjs.com/index.html)
* [Mark and Share](https://github.com/SmartTeleMax/MaSha)
* [react-grid-layout](https://github.com/STRML/react-grid-layout)
* [Reusable Chart Components with React and D3](http://busypeoples.github.io/post/d3-with-react-js/)
* [D3 in React](http://nicolashery.com/integrating-d3js-visualizations-in-a-react-app/)
* [react-datagrid](https://github.com/zippyui/react-datagrid)

repository: rjpw/skelton

gha_language: JavaScript

repo_name: rjpw/skelton


text:
---
title: Limited Numbers
---

This is a generic title. This section discusses all cards that selectively lock
off a certain CMC cost of a spell. This can include things like
{{Chalice of the Void}}, {{Sanctum Prelate}} or non-permanent hate such as
{{Spell Snare}}. There are some CMCs the deck needs to be able to function, and
some that are completely optional. Here we shall explore the relevancy these
cards have against us and some strategies to face them.

For each value examples will be given on what hate you might face and how to get
around the listed limitation.

In addition to these *work around* piles, we'll also discuss the catch-all
requirements for removing these restrictive permanents. As some numbers being
named restrict certain removal cards, it's good to have at least two available
to allow yourself an out for these cards if you were to face them.

## 0 Mana Cost Spells

In terms of 0 costs spells we have two main ones that are played. Lion's Eye
Diamond and Lotus Petal. Both are incredibly useful mana generating resources
but neither are required to win. All that it means is more mana is needed
post-DD to get us going.

> SW in hand - {B}{B}{B} + {U}{U}{B}{R} - 6 Storm

<row variant="pile">{{!IU}} {{!DR}} {{!DR}} {{!SW}} {{!BW}}</row>

> CB in play, SW in hand - {B}{B}{B} + {X}{B}{B} - 7+ Storm

<row variant="pile">{{!DR}} {{!IC}} {{!DR}} {{!CB}} {{!ToA}}</row>

> 2 SW in hand - {B}{B}{B} + {B}{R}{R} - 6 Storm

<row variant="pile">{{!DR}} {{!AoI}} {{!DR}} {{!DR}} {{!BW}}</row>

> 2 SW in hand - {B}{B}{B} + {U}{B}{R}

<row variant="pile">{{!DR}} {{!AoI}} {{!DR}} {{!LM}} {{!SW}}</row>

These piles have lost a lot of their power with the banning of Gitaxian Probe
since the free draw effect utilized here does not count towards Storm count.

The general concept to remember is that our main method of fast mana generation
after our 0 cost artifacts is DR. This means we need both {B} to enable the
casting of these rituals and also {R} available to cast BW at the end.
Alternatively if you are aiming for a LM pile you need {U}. As all our cantrips
are not affected we can still easily draw into what we need. If you happen to be
playing with maindeck ToA then you don't need to worry about these additional
colour requirements but for most DDFT lists you do.

CMC 0 basically only stops Engineered Explosives in terms of cards we can bring
in to fight it. Anything else such as {{By Force}}, {{Hurkyl's Recall}} or
similar can all deal with a Chalice on 0 with no issue and similarly,
{{Massacre}}, {{Abrupt Decay}} and {{Pyroclasm}} can all easily deal with
Sanctum Prelate. One thing to note is, should you by some means have a way to
generate colourless mana, you can in fact play EE for {1} and it will resolve
with 0 counter on due to the nature of Sunburst only counting coloured mana.

## 1 Mana Cost Spells

This is THE classic opener of Stompy variants, Aggro Loam and other strategies
that aren't concerned with cantripping or similar. The main issue with this
limitation is getting to the point you can cast Doomsday rather than the actual
going off. Obviously things like running BW along with artifact hate such as
{{Meltdown}} can help get around the issue but you may just find you can go off
without it (however unlikely that may be). You can also just try to go for an
{{EtW}} play by throwing cantrips into Chalice then using lands, LP and LEDs to
BW for EtW. This can also achieve a natural ToA kill if you have the time and
resources.

The two main points to take is the lack of ability to cast your cantrips and the
lack of being able to cast things like DR or CB. IC is the preferred draw method
here as it means you get the complete stack rather than IU that leaves you
needing to draw an additional card. If you have a CB in play already then there
is obviously no issue but it is still worth considering. This is also where the
cycling ability of Street Wraith and {{Edge of Autumn}} shines as it represents
a cantrip that, although does not generate Storm, does allow drawing into the
pile and also drawing a card for LM victories.

With these piles you also have to consider you have most likely cast DD off of
lands and LPs. As a result you probably have less mana available and as the most
common method of entering into our stacks are one mana cantrips, pass-the-turn
piles are a strong consideration. If passing the turn is not an option then
wishing for a draw spell, using a draw spell already in hand or using something
like Edge of Autumn to access the pile are all considerations.

> Pass the turn - {2}{B}{B}{B}{R} - 7 Storm

<row variant="pile">{{!BW}} {{!LED}} {{!LED}} {{!LP}} {{!BW}}</row>

> BW in hand, CB in play, pass the turn - {1}{R} - 8 Storm

<row variant="pile">{{!LED}} {{!LED}} {{!LED}} {{!LED}} {{!BW}}</row>

> BW in hand, CB in play - {B}{B}{B} + {2}{R} - 8 Storm

<row variant="pile">{{!LED}} {{!LED}} {{!LP}} {{!LP}} {{!BW}}</row>

> BW in hand, CB in play - {B}{B}{B} + {1}{R} - 7 Storm

<row variant="pile">{{!LED}} {{!AoI}} {{!LED}} {{!LED}} {{!BW}}</row>

In terms of removal there is very little here. Only {{Chain of Vapor}} and
{{Void Snare}} are affected here. This is where By Force shines over some other
artifact removal as casting By Force with X = 1 means that it becomes a CMC 2
card that then allows you to destroy a single Chalice set to 1. A Sanctum
Prelate is equally vulnerable as most of our removal for creatures costs 2 or 4.

## 2 Mana Cost Spells

This is less likely to be faced in terms of Chalice of the Void but significant
in that it includes playing around Spell Snare, a semi common card in many Ux
decks. The main things that get cut from this is IU and BW. Ideally this means
if you are running a draw-3 option you should have no issues generating a simple
double cantrip LM pile however if you require a BW Storm kill then you have to
get rid of it. You can also ignore this limitation with maindeck ToA.

> SW in hand, CB in play - {B}{B}{B} + {X} - 8+ Storm

<row variant="pile">{{!LED}} {{!AoI}} {{!ToA}} {{!LED}} {{!CB}}</row>

> SW in hand - {B}{B}{B} + {2}{U}{R}

<row variant="pile">{{!AoI}} {{!LED}} {{!BS}} {{!LM}} {{!Abandon Hope}}</row>

This limitation in terms of removal is very awkward. Things like Abrupt Decay
are not affected from a Chalice set to 2. This does lock off things like
Hurkyl's Recall or Echoing Truth though but allows Void Snare and Chain of Vapor
to be used. What is harder to remove is a Sanctum prelate set on 2. This
prevents BW from finding a Massacre and prevents the casting of Abrupt Decay or
things like Pyroclasm.

## 3 Mana Cost Spells

This is an interesting one to deal with. At this point it is almost guaranteed
this is a Sanctum Prelate rather than a Chalice as very rarely do decks dump six
mana into stopping 3 cost spells. Especially as such decks normally run plenty
themselves. The main cards blocked here are of course Doomsday itself, and some
of our enablers (AoI, TW and IC). If you are running IU then this does not
prevent your main PTT piles should this limit come down once you have committed.
If facing this limit you still have access to everything you need to find
answers and if in doubt, you can still initiate an Empty the Warrens line with
no issue.

Removal-wise this does not prevent anything really unless you are going for
something more spicy such as {{Toxic Deluge}} or {{Rushing River}}. Otherwise
all your removal is turned on and ready to go.

## 4 Mana Cost Spells

In this category we introduce, in addition to Prelate and Chalice, {{Gaddock
Teeg}} as another limitation permanent we could face. The main thing here is
that this number block prevents our Storm finishers from being used. LM piles
are completely unaffected so those are an easy line to victory.

Also to consider is the fact that we don't need to worry too much about Chalice
being set to four. Storm will still trigger so only the original instance of the
spell will be stopped.  It
does still prevent the use of Massacre though in case it should be needed.

Removing these two is also tricky at this cost block as it turns off our primary
removal in the form of Massacre. Other means of removal, if a LM pile is not
available, need to be considered.

Teeg also shuts off the use of By Force in the instance that he is used in
tandem with Chalice or similar (think Aggro Loam) so this could advocate the use
of other removal. He also shuts off the use of Engineered Explosives.

## Limitation Removal in Your Piles

Although we have touched on some examples of playing around these limitations
and also the relative effectiveness of certain removal cards, we haven't
discussed simply incorporating these cards into piles to allow us to win.
Obviously certain limitations will prevent you getting to these piles in the
first place but these should still give you an idea of how to swap out pile
elements for the required removal. For ease of clarity I shall present the use
of {{Nature's Claim}} for it's unique mana cost of {G} which you can swap out
for the appropriate removal spell by substituting the mana cost accordingly.

> SW and BW in hand - {B}{B}{B} + {2}{R}{G} - 8 Storm

<row variant="pile">{{!LED}} {{!Nature's Claim|WWK}} {{!DR}} {{!LP}} {{!ToA}}</row>

> BW and BS in hand, CB in play - {B}{B}{B} + {U}{G} - 9 Storm

<row variant="pile">{{!Nature's Claim|WWK}} {{!AoI}} {{!LED}} {{!LED}} {{!LED}}</row>

> SW and BW in hand - {B}{B}{B} + {2}{R}{G} - 7 Storm

<row variant="pile">{{!LED}} {{!Nature's Claim|WWK}} {{!LED}} {{!SW}} {{!ToA}}</row>

> Pass the turn, SW in hand - {2}{U}{U}{G}

<row variant="pile">{{!Nature's Claim|WWK}} {{!IU}} {{!LP}} {{!SW}} {{!LM}}</row>

> Pass the turn, SW in hand - {1}{U}{U}{G}

<row variant="pile">{{!Nature's Claim|WWK}} {{!TW}} {{!LED}} {{!SW}} {{!LM}}</row>

> Pass the turn, SW in hand - {2}{R}{G}

<row variant="pile">{{!Nature's Claim|WWK}} {{!AoI}} {{!LED}} {{!SW}} {{!LM}}</row>

> Pass the turn, LED in play - {2}{G}

<row variant="pile">{{!SW}} {{!IU}} {{!Nature's Claim|WWK}} {{!SW}} {{!LM}}</row>

> Pass the turn, LED in play - {2}{U}{G}

<row variant="pile">{{!SW}} {{!AoI}} {{!Nature's Claim|WWK}} {{!SW}} {{!LM}}</row>

## Pass-the-Turn Piles Using Chain of Vapor

One somewhat unique piece of potential removal for anything not set to
preventing 1 CMC spells being cast is Chain of Vapor. This allows you to bounce
your own 0 cost artifacts to further increase Storm count before using it to
remove a limitation.

> Pass the turn, SW in hand - {U}{U}{U} - 9 Storm

<row variant="pile">{{!IU}} {{!LED}} {{!LED}} {{!CoV}} {{!BW}}</row>

> Pass the turn, LED in play - {U}{U}{U} - 8 Storm

<row variant="pile">{{!IU}} {{!LED}} {{!SW}} {{!CoV}} {{!BW}}</row>

> Pass the turn, BW, SW and any 1 card in hand - {U}{U} - 9 Storm

<row variant="pile">{{!SW}} {{!BS}} {{!LED}} {{!LED}} {{!CoV}}</row>

## Removal Choices

With so many sets having seen print, there is now a veritable plethora of
different removal options for getting rid of things like
{{Chalice of the Void}}, {{Trinisphere}} and {{Thorn of Amethyst}} with many
being able to get rid of multiple at the same time. See the [removal
tables][removal-tables] for more details.

## Summary

1. There is often a winning line available despite facing hate
2. Strong sideboarding is key to mitigating these issues
3. Variable CMCs for your removal is advised to some extent

[removal-tables]: /appendices/removal-tables/

repository: Doishy/doomsday-wiki

repo_name: Doishy/doomsday-wiki


text:
## ZecWallet Lite
Zecwallet-Lite is z-Addr first, Sapling compatible lightwallet client for Zcash. It has full support for all Zcash features:
- Send + Receive fully shielded transactions
- Supports transparent addresses and transactions
- Full support for incoming and outgoing memos
- Fully encrypt your private keys, using viewkeys to sync the blockchain

## Download
Download compiled binaries from our [release page](https://github.com/adityapk00/zecwallet-lite/releases)

## Privacy
* While all the keys and transaction detection happens on the client, the server can learn what blocks contain your shielded transactions.
* The server also learns other metadata about you like your ip address etc...
* Also remember that t-addresses don't provide any privacy protection.

### Note Management
Zecwallet-Lite does automatic note and utxo management, which means it doesn't allow you to manually select which address to send outgoing transactions from. It follows these principles:
* Defaults to sending shielded transactions, even if you're sending to a transparent address
* Sapling funds need at least 5 confirmations before they can be spent
* Can select funds from multiple shielded addresses in the same transaction
* Will automatically shield your transparent funds at the first opportunity
    * When sending an outgoing transaction to a shielded address, Zecwallet-Lite can decide to use the transaction to additionally shield your transparent funds (i.e., send your transparent funds to your own shielded address in the same transaction)

## Compiling from source
Zecwallet Lite is written in Electron/Javascript and can be build from source. It will also automatically compile the Rust SDK needed to run Zecwallet Lite.

#### Pre-Requisites
You need to have the following software installed before you can build Zecwallet Fullnode

* [Nodejs v12.16.1 or higher](https://nodejs.org)
* [Yarn](https://yarnpkg.com)
* [Rust v1.40+](https://www.rust-lang.org/tools/install)

```
git clone https://github.com/adityapk00/zecwallet-lite.git
cd zecwallet-lite

yarn install
yarn build
```

To start in locally, run
```
yarn start
```

_PS: Zecwallet-Lite is NOT an official wallet, and is not affiliated with the Electric Coin Company in any way._

gha_language: TypeScript


text:
# GetFrozen

Getting 'frozen' object from other objects can be handled in simple manners.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'get_frozen'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install get_frozen

## Usage

### Object#get_frozen

Returns
1. self when the object is already frozen or immutable
2. copied and frozen object otherwise

Note: Some immutable objects cannot be duplicated (`true`, `false`, `nil`, `Numeric`) may or may not be 'frozen' in Ruby environment.
This library handles these immutables correctly, simply returns self.

## Restriction
This gem is intended to be applied for value objects.
There is no guarantee for using this method for state-bounded objects (file, database, thread ...).

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

1. Fork it ( https://github.com/[my-github-username]/get_frozen/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request


text:
# Requirements
<!-- position: 2 -->

You just need a web server with PHP support.

- PHP v5.6 or higher.
- PHP [mbstring](https://www.php.net/manual/en/book.mbstring.php) module for full UTF-8 support.
- PHP [gd](https://www.php.net/manual/en/book.image.php) module for image processing.
- PHP [dom](https://www.php.net/manual/en/book.dom.php) module for DOM manipulation.
- PHP [json](https://www.php.net/manual/en/book.json.php) module for JSON manipulation.
- Bludit supports almost every webserver:
  * [PHP Built-in web server](https://www.php.net/manual/en/features.commandline.webserver.php)
  * Nginx with module [ngx_http_rewrite_module](http://nginx.org/en/docs/http/ngx_http_rewrite_module.html)
  * Apache with module [mod_rewrite](http://httpd.apache.org/docs/current/mod/mod_rewrite.html)
  * Lighttpd with module [mod_rewrite](https://redmine.lighttpd.net/projects/1/wiki/docs_modrewrite)
  * Hiawatha, [rewrite rules](https://www.hiawatha-webserver.org/howto/url_rewrite_rules)
  * H2O, see the post [H2O HTTP/2 web server and Bludit](https://forum.bludit.org/viewtopic.php?f=6&t=1015) in the Support Forum
  * IIS with module [URL Rewrite](https://www.iis.net/downloads/microsoft/url-rewrite), see [this](https://forum.bludit.org/viewtopic.php?f=6&t=1420) post in the Support Forum

repository: bludit/documentation-english

repo_name: bludit/documentation-english