@***************************************************************************** * Page to display a form to gather user comments * * which are emailed to the site administrator * * Copyright (c) 2015 MIT Libraries * *****************************************************************************@ @(fbform: Form[(String,Boolean,String)])(implicit request: play.api.mvc.RequestHeader, messages: Messages) @import helper._ @implicitField = @{ helper.FieldConstructor(bootstrapHorizontal.f) } @layout.main("Feedback - TopicHub") {
Thanks for helping make @HubUtils.siteName a more valuable service!
@form(routes.Application.takeFeedback, 'class -> "form-horizontal") { * Denotes Required Element @inputText(fbform("email"), '_label -> "* Your Email", '_help -> "", 'class -> "form-control") @checkbox(fbform("reply"), '_label -> "Send Reply?", '_help -> "Would you like a reply sent to the email supplied?", 'class -> "form-control") @textarea(fbform("comment"), '_label -> "* Your Message", 'rows -> 8, 'cols -> 40, '_help -> "Please record any comments, questions, suggestions, etc you have in the field below. You may comment on application design and usability, or on the content you find (or don't).", 'class -> "form-control")


W3.CSS Tutorial. (n.d.). Retrieved from https://www.w3schools.com/w3css/
(n.d.). Retrieved from https://www.quackit.com/css/properties/css_border-color.cfm
Wire Flows
Style Sheet


Open Sourcing
User Experience
for the Internet of Things
Ivan Judson, PhD | Felix Rieseberg | Ville Rantala
Open Source Engineers, Microsoft
We Have to Build the
User Experience Together
[It's too hard]
Data Collection
We want to learn from data collected single users, user groups, and whole societies
Architecture
Moving Parts
Hardware
Software
Data
Security
That's a lot we all have to build
Example
Heatworks
Heatworks Architecture
We Propose A Proven Solution
Open Source & Collaboration
Success in three steps
Open Source, Open Data, Open APIs
Build Partnerships
Grow Communities
We write Open Source, MIT-Licensed Code
We work with Startups, Communities & Corporations
We solve Problems
As it turns out, the Internet of Things has many problems
Demo Time!
Windows 10 & AllJoyn
Cordova & AllJoyn
Cloud & AllJoyn
Please Get In Touch!
Ivan R. Judson, PhD
Felix Rieseberg
Ville Rantala


This package contains one public class which is a DataSource
implementation which provides a database connection pool. Below are a couple
of usage examples. One shows deployment into a JNDI system. The other
is a simple example initializing the pool using common java code.
Most J2EE containers will provide some way of deploying resources into JNDI. The method will vary among containers, but once the resource is available via JNDI, the application can access the resource in a container independent manner. The following example shows deployment into catalina.
In server.xml, the following would be added to the <Context> for your webapp:
<Resource name="jdbc/bookstore" auth="Container"
type="org.apache.commons.dbcp.jdbc2pool.Jdbc2PoolDataSource"/>
<ResourceParams name="jdbc/bookstore">
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.jdbc2pool.Jdbc2PoolDataSource</value>
</parameter>
<parameter>
<name>dataSourceName</name><value>java:comp/env/jdbc/bookstoreCPDS</value>
</parameter>
<parameter>
<name>defaultMaxActive</name><value>30</value>
</parameter>
</ResourceParams>
In web.xml. Note that elements must be given in the order of the dtd described in the servlet specification:
<resource-ref>
<description>
Resource reference to a factory for java.sql.Connection
instances that may be used for talking to a particular
database that is configured in the server.xml file.
</description>
<res-ref-name>
jdbc/bookstore
</res-ref-name>
<res-type>
org.apache.commons.dbcp.jdbc2pool.Jdbc2PoolDataSource
</res-type>
<res-auth>
Container
</res-auth>
</resource-ref>
Catalina deploys all objects configured similarly to above within the
java:comp/env namespace. So the JNDI path given for
the dataSourceName parameter is valid for a
ConnectionPoolDataSource
that is deployed as given in the
cpdsadapter example
The DataSource
is now available to the application as shown
below:
Context ctx = new InitialContext();
DataSource ds = (DataSource)
ctx.lookup("java:comp/env/jdbc/bookstore");
Connection con = null;
try
{
con = ds.getConnection();
...
use the connection
...
}
finally
{
if (con != null)
con.close();
}
The reference to the DataSource
could be maintained, for
multiple getConnection() requests. Or the DataSource
can be
looked up in different parts of the application code. Jdbc2PoolDataSource
will maintain the state of the pool between different lookups. This
behavior may be different
among in other implementations. It is in contrast to the behavior of
{@link org.apache.commons.dbcp.BasicDataSource}, where two lookups of a pool set to a maximum of
100 connections will lead to two independent sets of connections for a total
of 200. With Jdbc2PoolDataSource, you are expected to deploy different
instances under different names, if you wish to have independent sets of
connections.
Connection pooling is useful in applications regardless of whether they run in a J2EE environment and Jdbc2PoolDataSource can be used within a simpler environment. The example below shows DriverAdapterCPDS used as the source, though any CPDS is applicable.
public class Pool
{
public static DataSource ds;
static
{
DriverAdapterCPDS cpds = new DriverAdapterCPDS();
cpds.setDriver("org.gjt.mm.mysql.Driver");
cpds.setUrl("jdbc:mysql://localhost:3306/bookstore");
cpds.setUser("foo");
cpds.setPassword(null);
Jdbc2PoolDataSource tds = new Jdbc2PoolDataSource();
tds.setConnectionPoolDataSource(cpds);
tds.setDefaultMaxActive(10);
tds.setDefaultMaxWait(50);
ds = tds;
}
}
This class can then be used wherever a connection is needed:
Connection con = null;
try
{
con = Pool.ds.getConnection();
...
use the connection
...
}
finally
{
if (con != null)
con.close();
}


Tech enthusiastic, determined, passionate and a computer science student looking for an oppurtunity to work in your prestige institution.
Managed a team of application developers from universities all over Pakistan in Softec which is one of the biggest software competion conducted in pakistan.
Manages the social media account of fastcare a charitable organization which plays a part in welfare for the people around us in the shape of donations, talks on social adversities and motivational speeches.
Self learned video editor and animator. can do cloning, 120 fps editing and complete videography on any relevant topic.
Writes Blogs, social media posts on current affairs and satirical events.
Computer programming.
PER-90%
Apart from being a computer science student I am an avid learner of tech skills and follows any new advancement in my field very passionately. I workout because i love being fit.I play cricket, football and videogames.
When forced indoors, I follow a number of sci-fi and fantasy genre movies and television shows, I am an aspiring chef, and I spend a large amount of my free time exploring the latest technology advancements in the front-end web development world.


Copyright Bruce Wilcox<EMAIL_ADDRESS>Revision 2/8/2021 cs11.1
How to support non-English languages at end of manual.
Back in school we learned the various parts of speech (noun, verb, adjective, adverb, preposition …) and were taught basic rules of grammar. Why? To help us understand meaning. But fancy grammar is not needed for basic meaning. Me hungry is perfectly understandable. And context also dictates meaning: What do you like to do? And What food do spiders eat? Can both be answered with fly with entirely different meanings.
And most chatbots, even in ChatScript, don’t use pos-tagging or grammar.
They don’t understand general meaning but they can hunt for specific meanings by looking for keywords in particular combinations or orders. But ultimately, you can handle more meaning when you can parse a sentence.
Pos-tagging (part-of-speech tagging) is a strange beast. Pos-taggers define a range of labels for their convenience which can be more or less than what you’d expect.
I learned something like 8 parts of speech as a child. Pos-taggers vary from 38 possible tags to over a hundred. Existential there is a common pos-tag, as in there is a table. On the more side, pos-taggers typically separate verbs into their various tenses. On the less side, the standard Penn Treebank system lumps prepositions and subordinate conjunctions into the single label IN.
Pos-tagging by itself is often useless. It exists to support parsing. Nowadays most people treat postaggers and parsers as a done deal. A long time ago a guy named Brill was discovered that you can get 90% of words correctly tagged merely by tagging it with its most common tag. Nowadays statistical pos taggers like the Stanford parser are the gold standard and on Wall Street Journal type articles it is said to be about 97.3% accurate in tagging.
Training probability pos-taggers means it generalizes what it has seen to build a relatively simple model of how probable a tag is given surrounding words. You can then test it on the same original data (something you don’t normally do with machine learning models) and see how they do. TreeTagger trained on a large sample of Wall Street Journal sentences, achieves 97.5% accuracy on the replay. Trained on the switchboard corpus of telephone conversations yielded 89.7% against those. Pos-tagging degrades rapidly on data it was not trained for. One review said that on bug reports the Stanford Pos-Tagger was between 83.6% and 90.5% accurate using Wall Street Journal trained models.
Another study showed that trained on WSJ data (lots of clean data) and applied to the same kind of data, atis: Recordings of Air Travel Information System dialogue, i.e. natural speech. 2. brown: The original Brown Corpus, containing various topics. 3. swbd: Switchboard Corpus of telephone conversations. 4. wsj/00-05: Wall Street Journal articles (collection 0 to 5). 5. wsj/00-22,24: Wall Street Journal articles (collection 0 to 22, and 24). 6. wsj/23: Wall Street Journal articles (collection 23). wsj/23: Percent Correct: 97.454%
Statistical parsers look at tuples (typically 3) of words to predict what part-of-speech a word will be. And because they do so well, pos-tagging is now separated into a separate phase from parsing. These “good” results are for kinds of material the tagger is trained for and degrades on other works until trained there. They are rarely trained on other kinds of work because the training data isn’t there.
Furthermore, there’s a fundamental flaw with the idea that each word can be given a correct pos tag. Idioms are not addressed. For example: the idiom until recently is an adverb idiom. Yet under normal pos-taggers it becomes a preposition and an adverb. So where is the object of the preposition? But hey, at least it’s one of the words is right.
More than
is a particularly interesting combo. More
than one ate meat. They label more an adjective and
than a preposition/conjunction while they correctly label the
subject as one and the noun phrase contains a quantifier phrase. What
about they sold more than 150 units. The word than is either a
preposition or a subordinate conjunction under some pos-taggers. But
more than is also an idiom whose composite postag would be as a
quantifier.
Quantifiers join articles and determiners as something that comes before a noun (all children) and denote quantity. Then mix that with being allowed to omit words. I love her more than you really means_ I love her more than [I love] you_ and than is a conjunction.
Or by the time we left, we were tired. You take a preposition determiner noun (by the time) but as an idiom it’s a subordinate conjunction. CMU’s Link Parser recognizes and marks idioms and their behavior correctly. And so does ChatScript. Stanford will collapse some multi-word prepositions into a single one during parsing, but not during pos-tagging. So you end up with strange markings. Another example is inch by inch, they crawled. The pos and tree for that in Stanford is rubbish, starting with noun, preposition, noun.
Back to the idea that Stanford is good doing 97.3% accurate in pos-tagging. 97.3% accuracy in postagging means that out of every 100 words, almost 3 are wrongly tagged. The average sentence length of populist publications like Reader’s Digest in 1985 was 20-22 words. Heavy duty publications like the Wall Street Journal or the New York Times averaged around 26-27 words. So presumably almost one in every four WSJ sentences is wrongly tagged. Even if you pos-tag a sentence perfectly you can wrongly parse it. When pos-tagging is wrong, what chance do you have? The stated accuracy of parsing of the Stanford parser is 56%. Almost half of what it reads is parsed incorrectly.
Google recently released SyntaxNet, an even better parser. Yet if you
give it wind the clock
, it thinks wind
is a
noun. It doesn’t even have a sentence there.
ChatScript faces uncommon problems from most Natural Language tools.
The best taggers/parsers are trained on the Wall Street Journal, where everything is properly cased.
Chatters often never use upper case and speech recognitions devices don’t output it either. So ChatScript works to handle all cases of things. And, following established tradition, I define my own tags for my own convenience. In addition to the usual tags differentiating various kinds of nouns and verb, I also differentiate words based on how it is used. Nouns can be used as adjectives, so bank teller is an adjective_noun noun_singular pair. Verbs can be used as nouns or adjectives, so we have the gerund (walking is fun) and the noun infinitive (to walk is fun) and the adjective participle (the walking dead is dead).
Postagging is harder than it looks. Consider these uses of the word up.
what jumps up? # adverb up, pronoun what
what jumps
up the wall # preposition up, pronoun what
what jumps up
the ante? # verb up, determiner what
what do people jump
up? # preposition up, pronoun “what” as object
Hence ChatScript has a built-in pos-tagger/parser using rules of grammar along with statistics. This is the tack taken by Constraint Grammar parsers, which can achieve high degrees of pos-tagging accuracy (99.x%) and run rapidly. Their primary flaw is you have to hand code all the rules of grammar (say around 1500 of them) and need a lot of grammatical expertise. And there are no open-source versions of them.
So one complaint I have is with accuracy. Even on work they are
trained on, they reflect probability of words. So they become blind to
low probability events. Like I ate everything but my dog
.
The dictionary tells us that but
is usually a coordinating
conjunction, but also rarely a preposition. In the sentence above, ML
parsers always claim it is a coordinating conjuction, though in fact it
is a preposition. And you can’t parse this sentence correctly if you are
wrong about the part of speech.
Another complaint is speed and memory requirements. The simpler of the Stanford parsers is the PCFG one. On an Intel i5 2.53 Mhz machine, a 27 word sentence takes 1.5 seconds and 100 Mb. ChatScript takes under 10 milliseconds and 50Mb with a full dictionary. You can run with a large dictionary in 16Mb for a cellphone.
And a fourth complaint is that Stanford’s system will always return a parse, even if the parse is not reasonable. The parse of is it on me? given that it treats on as an adverb instead of a preposition, is garbage and is similar to is it me? with an extra adverb tacked on. For other sentences it can’t say I find no verb so either this isn’t a sentence or something is wrong. It has no way of knowing that maybe it failed when sometimes one clearly could if one knew grammar.
My fifth complaint, the output is a tree structure, which then needs to be reinterpreted by some other tool.
And my sixth complaint is that Stanford’s errors are uniformly distributed. It doesn’t matter if the sentence is a short one, a first grade sentence, whatever. It will make errors in simple sentences as well as complex ones. Particularly for chat, simple sentences are more likely, so I would prefer a pos-tagger that was more accurate on easy stuff.
And my final complaint is that you can’t readily fix an ML tagger’s mistakes. It has to be trained on a corpus and creating one that will fix issues is hard and not ever done.
The Stanford Parser (and I pick on it merely as representative of all statistical parsers of which it is considered one of the best) is 97.3% accurate in uniform ways. That is, it is flawed on all kinds of input from simple sentences to complex ones. Simple sentences can defeat it. It can handle It is on me but not Is it on me? which becomes: is (verb) it (pronoun) on (adverb) me (pronoun) making on an adverb instead of a preposition.
And it has weird variances: Get it off of me labels off as a particle (correctly) but _get the spider off of me labels off as an adverb (differently and wrongly). Or if you say I saw Dad do it it correctly labels Dad as a proper noun. Same for Father and Mother. But Mom it labels as an ordinary singular noun, even while keeping it capitalized in its output. Or consider my dog is a blue being which it correctly labels blue as an adjective and being as a noun. But my dog is a big blue being it labels blue as a noun and being as a verb phrase present participle.
It is particularly inept at distinguishing pronouns from determiners (always considering them determiners), so it will parse this sentence I’ll take all I can get by labelling all as a determiner. Similarly with All she had to do was ask, it treats all as a determiner.
The main sentence should parse to all was ask with an implied that she had to do clause modifying all. And, strangely, the Stanford pos tagger likes to label ago as IN (prepostion or subordinate conjunction), which it never is, instead of adverb like in they lived twenty years ago. I can’t even imagine how that error exists in the system. Even the simple Many are poor has many considered a determiner - but there is no noun. And if you say many of them are poor it changes many from a determiner to an adjective. Still no noun anywhere in sight.
It also doesn’t handle simple stuff like what swims are safe, considering swim to be a verb. And it generally always thinks can is a modal verb, like in what can goes pop?.
There are also other interesting issues with quantifier phrases. A lot of children eat. Do you want the subject to be lot or children. If a lot of is a quantifier idiom, then the subject is children. If you are doing raw pos-tagging, then the subject is lot. Either will work, but I’d rather have children be the subject. Same for Some of the honey spilled. Normal parses have some is the subject. But that’s underinformative. CS treats Some of the as an idiom determiner, so the subject becomes honey.
Consider this sentence: he painted the car purple. The Standford tagger says: he/PRP painted/VBD the/DT car/NN purple/NN which means it claims _purpl_e is a noun. I can live with that, though one might prefer purple be considered an adjective. The parse, however, becomes problematic. Should it be considered subect verb indirectobject object or subject verb objectcomplement. Or is it subject verb directobject (the object being car purple)? Its parse looks just like a parse for he painted the bank teller.
This gets even messier given that ChatScript will attempt named entity extraction - it will decide some sequences of words represent a single upper-case compound name.
By default ChatScript attempts to detect named entities given as multiple words, and merge them into a single token with underscores. united states of america becomes United_States_of_America. This is not without its hazards. The WORLDDATA ships with a large number of names of works like movies, tv shows, books, etc. These can collide. Don’t lie to me can see lie to me as a possible TV show name. The merging code will ALWAYS merge quoted strings and capitalized sequences, so Lie to Me will get merged. It will also merge any sequence whose result is marked with the property ALWAYS_PROPER_NAME_MERGE. Currently world data adds this on to all location names (countries, cities, states) so they are always a single token no matter what case is used. The merging code will not automatically merge the names of TV shows. Nevertheless the sequence will be marked with its appropriate concepts because the system checks sequences of words even if they are not merged. So you would get lie to me Lie to Me all marked appropriately and it is up to the script to distinguish.
I personally run script early on that sees if
~NOUN_TITLE_OF_WORK
matches. If it does, it determines if
it was used in a sentence involving relevant verbs like I watched
lie to me yesterday or if the user entered it capitalized or quoted
or if we were already in the TV topic. If none of those are true, the
script erases the ~TV
topic mark using
^unmark
. This prevents the system from erroneously trying
the TV topic. You can also just turn off proper name merging by changing
the value of $TOKEN
removing the
| #DO_PROPERNAME_MERGE
value usually applied, at the cost
of having to deal with named sequences yourself in script.
The ChatScript parser runs by default on all input, doing what it can to parse it. If it believes it failed to parse correctly then it will set the tokenflags appropriately. You can test for this like this:
u: ( %tokenflags&#FAULTY_PARSE)
You can suppress the parser by setting $token
to NOT
have the request to parse | #DO_PARSE
If the parser is not
run, then the pos-tags of all words will still be partially performed,
reducing the set of word interpretations as much as it can without
risking losing any correct pos-tag. But you will not get any parse
information..
The fragments of a successful parse are retrievable using concepts.
The main sentence, because it may not contiguous and is special, does
not have a composite retrieval. Instead you can retrieve
~mainsubject
, ~mainverb
,
~mainindirect
, ~maindirect
. Things which are
contiguous chunks are phrases, clauses, and verbals.
ChatScript has a complexity limit, and will not accept sentences near 255 words. Also, sentences containing more than 7 of some particular concept will not mark after the first 7. So a sentence with 8 nouns will not have a ~noun after the 7th. If the nouns were a mixture of singular and plural, then it will represent them, up to the 7 limit.
ChatScript recognizes these structures: the main sentence, prepositional phrases (called phrases), subordinate clauses (called clauses) and various verbal expressions (called verbals) like gerunds, adjective participles, and noun infinitives.
Parse results are all concepts and are matched just like any other. E.g.,
u: (_~mainsubject * _~mainverb * _~mainobject) A 3 piece sentence in normal order.
See the manual ChatScript System Variables and Engine-defined Concepts for a list.
In addition, you may find ^phrase(type matchvar) useful to retrieve
all of a prepositional phrase or a noun phrase. Type is
noun
, prepositional
, verbal
,
adjective
. Optional 3rd argument canonical
will return the canonical phrase rather than the original phrase.
E.g.,for input:
u: (I ~verb _~directobject) $tmp = ^phrase(noun _0)
with input I love red herring $tmp
is set to
red herring.
Sentence parse data comes in 3 kinds:
s:
?:
and
\!
pattern%tense %voice %sentence %quotation %impliedyou %impliedsubject %foreign
%command %parsed %question %length
%tense = { past, present, future}
%voice = {active, passive}
There are 2 phases that can intermix. The first are rules that try to
remove obviously illegal pos values. These rules are in
LIVEDATA/ENGLISH
. I have a standard test
:pennmatch raw
which takes a bit above 90K tokens in 3800 pennbank sentences and
reports those that have incorrectly pruned
(REGRESS/PENNTAGS/penn.txt
). It’s goal is to maximally
prune while NEVER removing a valid pos-tag. It currently prunes badly 2%
of the time and prunes 47K ambiguous words down to 15.7K.
The next phase is hard code parsing. It tries to find a sentence structure that works, using a garden path algorithm. Along the way it can assign pos, rerun rules, assign roles, and sometimes override prior pos decisions when it finds a conflict. It gets run as
:pennmatch
and currently is 94% right in pos-tagging.
:pos this is a sentence
displays what it is doing as it pos/parses.
TreeTagger has a pos-tagger for English (see Foreign language support about TreeTagger) and if you have a license for it, it works in conjunction with ChatScript’s own tagger to yield a better result than either separately. In the bug reports study, TreeTagger performs the best in assigning tags to nouns and verbs, while the Stanford tagger performs the best in assigning tags to adjectives and adverbs. In general I care more about nouns and verbs.
While ChatScript supports UTF8 for input and scripting, a lot of ChatScript’s power comes from the concise pattern matching code. That, in turn, stems from the ability to define concepts, and to take advantage of ChatScript’s dual input stream - original word and lemma (canonical form). So instead of having to write patterns naming all forms of a verb, you can just use the lemma form and mean all of them. Or the singular noun to catch plural as well. That ability depends on pos-tagging abilities.
CS allows you to use an external pos-tagger and/or parser and/or spelling corrector for other languages. It comes with a German simple bot to illustrate how to do this, using TreeTagger. Treetagger is one example you can use (many others exist). TreeTagger has windows, mac, linux versions. TreeTagger supports a wide range of languages for free but you need a license if you want to use it commercially. The local non-commercial copy is annoying in that it outputs a couple of processing status messages as it goes, but it would have no impact if CS is being used as a server, and at least allows you to experiment. I presume the commercial license would enable you to remove them.
http://www.cis.uni-muenchen.de/~schmid/tools/TreeTagger/ (Author: Helmut Schmid, CIS, Ludwig-Maximilians-Universität, Germany).
The German bot assumes you have installed TreeTagger and the german data per instructions provided on his website. I have only tried the Windows installation.
To use a foreign tagger, you set the $cs_externaltag
variable in your bot definition to a topic (called in Gambit mode) that
will perform the work. And you need to disable ChatScript from
performing the work. Make your bot definition $cs_token
NOT
use the following: #DO_SPELLCHECK
, #DO_PARSE
,
#DO_SUBSTITUTE_SYSTEM
(since that is english substitutions
and punctuation processing).
In your tagging topic, you invoke your spellchecker, or tagger, or
parser, either locally via ^popen
or remotely using
^tcpopen
or ^jsonopen
. And then process the
return data and use one or more of these functions to alter ChatScript’s
internal data.
^setcanon
(wordindex value) - changes the canonical value
for this word ^settag
(wordindex value) - changes the
pos tag for the word ^setoriginal
(wordindex value) -
changes the original value for this word
^setrole
(wordindex value) - changes the parse role for
this word
The first important one is ^setcanon, to allow the CS dual input
processing to work in patterns. If you are doing spell checking, you may
use ^setoriginal
to revise the original word. SetTag and
SetRole are for the pos value and Role value (mainsubject, mainverb,
etc). These values will come back in whatever notation your external
system uses. All of this happens BEFORE Chatscript starts marking things
and therefore if you use :trace
prepare, you can see the
results of the annotations in the concepts triggered.


Fabio Curi, VU, MSc 2019. Linguistic features for Low-Resource Neural Machine Translation
David Zomerdijk, UvA, MSc 2018. Finding Frequently Asked Questions.
Erik Stammes, UvA, BSc 2018. Contextual Slot Filling for Task-Oriented Conversational Agents.
Alexander Geenen, UvA, MSc candidate. Recognising Textual Entailment based on graph neural networks.
Tirza Soute, UvA, MSc candidate. Recognising Textual Entailment based on Bayesian deep learning.
Thijs Brouwers, VU, MSc candidate. Text Summarisation based on self-attention neural architectures.


Lift Evac Process/Protocol Guide
Assess (Phase 0)
4 min: Notify Patrol Base
- Base to monitor Ch.1; listen for mechanic dispatch
5 min: Notify Lift Maintenance
(if not already done)
- If lift maintenance is not available, notify resort management (MOD)
10 min: Stranded Staff
| # of staff | Tower # | Chair | SP / MS |
|---|---|---|---|
WAIT FOR INSTRUCTION FROM RESORT MANAGEMENT
Standby (Phase 1)
On order from Resort Management- Establish communication network (ch 2)
- Designate Evac Supervisor
- All available personnel to Top Duty
- Assemble evac teams
- Break evac bag seals
- Belayers put on harnesses
- Reposition resources as needed
Deploy (Phase 2)
On order from Resort Management- Teams deploy to assigned spans and STANDBY
- Teams report "in position"
- Evac Supervisor notifies Resort Management when ready
Evacuate (Phase 3)
On order from Resort Management- Lift power lockout: Evacuation Supervisor MUST hear and POSITIVELY acknowledge that the lift has been locked out before starting by the Lift Supervisor
- Order evacuation
- Each team reports confirmation
- Begin evacuation
- Mountain Safety: Record the name, address, phone, chair number and time of guest evacuation
- 10 minutes updates to management
- Evacuation Supervisor: Direct final check of all chairs and sweep of the area; obtain “all clear” confirmation
Post Evacuation (Phase 4)
On order from Resort Management- Data compiled to management
- Debrief and repack gear
- Note any damaged or missing gear to Evacuation Supervisor


Lagos to relocate 400 Jakande Estate residents - The Nation Newspaper
Tajudeen Adebanjo
Lagos State government said it would relocate 400 residents of the Lateef Jakande Estate because of reconstruction.
The estate is in Ilasan, Eti-Osa Local Government Area.
The relocation, Commissioner for Housing, Moruf Akinderu-Fatai said, will be temporary to one of the state-owned schemes which will soon be completed.
Akinderu-Fatai said Governor Babajide Sanwo-Olu’s administration is determined to regenerate the housing estate.
He said: “We are committed to the regeneration of Ilasan and other parts of the state in line with sustainable development goal SDG 11 which is focussed on creating sustainable and livable cities and communities.
“The regeneration programme will involve reconstruction of dilapidated structures and repair of run down infrastructures which are no longer safe for further human utilisation.
“In regenerating the estate, we will also take cognisance of access to quality education, health facilities, efficient public transportation, refuse collection services, sewage, human safety and good air quality, among other things.
“We are working with other ministries and agencies to promoting a robust neighbourhood life through availability of structures that encourage community activities.”
READ ALSO: Jakande Estates: Waiting to crash?
Akinderu-Fatai said habitation in Ilasan is dangerous and injurious to healthy living, hence the government’s determination to intervene by reconstructing the estate as soon as possible.
He explained that the decision was based on the need to set good standards of sustainability for future generations of Lagosians.
“The future of our state is very important, hence we must make the right decisions today in order to bequeath a legacy of sustainability to the generations yet unborn”.
“We are set to make the provision of housing beyond mere shelter by promoting a better quality of life through enhancing inclusive and sustainable urbanisation,” he added.


DiscordShell
Control discord chat-bots
Create a bot token and insert it in this website to start controlling a bot. Click the plus sign to open an new tab and add a bot.
Create a bot token and insert it in this website to start controlling a bot. Click the plus sign to open an new tab and add a bot.


querybts(1) querybts(1) NAME querybts - view outstanding bug reports on a debbugs server SYNOPSIS querybts [options] <package | number [number2]...> DESCRIPTION querybts is designed to provide a convenient and easy-to-use interface to the Debbugs bug tracking system, as used by Debian and several other projects. You can specify a package name or one or more report numbers. OPTIONS The program follows the usual GNU command line syntax, with long options starting with two dashes (`--'). A summary of options are included below. -h, --help Show summary of options. --version Show the version of querybts and exit. -A, --archive Browse archived bugs instead of current reports. Debbugs servers clear out closed reports after 28 days and place them in a sepa‐ rate archive; this option allows those older, resolved reports to be viewed (at least for servers that maintain an archive). -B SYSTEM, --bts=SYSTEM Instead of the Debian bug server, use the server specified by SYS‐ TEM. Valid options are default and debian but check --help for an updated list. -b, --buglist Display a bugs list for the given package. --latest-first Display the bug reports list sorted and with the latest reports at the top. --mbox-reader-cmd=MBOX_READER_CMD Specify a command to open the bug reports mbox file. You can use %s to substitute the mbox file to be used, and %% to insert a lit‐ eral percent sign. If no %s is specified, the mbox file name is supplied at the end of the argument list. -m, --mbox Retrieve the given bug number(s) or package name(s) as a mailbox file, instead of viewing it. It will be dumped to standard output. --proxy=PROXY, --http_proxy=PROXY Specify the WWW proxy server to use to handle the queries to the bug tracking system. You should only need this parameter if you are behind a firewall. -s, --source Query on source packages, rather than binary packages. --timeout=SECONDS Specify the network timeout, the number of seconds to wait for a resource to respond. If nothing is specified, a default timeout of 1 minute is selected. In case of a network error, there are chances it's due to a too low timeout: try passing the --timeout option with a higher value than default. -u INTERFACE, --ui=INTERFACE, --interface=INTERFACE Specify the user interface to use. Valid options are text, urwid, gtk2; default is taken from the reportbug configuration files. -w, --web Launch a web browser to view bug reports, instead of using the internal interface. This will also allow you to see the whole discussion about a particular bug at once, instead of one message at a time as querybts would do. (Only the first bug number on the command line will be opened.) CONFIGURATION FILES querybts supports a simple run control file syntax. Commands are read from /etc/reportbug.conf and $HOME/.reportbugrc with commands in the lat‐ ter overriding those in the former. Commands are not case sensitive, and currently take 0 or 1 argument; arguments containing whitespace must be enclosed in quotes. Any line starting with # is taken to be a comment and will be ignored. Generally, options corresponding to the long options for querybts are supported, without leading -- sequences. See the default /etc/report‐ bug.conf for all acceptable options and reportbug.conf(5) for all accept‐ able options and detailed information. Options only supported by reportbug will be silently ignored. ENVIRONMENT BROWSER Colon-separated list of web browsers to try; they will be tried in order, until one succeeds. You can use %s to substitute the URL to be used, and %% to insert a literal percent sign. If no %s is specified, the URL will be supplied as a normal argument. Provides the address of a proxy server to handle the BTS query. This should be a valid http URL for a proxy server, including any required port number (simply specifying a hostname, or omitting a port other than 80, WILL NOT WORK). SEE ALSO reportbug(1), reportbug.conf(5) AUTHOR Chris Lawrence<EMAIL_ADDRESS>Sandro Tosi<EMAIL_ADDRESS>querybts(1)


{{ personal-details.full-name }}'s
Letter of Last Instructions
Purpose of Document
The purpose of this letter is to give my representative or family member the information they will need concerning my personal and financial matters.
Death Notification
Contact each individual in the Emergency Contacts below and make sure they are informed of my death. A few are responsible for carrying out these instructions.
Carrying Out Instructions
Below you will find instructions for handling personal matters, such as terminating accounts, notifying insurance agencies, body disposal & funeral wishes.
Emergency Contacts
{{ emergency-contacts.instructions }}
Funeral Arrangements
{{ funeral-arrangements.instructions }}
Organ Donar
{{ funeral-arrangements.organ-donar }}
Body Disposal
{{ funeral-arrangements.body-disposal }}
Type of Service
{{ funeral-arrangements.type-of-service }}
Service Location
{{ funeral-arrangements.service-location }}
Request Autopsy
{{ funeral-arrangements.request-autopsy }}
Embalming
{{ funeral-arrangements.embalming }}
Public Viewing
{{ funeral-arrangements.public-viewing }}
Coffin Preference
{{ funeral-arrangements.coffin-preference }}
Burial Location
{{ funeral-arrangements.burial-location }}
Burial Instructions
{{ funeral-arrangements.burial-instructions }}
Funeral Instructions
{{ funeral-arrangements.funeral-instructions }}
Obituary Instructions
{{ funeral-arrangements.obituary-instructions }}
Other Instructions
{{ funeral-arrangements.other-instructions }}


!= include('style'); ?>
SmartIQ Workshop Event Selection
Your email -
Please select one of the following times to attend:
!= include('script'); ?>


Simple app that lists top 100 GitHub users that are living in Thailand, ordered by follower count.
Note that there's an API limit which will allow only 5 call per minutes. So if you see blank page, simply hit refresh until something shows up.
About Rate limit.
We can get more info for users such as real name, follower count but that require me to register this app as an OAuth app on GitHub which I'm too lazy to do.


In this template we will take a look at a typical problem when talking to other systems: dealing with their failure.
Especially when talking to publicly available services you cannot always operate under the assumption that the third-party service will always be available and always perform well. One reason for a third-party service not being available can be a high load that is crippling the system. Therefore just continuing to send your messages to that system will make the problem worse. A better solution would be to detect problems with third-party systems and react accordingly by stopping sending requests. But this is not only useful in scenarios in which you communicate with third-party services, you can use this to avoid overflowing your own actors, as well.
Akka provides a circuit breaker component for this exact scenario in its pattern package, and there is a nice documentation for it. But in most real-world scenarios using only the circuit breaker will not be enough. In this template we will take a look how to deal with the problems that might arise.
First we will need a Service to call. We will simulate this service using an actor. Take a look at the code in Service.java.
The Service actor will simulate a service that becomes very slow from time to time.
In the constructor we set up a regular Swap
message, that will be sent to the actor every 2
seconds.
When receiving the Swap
message the actor will change its behavior. In its normal state it will
reply to
each Task
message with a Response
message. Upon the first Swap
message it
will change its behavior. In this new state it will block for 1 second and ignore the message. No response will
be sent.
The next Swap
message will
revert the Service back to the normal behavior. Please note that blocking inside your actors is not something
that should be done under normal circumstances. In this case, however, it simulates exactly what we need, a
service that does not respond to our
requests, and does not handle new requests in the mean time. A nice side-effect is that the queued messages
prevent the swap message from being handled, an indication that us sending the service messages impedes it from
recovering.
Let's see what happens when we run it.
We defined a main
method in the Main.java class. It creates an actor
system, and the service actor, as well as a TaskCreator
actor, that will create the
Tasks
. To do this we set up a regular Tick
message that will be sent every 200
milliseconds and triggers creation of tasks. Then we wait for 10 seconds, before shutting everything down.
Thanks to the log statements in the
actor we can observe what happens when we execute the program. Each Task
message receives incremented ids, so we can follow the messages in the log.
First we will see a number of requests and responses, after 2 seconds the first Swap
message is
received and we see that there is a delay of one second between request and response. After 2 seconds the second
Swap
message should arrive, but as there are still Task
messages in the
Service
actors mailbox, the Swap
message will be delayed. Obviously this is a problem.
Let's try to take the load off our service.
Let us tackle the problem using a circuit breaker. The relevant code can be found in SimpleCircuitBreaker.java.
Let us go through the code.
First we need to initialize the circuit breaker:
new CircuitBreaker( getContext().dispatcher(),
getContext().system().scheduler(),
MAX_FAILURES,
CALL_TIMEOUT,
RESET_TIMEOUT )
We need to specify the dispatcher the circuit breaker will be running on, as well as a scheduler. The scheduler is
necessary as the
circuit breaker uses Callable
s to send the messages to the service. Next, we set the maximum number of
failed
attempts before the circuit breaker opens. This setting is very specific to your situation. If the service you
are talking to is on the same machine as your Akka process, you can use a low setting, as failures are most
likely caused by problems within the service. On the other hand, a service you connect to through the internet may
fail on occasion because there are problems with the connection, you will want to make sure that you do not
stop the message flow just because one or two messages got lost. Similarly the next two settings depend very
much on your unique situation. First, the call timeout specifies how long the circuit breaker is willing to wait
for a response. If the response is not received in this timeframe, it will be considered failed. The last
parameter is the reset timeout, the time the circuit breaker will wait after opening until it tries to send
another request.
After creating the circuit breaker, we register some callbacks to be notified when the circuit breaker changes its state. In this case we will simply log the changed state, you could have more complex logic in there though.
Now, take a look at lines 61-67 to see how to send messages to the service using the circuit breaker. The
circuit breaker
provides two modes of operation, callWithCircuitBreaker will make the call asynchronously and return a future
containing the result of the call, while callWithSyncCircuitBreaker allows you to perform a synchronous call. We
will use the
asynchronous method here. The method expects a callable object as parameter, which we will declare anonymously
at this point. The callable needs to return a Future<Object>
. This makes it very natural to
combine the circuit breaker with the Ask
Pattern, since it returns
Future<Object>
. We send the Task
to the service, and let the circuit breaker
wait for the response for us. In order to return the result to our caller, we use the PipeTo
pattern to return the response once the future is done.
Time to run the example. Go to the Main.java class and comment line 13, while uncommenting line 14,
system.actorOf( SimpleCircuitBreaker.props(), "SimpleCircuitBreaker" );
Once you've done this, click Save
and switch to the Run tab. Activator should run the program after compiling automatically,
unless you switched this off. In that case, just click the Start
button.
Using the CircuitBreaker works quite nicely for our use case. After the service switches into slow mode, it will
still receive some messages until the circuit breaker realizes something is wrong, but then the flow of messages
stops, and the service can recover. The circuit breaker will probe if the service is available again, and if it
is, will resume sending the requests.
There is one problem though. The Task
messages that are sent while the Service is in slow mode are
never delivered.
Before we move on, note that we use the call timeout of the circuit breaker for the ask timeout. This may or may
not make sense for your use-case. You may want to use a longer timeout for the ask, so as to still receive
responses from the service, even if the circuit breaker will treat that call as failed and cease sending further
messages. Note that you will need to add handling of the messages in this case, as responses of timed out calls
are not returned. Also, it is noteworthy that for the asynchronous call method the call timeout is only used to
decide if
the call failed or succeeded, the call will not be interrupted after the timeout. This is useful when you want
to get the result, but it means that the circuit breaker will open only after the call finishes. Try setting the
ask timeout to a higher value in the code (e.g. 500
), and see what happens. This is not the
intended behavior, and a issue is open for this.
For some use cases this simple solution is already all you need. But usually creating our messages was hard
work, we want to make sure they all reach the target. Right now they are just being discarded. So we need to
make sure to remember all messages for which we did not receive a response from our service yet. There are
several possibilities to do this. While it is entirely possible to do this using a queue and some
become
magic, this is not necessary anymore. Akka 2.3 saw the introduction of Akka Persistence,
which allows to persist messages, which sounds like just the thing we need.
What we are trying to do here, is to accomplish at-least-once delivery. Normally Akka guarantees at-most-once delivery (read here for a detailed discussion of message delivery reliability), and this is what we saw in the earlier examples, no Task was delivered twice to the service. However, a lot of the Tasks got lost on the way. With at-least-once delivery we will make sure that every one reaches its destination.
If you have used the eventsourced library or the Akka Persistence API prior to 2.3.4, you might have used
channels for this. However, in an attempt to streamline the API, the Akka team greatly reduced the amount of
concepts. Now, if you want to use persistence, you will have to use UntypedPersistentActor
. This
actor provides event-sourcing, which means that, unlike in command-sourcing, not every message that is received will automatically be persisted. Instead you have to provide persit blocks that will persist the events that are created from received commands. This is a very nice way to recreate your actors state, as you only persist and replay events that influence the actors state, if you receive other messages (e.g. to retrieve the actor state), these do not need to be persisted and replayed. Usually you separate updating the state and any side effects like sending messages, so that the side effects are not triggered during recovery.
To use at least once delivery, Akka persistence introduces the perfectly named UntypedPersistentActorWithAtLeastOnceDelivery
. This actor lets you create a deliver
block, in which you can provide a message and a destination. Each message needs to have a deliveryId
. This id will be used to confirm that the message has arrived. For this the receiver needs to respond with a message that contains this deliveryId
. When you receive this response you then call the confirmDelivery
method with the deliveryId
as the argument. Akka Persistence will attempt redelivering the message until such a response is received. Both the event from which you create the message to be delivered and the response need to be persisted. This way if the actor crashes and restarts it will know which messages have already been delivered, and which need to be resent.
Let us take a look of how this looks in our example.
Take a look at PersistingCircuitBreaker.java
The PersistingCircuitBreaker
actor extends the UntypedPersistentActorWithAtLeastOnceDelivery
. UntypedPersistentActor
provides two abstract receive methods, onReceiveCommand
and onReceiveRecover
, the former is the regular receive method, while the latter will only be used when the actors starts and performs recovery of persisted events. Furthermore the UntypedPersistentActor
provides methods that can be overwritten to change some settings. We use redeliverInterval
and persistenceId
. The persistenceId is especially important, as it will mark all messages for this actor. Per default the actor path is used, which works well in most cases, but can be a problem if you change your path or if your actor has no name (as the path will then be dependend on the order in which the actors are started).
We also create a circuit breaker actor, that is basically equal to
the SimpleCircuitBreaker
actor we used in the last step. Upon receiving a Task
message
the PersistingCircuitBreaker
will wrap it into an envelope to preserve the original sender. We need to preserve the original sender, as the PersistingCircuitBreaker
needs to receive the response to confirm the delivery. We then persist the envelope to be able to resend the message during actor recovery and pass it on to the updateState
method. This method encapsulates the delivery part, as it needs to be performed during recovery as well as normal operation. Here we will put the TaskEnvelope
into a new message type which contains the deliveryId. We specify the circuit breaker actor as a receiver. Note that we need to use the path for sending here. This is because the semantics of at-least-once delivery are more in line with sending to ActorSelection than sending to ActorRef, which is made visible by using the path instead of the ref.
The handling of DeliveryConfirmation
is similar. We also need to persist it, and pass it on to the updateState method. However, before we do that, we extract the response from the service from the confirmation and send it to the original sender. We do not put it into the updateState method, as this would cause the message to be sent each time during recovery, we do not want that. Using event-sourcing it is easy to separate side-effects (sending of the response) from state updates (confirmation of the delivery). In the updateState method we simply confirm that the response was received, and that Akka does not need to try resending the message anymore.
In CircuitBreakerPersistentActor
we had to add handling of TaskEnvelope
messages. We extract the task from the envelope and send it to the service, and if we receive a Response
message, we wrap the response into a DeliveryConfirmation
message, that contains all information the PersistingCircuitBreaker
actor will need.
We use the resending feature to make sure Task
s that were rejected by the circuit breaker or received no response from the service will be resent. A nice side-effect is that our messages survive a restart of the actor or the complete actor system. If you run the example twice you will see messages that were not confirm in the last run being sent around 1 second after the start.
Go to the Main.java class and comment line 14, while uncommenting line 15,
system.actorOf( PersistingCircuitBreaker.props(), "PersistingCircuitBreaker" );
Once you've done this, click Save
and switch to the Run tab. Activator should run the program after compiling automatically,
unless you switched this off. In that case, just click the Start
button.
Starting the program we now see that after the service recovered it will receive the messages that could not be sent during the down time. Usually you will see Tasks 23-25 before tasks 11-20 will be replayed. That is because the redelivery time is set to 1 second.
The combination of persistent at-least-once delivery and the circuit breaker is quite nice, if you are dealing with unreliable services. However, problems can arise if the service is unavailable for a long time or you send a high number of messages. As the UntypedPersistentActorWithAtLeastOnceDelivery
actor stores all undelivered messages in memory you can face problems when a lot of messages are waiting for delivery. There is a setting for the at-least-once delivery, maxUndeliveredMessages
which can be used to deal with the problem. Now, when the limit is reached trying to deliver new messages will result in an Exception being thrown. In such a case you use supervision to divert all messages to a temporary storage until sending is possible again. Or you could stop creating new messages or take other measures that make sense for your business case.
In order to gain more experience with circuit breakers you can try several things using this template:
We hope you had fun going through this template with us. Any issues, feedback or questions can be given using the GitHub page of this template.
Happy hAkking !


{% extends 'pypi_packages/base.html' %} {% block title %}Delete {{ package }}{% endblock %} {% block content %}
You are about to delete {{ package }}.
Are you sure you want to delete {{ package }}?


Our
[western]
society has taught us
to understand that knowing is
the only way to be viewed as having knowledge.
Not-knowing is viewed as having less knowledge
therefor less in the eyes of society.


pyglet provides a basic representation of the framebuffer as components of the AbstractImage hierarchy. At this stage this representation is based off OpenGL 1.1, and there is no support for newer features such as framebuffer objects. Of course, this doesn't prevent you using framebuffer objects in your programs -- pyglet.gl provides this functionality -- just that they are not represented as AbstractImage types.
A framebuffer consists of
You cannot create the buffer images directly; instead you must obtain instances via the BufferManager. Use get_buffer_manager to get this singleton:
buffers = image.get_buffer_manager()
Only the back-left color buffer can be obtained (i.e., the front buffer is inaccessible, and stereo contexts are not supported by the buffer manager):
color_buffer = buffers.get_color_buffer()
This buffer can be treated like any other image. For example, you could copy it to a texture, obtain its pixel data, save it to a file, and so on. Using the texture attribute is particularly useful, as it allows you to perform multipass rendering effects without needing a render-to-texture extension.
The depth buffer can be obtained similarly:
depth_buffer = buffers.get_depth_buffer()
When a depth buffer is converted to a texture, the class used will be a DepthTexture, suitable for use with shadow map techniques.
The auxilliary buffers and stencil bits are obtained by requesting one, which will then be marked as "in-use". This permits multiple libraries and your application to work together without clashes in stencil bits or auxilliary buffer names. For example, to obtain a free stencil bit:
mask = buffers.get_buffer_mask()
The buffer manager maintains a weak reference to the buffer mask, so that when you release all references to it, it will be returned to the pool of available masks.
Similarly, a free auxilliary buffer is obtained:
aux_buffer = buffers.get_aux_buffer()
When using the stencil or auxilliary buffers, make sure you explicitly request these when creating the window. See OpenGL configuration options for details.


Language placeholder
Grid demo
Editor demo

 Kendo UI Editor allows your users to edit HTML in a familiar, user-friendly way.
 In this version, the Editor provides the core HTML editing engine, which includes basic text formatting, hyperlinks, lists, and image handling. The widget outputs identical HTML across all major browsers, follows accessibility standards and provides API for content manipulation.

Features include:

Text formatting & alignment

Bulleted and numbered lists

Hyperlink and image dialogs

Cross-browser support

Identical HTML output across browsers

Gracefully degrades to a textarea when JavaScript is turned off

 Read more details or send us your feedback!

Validator demo
Book Tickets
Your Name
Movie
Amount
Email
Phone
I accept the terms and condition of service
Submit


Website Look And Feel Generator
- Pro
- It requires only sh/sed posix shell tools to build doc pages.
- It can build a common navigation bar and a sitemap for all webpages.
- The program is a single short script file freely copyable
& modifiable.
- Con
- All embedded meta-information must fit on a single line each.
- There is only little more functionality than variable substititions.
- The doc processing is slow - and even slower without gnu sed.
- Neutral
- A sitefile must be written - the sitemap is not truly autodetected.
- The speedier twin perl script provides the exact same functionality.
- Best for small webpages but gets too slow for hundreds of webpages.
- The fancy results stem from the sitefile logic -
see our examples .
- Plus
- Automatic "printerstyle" page generation helping text-mode browsers.
- That style helps also for web accessibility of challenged people.
- Ships with fancy tabbed style navigation as shown on these webpages.
- Shortpage special style to print source code on full screen width.
- It can adapt hrefs to navigate web content pages in subdirectories.


-
Dijkstra’s shortest path algorithm
By: Sona C J
Given a graph and a source vertex in the graph, find the shortest paths from the source to all vertices in the given graph.
Dijkstra’s algorithm is very similar to Prim’s algorithm for minimum spanning tree. Like Prim’s MST, we generate a SPT (shortest path tree) with a given source as a root. We maintain two sets, one set contains vertices included in the shortest-path tree, other set includes vertices not yet included in the shortest-path tree. At every step of the algorithm, we find a vertex that is in the other set (set of not yet included) and has a minimum distance from the source.
- Create a set sptSet (shortest path tree set) that keeps track of vertices included in the shortest-path tree, i.e., whose minimum distance from the source is calculated and finalized. Initially, this set is empty.
- Assign a distance value to all vertices in the input graph. Initialize all distance values as INFINITE. Assign distance value as 0 for the source vertex so that it is picked first.
- While sptSet doesn’t include all vertices
- Pick a vertex u which is not there in sptSet and has a minimum distance value.
- Include u to sptSet.
- Update distance value of all adjacent vertices of u. To update the distance values, iterate through all adjacent vertices. For every adjacent vertex v, if the sum of distance value of u (from source) and weight of edge u-v, is less than the distance value of v, then update the distance value of v.


This exercise is meant to get you acquainted with the type of data you would normally encounter in an assembly/annotation project. We will for all exercises use data for the fruit fly (Drosophila melanogaster), as that is one of the currently best annotated organisms and there is plenty of high quality data available.
You can create the folders where you want but I would suggest a folder organisation, if you do not follow this organisation remember to put the correct path to your data.
mkdir bonus/assembly
cd bonus/assembly
Let’s link the raw fastq files.
mkdir raw
cd raw
ln -s /proj/uppstore2017171/courses/RNAseqWorkshop/downloads/assembly_annotation/raw_computes/* .
We will clone this Github repo from NBIS annotation team which will be used during this practical.
git clone https://github.com/NBISweden/GAAS.git
RNA-Seq data is in general very useful in annotation projects as the data usually comes from the actual organism you are studying and thus avoids the danger of introducing errors caused by differences in gene structure between your study organism and other species.
Important points to remember before starting working with RNA-Seq:
Check if sequence data is paired-end or single-end. Last generation of sequenced short reads (since 2013) are almost all paired. Anyway, it is important to check that information, which will be useful for the tools used in the next steps.
Check if the sequence data are stranded. This information will be useful for the tools used in the next steps. (It is recommended to use stranded data to avoid transcript fusion during the transcript assembly process. That gives more reliable results.)
Left / L / forward / 1 have identical meaning. It is the same for Right / R /Reverse / 2
We run a quick QC to check encoding version and fastq quality score format. We have to use FastQC tool.
module load bioinfo-tools
module load FastQC/0.11.5
mkdir fastqc
fastqc ./raw/ERR305399_1.fastq.gz -o fastqc/
Copy the FastQC report HTML file to your system and inspect the results. You can use SCP
to copy the file. Run the command below from a LOCAL terminal.
scp user@rackham.uppmax.uu.se:[path-to-report.html] .
Next, we check the fastq quality score format. For this, we will be using the scripts libraries available in the git gaas you need first to export the libraries and run the script fastq_guessMyFormat.pl
.
export PERL5LIB=$PERL5LIB:./GAAS/annotation/
./GAAS/annotation/Tools/bin/fastq_guessMyFormat.pl -i ./raw/ERR305399_1.fastq.gz
In the normal mode, it differentiates between Sanger/Illumina1.8+ and Solexa/Illumina1.3+/Illumina1.5+. In the advanced mode, it will try to pinpoint exactly which scoring system is used.
More test can be made and should be made on RNA-seq data before doing the assembly, we have not time to do all of them during this course. have a look here
In this section, we run a genome-guided transcriptome assembly. We use Trimmomatic to trim the reads, HISAT2 to map reads to reference genome and StringTie to assemble reads into transcripts.
Trimmomatic performs a variety of useful trimming tasks for illumina paired-end and single ended data.The selection of trimming steps and their associated parameters are supplied on the command line.
mkdir trimmomatic
module load bioinfo-tools
module load trimmomatic/0.36
The following command line will perform the following: * Remove adapters (ILLUMINACLIP:TruSeq3-PE.fa:2:30:10) * Remove leading low quality or N bases (below quality 3) (LEADING:3) * Remove trailing low quality or N bases (below quality 3) (TRAILING:3) * Scan the read with a 4-base wide sliding window, cutting when the average quality per base drops below 15 (SLIDINGWINDOW:4:15) * Drop reads below the 36 bases long (MINLEN:36)
java -jar /sw/apps/bioinfo/trimmomatic/0.36/milou/trimmomatic-0.36.jar PE -threads 5 -phred33 ./raw/ERR305399_1.fastq.gz ./raw/ERR305399_2.fastq.gz trimmomatic/ERR305399.left_paired.fastq.gz trimmomatic/ERR305399.left_unpaired.fastq.gz trimmomatic/ERR305399.right_paired.fastq.gz trimmomatic/ERR305399.right_unpaired.fastq.gz ILLUMINACLIP:/sw/apps/bioinfo/trimmomatic/0.36/milou/adapters/TruSeq3-PE.fa:2:30:10 LEADING:3 TRAILING:3 SLIDINGWINDOW:4:15 MINLEN:36
Once the reads have been trimmed, we use HISAT2 to align the RNA-seq reads to a genome in order to identify exon-exon splice junctions. HISAT2 is a fast and sensitive alignment program for mapping next-generation sequencing reads (whole-genome, transcriptome, and exome sequencing data) against a reference genome.
First you need to build an index of your chromosome 4
mkdir index
module load HISAT2
module load samtools/1.8
hisat2-build /proj/uppstore2017171/courses/RNAseqWorkshop/downloads/assembly_annotation/chromosome/chr4.fa ./index/chr4_index
Then you can run HISAT2 : * --phred33
Input qualities are ASCII chars equal to the Phred quality plus 33. This is also called the “Phred+33” encoding, which is used by the very latest Illumina pipelines (you checked it with the script fastq_guessMyFormat.pl)
* --rna-strandness <string>
For single-end reads, use F or R. F means a read corresponds to a transcript. R means a read corresponds to the reverse complemented counterpart of a transcript. For paired-end reads, use either FR or RF. (RF means fr-firststrand see here for more explanation).
* --novel-splicesite-outfile <path>
In this mode, HISAT2 reports a list of splice sites in the file : chromosome name
hisat2 --phred33 --rna-strandness RF --novel-splicesite-outfile hisat2/splicesite.txt -S hisat2/accepted_hits.sam -p 5 -x index/chr4_index -1 trimmomatic/ERR305399.left_paired.fastq.gz -2 trimmomatic/ERR305399.right_paired.fastq.gz
Finally you need to change the SAM into BAM file and to sort it in order for StringTie to use the bam file to assemble the read into transcripts.
samtools view -bS -o hisat2/accepted_hits.bam hisat2/accepted_hits.sam
samtools sort -o hisat2/accepted_hits.sorted.bam hisat2/accepted_hits.bam
StringTie is a fast and highly efficient assembler of RNA-Seq alignments into potential transcripts. It uses a novel network flow algorithm as well as an optional de novo assembly step to assemble and quantitate full-length transcripts representing multiple splice variants for each gene locus. You can add as input an annotation from GTF/GFF3 file to calculate TPM and FPKM values.
module load bioinfo-tools
module load StringTie
stringtie hisat2/accepted_hits.sorted.bam -o stringtie/transcripts.gtf
When done you can find your results in the directory outdir. The file transcripts.gtf
includes your assembled transcripts.
You could now also visualise all this information using a genome browser, such as IGV. IGV requires a genome fasta file and any number of annotation files in GTF or GFF3 format (note that GFF3 formatted file tend to look a bit weird in IGV sometimes).
Transfer the GTF files to your computer using SCP:
scp user@rackham.uppmax.uu.se:[path-to-transcripts.gtf] .
Looking at your results, are you happy with the default values of StringTie (which we used in this exercise) or is there something you would like to change?
Trinity assemblies can be used as complementary evidence, particularly when trying to polish a gene build with Pasa. Before you start, check how big the raw read data is that you wish to assemble to avoid unreasonably long run times.
module load bioinfo-tools
module load trinity/2.4.0
module load samtools
Trinity --seqType fq --max_memory 32G --left ./raw/ERR305399_1.fastq.gz --right ./raw/ERR305399_2.fastq.gz --CPU 5 --output trinity --SS_lib_type RF
Trinity takes a long time to run (like hours), you can stop the program when you start it and have a look at the results, look in /proj/uppstore2017171/courses/RNAseqWorkshop/downloads/assembly_annotation/RNAseq/trinity
and the output is Trinity.fasta
.
In order to compare the output of StringTie and the output of Trinity we need to map the Trinity transcript to the chr4 of Drosophila.
We’ll use the GMAP software to align the Trinity transcripts to our reference genome. Trinity contains a utility that facilitates running GMAP, which first builds an index for the target genome followed by running the gmap aligner:
module load gmap-gsnap
mkdir gmap
/sw/apps/bioinfo/trinity/2.4.0/rackham/util/misc/process_GMAP_alignments_gff3_chimeras_ok.pl --genome /proj/uppstore2017171/courses/RNAseqWorkshop/downloads/assembly_annotation/chromosome/chr4.fa --transcripts /proj/uppstore2017171/courses/RNAseqWorkshop/downloads/assembly_annotation/RNAseq/trinity/Trinity.fasta > gmap/transcript_trinity.gff
There are different ways of assessing the quality of your assembly, you will find some of them here.
We will run BUSCO to check the the quality of the assembly. BUSCO provides measures for quantitative assessment of genome assembly, gene set, and transcriptome completeness (what we are going to do here). Genes that make up the BUSCO sets for each major lineage are selected from orthologous groups with genes present as single-copy orthologs in at least 90% of the species in the chosen branch of tree of life.
For the Trinity results :
module load BUSCO/3.0.2b
/sw/apps/bioinfo/BUSCO/3.0.2b/rackham/bin/run_BUSCO.py -i /proj/uppstore2017171/courses/RNAseqWorkshop/downloads/assembly_annotation/RNAseq/trinity/Trinity.fasta -o busco_trinity -l $BUSCO_LINEAGE_SETS/arthropoda_odb9 -m tran -c 5
Busco will take 30 to run so you can check the results in /proj/uppstore2017171/courses/RNAseqWorkshop/downloads/assembly_annotation/RNAseq/busco_trinity
For the guided assembly results, you need first to extract the transcript sequences from the gtf transcript file :
module load BioPerl
export PERL5LIB=$PERL5LIB:./GAAS/annotation/
./GAAS/annotation/Tools/bin/gff3_sp_extract_sequences.pl --cdna -g transcripts.gtf -f /proj/uppstore2017171/courses/RNAseqWorkshop/downloads/assembly_annotation/chromosome/chr4.fa -o transcripts_stringtie.fa
Then you can run BUSCO again :
/sw/apps/bioinfo/BUSCO/3.0.2b/rackham/bin/run_BUSCO.py -i stringtie/transcripts_stringtie.fa -o busco_stringtie -l $BUSCO_LINEAGE_SETS/arthropoda_odb9 -m tran -c 5
Compare the two BUSCO results, what do you think happened for StringTie?
Now you are ready either to annotate your RNA-Seq or you can use then to do the genome annotation.
For the de-novo assembly you can use the Trinity.fasta
file obtained. For the genome-guided assembly you can either use the StringTie results transcripts.gtf
, but you will often need to reformat it into a gff file.
End of document


Opening: October 14, 1988
Architectural design: Ezequiel Nicolau
Art work: Júlio Pomar
Platform length: 105 m
Code: AH
Wikipedia page


Expressive Speech Synthesis for Dialogs
Synth text
Synthesize
Download
Adjust the style token weights
{% for token in gst_tokens %}
Token {{ token }}
0.0
{% endfor %}
Copy GST weights
or
Upload style reference
Browse
Reference name
Assign a name for the reference and add it to the bot response, e.g., {"ref": "Happy"}
Upload


Ccmailgateway.pm
Transaction conversion interfaces inwards for mail etc.
This is the second generation mail transaction logic:
- better checking - provides some feedback - remote mailboxes rather than local read of mail file - in separate module to prepare for gpg etc. etc.
Mail Transactions -> Confirm pin p123456 confirm (to be done) -> Change pin p123456 change p345678 (to be done) -> Pay send 5 <currencyname> to <username> at <registry_name> for stuff -> Query Balance balance (to be done, like sms mailed balance transaction)
Hugh Barnard
Cchooks.pm
(c) Hugh Barnard 2005 - 2008 GPL Licenced
=cut
package Ccmailgateway; use strict; use vars qw(@ISA @EXPORT); use Exporter; my $VERSION = 1.00; @ISA = qw(Exporter); use Cclite; use Cclitedb; use Ccu; ###use Ccsecure; use Ccconfiguration; # new style configuration method ###use Net::POP3; ###use Net::SMTP; my %configuration = readconfiguration; @EXPORT = qw( mail_message_parse mail_transaction );
this is the provisional solution to the multilingual message fragments later, it will go somewhere neater to change these, just substitute a translated hash
=cut
# changed to get language from decide_language 08/2011 our %messages = readmessages();
Check the sender, receiver and currency exist in the registry Also get userPublickeyid for the transaction originator so that the key can be retrieved...
sub _check_to_and_from { my ( $registry, $transaction_description_ref ) = @_; my ( $message, $token, $offset, $limit ); ###print "transaction description is $transaction_description_ref->{'text'}\n" ; # this is an email address, need to escape at least @ my $from = quotemeta( $transaction_description_ref->{'from'} ); my ( $error, $fromuserref ) = get_where( 'local', $transaction_description_ref->{'registry'}, 'om_users', '*', 'userEmail', $from, $token, '', '' ); # my ( $error, $touserref ) = get_where( 'local', $transaction_description_ref->{'registry'}, 'om_users', '*', 'userLogin', $transaction_description_ref->{'destination'}, $token, $offset, $limit ); my ( $error, $currencyref ) = get_where( 'local', $transaction_description_ref->{'registry'}, 'om_currencies', '*', 'name', $transaction_description_ref->{'currency'}, $token, $offset, $limit ); my $error; # added test for blank from to guard against bad email parse etc.. $error = "$messages{'unknownsender'} " if ( !length($fromuserref) || ( !length($from) ) ); $error .= "$messages{'unknownrecipient'} " if ( !length($touserref) ); $error .= "$messages{'unknowncurrency'} " if ( !length($currencyref) ); #FIXME: cross registry is not allowed in batch processes at present 12/3/2010 if ( $transaction_description_ref->{'registry'} ne $registry ) { $error .= "$messages{'nocrossregistry'} "; } # one of the above lookups fails, reject the whole transaction if ( length($error) ) { $message = "$transaction_description_ref->{'from'} transaction invalid: $transaction_description_ref->{'error'} $error"; } return $message; }
Items go two by two, I hate this but it seems more solid than the all-at-once parser, for mail anyway... FIXME: If you want another language you need to replace this..
sub _fuzzy_ark_parse { my ($input) = @_; # begin parse on whitespace my ( %transaction_description, $status ); my $found_count = 0; # used to count elements parsed $input = lc($input); # canonical is lower case # tokenise on white space... my @words = split( /\s+/, $input ); # fuzzy ark parsing the terms mainly go two-by-two! # count of found elements should be 5 in a valid transaction my $counter = 0; # used for term lookahead # this should be send, balance, confirm etc... $transaction_description{'type'} = $words[0]; foreach my $word (@words) { if ( $word =~ /^(\d+)$/ ) { $transaction_description{'amount'} = $word; # amount is the only numeric thing $found_count++; $transaction_description{'currency'} = $words[ ( $counter + 1 ) ]; # currency is next to quantity # make singular for english language currencies dallies = dally, limes = lime... $transaction_description{'currency'} =~ s/ies$/y/i; $transaction_description{'currency'} =~ s/s$//i; $found_count++ if ( length( $transaction_description{'currency'} ) ); } if ( $word eq "to" ) { # found 'to' $transaction_description{'destination'} = $words[ ( $counter + 1 ) ]; # touser is next $found_count++ if ( length( $transaction_description{'destination'} ) ); } if ( $word eq "at" ) { # found 'at' $transaction_description{'registry'} = $words[ ( $counter + 1 ) ]; # toregistry is next $found_count++ if ( length( $transaction_description{'fromregistry'} ) ); } $counter++; } $input =~ /for\s+(\w.*)$/i; # description is everything at end # look up sending user, receiving user and currency $transaction_description{'description'} = $1; $found_count++ if ( length( $transaction_description{'description'} ) ); return ( $found_count, \%transaction_description ); }
This is parse, validation both for mail and jabber, needs a new name perhaps Will only do 'send' and 'balance' at the moment. This whole area probably needs merging with SMS and smart phone widgets too...
sub mail_message_parse { my ( $class, $registry, $from, $to, $subject, $text ) = @_; # '$to' here is the registry batch email address, not the destination user! # send 4 duckets to unknown at dalston for barking lessons my $parse_type = 0; my ( $count, $transaction_description_ref, $error_message, $token ); ( $count, $transaction_description_ref ) = _fuzzy_ark_parse($text); #FIXME: this quoting needs to go down into the db layer... # necessary for mail but not for jabber? my $quote_from = quotemeta($from); my ( $error, $fromuserref ) = get_where( $class, $registry, 'om_users', '*', 'userEmail', $quote_from, $token, '', '' ); $transaction_description_ref->{'userPublickeyid'} = $fromuserref->{'userPublickeyid'}; $transaction_description_ref->{'source'} = $fromuserref->{'userLogin'}; $transaction_description_ref->{'name'} = $fromuserref->{'userName'}; if ( $transaction_description_ref->{'type'} eq 'send' ) { $transaction_description_ref->{'text'} = _make_pretty_transaction_description($transaction_description_ref); # need this later to deduce the payer... $transaction_description_ref->{'from'} = $from; $transaction_description_ref->{'title'} = $subject; # check currency, registry and destination are OK, if not cumulate with errors # deduce tradeSource using 'from' email, get public key id from originator record ( $error_message ) = _check_to_and_from( $registry, $transaction_description_ref ); my $text = $transaction_description_ref->{'text'}; # there must be at least 4 components in a send message $transaction_description_ref->{'error'} .= $messages{'incompletetransaction'} if ( $count < 4 ); } elsif ( $transaction_description_ref->{'type'} eq 'balance' ) { # FIXME: probably needs regression testing with non-encrpyted... # FIXME: no reason not to parse/allow multiregistry query via 'balance <registryname>' $transaction_description_ref->{'registry'} = $registry; # this is a balance request... $transaction_description_ref->{'text'} = _mail_get_balance( $registry, $quote_from, $transaction_description_ref->{'currency'} ); } else { $transaction_description_ref->{'error'} = "$messages{'incompletetransaction'}: $text"; } $transaction_description_ref->{'error'} .= $error_message if ( length($error_message) ); return ( $parse_type, $transaction_description_ref ); } sub _make_pretty_transaction_description { my ($transaction_description_ref) = @_; my $pretty_description; # this is the description for the email... foreach my $key ( keys %$transaction_description_ref ) { $pretty_description .= "$key: $$transaction_description_ref{$key}\n"; } return $pretty_description; } sub mail_transaction { my ($transaction_description_ref) = @_; my %transaction; # convert to standard transaction input format, fields etc. #fromregistry : chelsea $transaction{fromregistry} = $transaction_description_ref->{'registry'}; #home : http://cclite.caca-cola.com:83/cgi-bin/cclite.cgi, for example $transaction{home} = ""; # no home, not a web transaction #subaction : om_trades $transaction{subaction} = 'om_trades'; #toregistry : dalston $transaction{toregistry} = $transaction_description_ref->{'registry'}; #tradeAmount : 23 $transaction{tradeAmount} = $transaction_description_ref->{'amount'}; #tradeStatus : default taken from configuration $transaction{tradeStatus} = $configuration{'initialpaymentstatus'}; #tradeCurrency : ducket $transaction{tradeCurrency} = $transaction_description_ref->{'currency'}; #tradeDate : this is date of reception and processing, in fact my ( $date, $time ) = &Ccu::getdateandtime( time() ); $transaction{tradeDate} = $date; $transaction{tradeTitle} = $transaction_description_ref->{'title'}; #tradeDescription : added by this routine $transaction{tradeDescription} = $transaction_description_ref->{'description'}; #tradeDestination : ddawg $transaction{tradeDestination} = $transaction_description_ref->{'destination'}; #tradeItem : test to see variables #tradeSource : manager $transaction{tradeSource} = $transaction_description_ref->{'source'}; # remove html from response, this is not true csv though.. $transaction{mode} = 'csv'; # call ordinary transaction my ( $token, $pages ); my $transaction_ref = \%transaction; my ( $metarefresh, $home, $error, $output_message, $page, $c ) = transaction( 'mail', $transaction{fromregistry}, 'om_trades', $transaction_ref, $pages, $token ); return "$output_message\n $transaction_description_ref->{'text'}"; }
FIXME: duplicate in Ccsmsgateway and needed for jabber Send balance, via email at present, sms later... To be done...
sub _mail_get_balance { my ( $registry, $quote_from, $currency ) = @_; my ( $token, $offset, $limit, $balance_ref, $volume_ref ); my ( $error, $fromuserref ) = get_where( 'local', $registry, 'om_users', '*', 'userEmail', $quote_from, $token, $offset, $limit ); my %fields = ( 'userLogin', $fromuserref->{'userLogin'} ); my $fieldsref = \%fields; # html to return html, values to return raw balances and volumes # for each currency ( $balance_ref, $volume_ref ) = show_balance_and_volume( 'local', $registry, $fromuserref->{'userLogin'}, 'values', $token ); # current balance for this particular currency my $message; if ( !length($currency) ) { foreach my $curr ( sort keys %$balance_ref ) { $message .= "$curr= $balance_ref->{$curr}\n"; } } else { $message .= "$currency = $balance_ref->{$currency}\n"; } return $message; } 1;


Aspiring Full Stack Developer based in New York. Experienced in HTML, CSS, JavaScript, ReactJS, NodeJS, and PostgresSQL. Over 10 years hands-on experience in installation, troubleshooting and configuration of computer systems. Hands-on experience in A/V input and output devices, Windows operating system and application & system setup
Course Assistant for Columbia’s Full-stack coding bootcamp. Assis6ng the professor with conduc6ng class. Engage students in need and provide sup- port with course assignments.
Serve as plan liaison for physicians/physician groups in a specified geo- graphical area. Will be the main point of contact for all plan-related issues including marke6ng, enrollment, contrac6ng, billing and reimbursement. Responsible for the resolu6on of all issues, including those iden6fied by the provider, and those iden6fied internally that have an impact on the physician. Coordinates with all Healthfirst staff to assist as appropriate, including crea6ng project plans, issue logs, conference calls, etc.
Acted as the main liaison between the Network Management/Provider Relations Department and key stakeholders and business partners both internally and externally. Build and develop business relationships vital to the success of quality incentive project and actively facilitate discussions around issues. Performed beginner level statistical analyses with Excel or other quantitative tools.
Part-time Intensive Full-Stack Web Development course which transforms students into entry level full stack web developers.
iDJ is a music application built on ReactJS using the Soundcloud API. Search for your favorite songs, add to the playlist then have your party vote on the songs in the playlist. The song with the most votes will be played next in the queue.
View Demo | View GithubSimple app which allows you to search for a movie title and displays metadata. Built with React without the use of create-react-app package.
View Project


AMC 10
by REFATH BARI
Menu
Home
Landing
Generic
Elements
Get Started
Log In
Number Theory Videos
Number Theory videos I made to prepare for the AMC 10.
Divisiblity, and Basic Modular Arithmetic
Lorem ipsum set dolor
Lorem Elsass ipsum Oberschaeffolsheim Heineken
Lorem ipsum set dolor
Lorem Elsass ipsum Oberschaeffolsheim Heineken
Lorem ipsum set dolor


Enter Registration Details
Vehicle Reg. No. Part1 :
Vehicle Reg. No. Part2 :
Captcha :
Developed by
fatalcoder524


right days EEG developed left cerebral {border-style patients brain postoperative px;} #ffffff;} Fig. migraine newly lesion neurological performed surgery imaging moyamoya symptoms transient hyperperfusion patient perfusion slowing CSD DWI area dysfunction episode second showed Kim TND Transient arm hemisphere Brain Supplementary associated depression disease neurologic observed onset preoperative structural symptomatic (Case MRI SPECT clinical cortical day diffusion pathophysiology prolonged px; seizure {font-family Absent Data amplitude cases computed did evaluation focal font-size hemibody hemorrhage hours hypesthesia initial motor patients. seizures spreading symptom CT, EDAGS However, Hyperperfusion MR, Perfusion arrhythmic artery blood compared double; hemisphere. human increase low magnetic online-only paresis period temporal underlying Dysarthria EDAS Lee Neurol Right Supplement). attenuation border-color border-width common cortex depression, deterioration flap flow hemiparesis hemiplegic mild mixed occur patients, phenomenon recovery resonance revascularization seizure, solid; study superficial swelling weakness {font-style {font-weight (patient ---, Arrhythmic CBF Case EDAS. Fabricius Korea Korean MRP, Results Spreading acute attack aura based bold bypass cause children courier; electrical em; emission episodes. evidence frontal galeal hours; hyperperfusion. indirect intraventricular ischemia ischemic lasted neurosurgical photon pt;} regardless reported significant single subdural surgery, surgical tomography typical visual weighted


Things that you learn each day are precious. By sharing them on Tilgram, not only others can benefit from those, but also you avoid forgetting them.
TIL is an acronym for Today I Learned
Tilgram's complete source code is available on Github.


responsibility the fun way
Registration
Create your children's accounts
Child 1
Name
Username
Password
Gender
Select Gender
male
female
Birthday
Favorite Color
Select a Color
blue
green
light blue
orange
pink
purple
red
yellow
Add a child
Next
Terms & Conditions | Privacy Policy | Support


The command-line tool behave has a bunch of command-line arguments and is also configurable using configuration files.
Values defined in the configuration files are used as defaults which the command-line arguments may override.
You may see the same information presented below at any time using behave -h.
Disable the use of ANSI color escapes.
Use ANSI color escapes. This is the default behaviour. This switch is used to override a configuration file setting.
Invokes formatters without executing the steps.
Define user-specific data for the config.userdata dictionary. Example: -D foo=bar to store it in config.userdata[“foo”].
Don’t run feature files matching regular expression PATTERN.
Only run feature files matching regular expression PATTERN.
Don’t output JUnit-compatible reports.
Output JUnit-compatible reports. When junit is enabled, all stdout and stderr will be redirected and dumped to the junit report, regardless of the ‘–capture’ and ‘–no-capture’ options.
Directory in which to store JUnit reports.
Specify a formatter. If none is specified the default formatter is used. Pass ‘–format help’ to get a list of available formatters.
Show a catalog of all available step definitions. SAME AS: –format=steps.catalog –dry-run –no-summary -q
Don’t print skipped steps (due to tags).
Print skipped steps. This is the default behaviour. This switch is used to override a configuration file setting.
Don’t print snippets for unimplemented steps.
Print snippets for unimplemented steps. This is the default behaviour. This switch is used to override a configuration file setting.
Don’t print multiline strings and tables under steps.
Print multiline strings and tables under steps. This is the default behaviour. This switch is used to override a configuration file setting.
Only execute the feature elements which match part of the given name. If this option is given more than once, it will match against all the given names.
Don’t capture stdout (any stdout output will be printed immediately.)
Capture stdout (any stdout output will be printed if there is a failure.) This is the default behaviour. This switch is used to override a configuration file setting.
Don’t capture stderr (any stderr output will be printed immediately.)
Capture stderr (any stderr output will be printed if there is a failure.) This is the default behaviour. This switch is used to override a configuration file setting.
Don’t capture logging. Logging configuration will be left intact.
Capture logging. All logging during a step will be captured and displayed in the event of a failure. This is the default behaviour. This switch is used to override a configuration file setting.
Specify a level to capture logging at. The default is INFO - capturing everything.
Specify custom format to print statements. Uses the same format as used by standard logging handlers. The default is ‘%(levelname)s:%(name)s:%(message)s’.
Specify custom date/time format to print statements. Uses the same format as used by standard logging handlers.
Specify which statements to filter in/out. By default, everything is captured. If the output is too verbose, use this option to filter out needless output. Example: –logging-filter=foo will capture statements issued ONLY to foo or foo.what.ever.sub but not foobar or other logger. Specify multiple loggers with comma: filter=foo,bar,baz. If any logger name is prefixed with a minus, eg filter=-foo, it will be excluded rather than included.
Clear all other logging handlers.
Don’t display the summary at the end of the run.
Display the summary at the end of the run.
Write to specified file instead of stdout.
Alias for –no-snippets –no-source.
Don’t print the file and line of the step definition with the steps.
Print the file and line of the step definition with the steps. This is the default behaviour. This switch is used to override a configuration file setting.
Defines the current test stage. The test stage name is used as name prefix for the environment file and the steps directory (instead of default path names).
Stop running tests at the first failure.
Only execute features or scenarios with tags matching TAG_EXPRESSION. Pass ‘–tags-help’ for more information.
Don’t print the time taken for each step.
Print the time taken, in seconds, of each step after the step has completed. This is the default behaviour. This switch is used to override a configuration file setting.
Show the files and features loaded.
Only run scenarios tagged with “wip”. Additionally: use the “plain” formatter, do not capture stdout or logging output and stop at the first failure.
Expand scenario outline tables in output.
Use keywords for a language other than English.
List the languages available for –lang.
List the translations accepted for one language.
Show help for tag expressions.
Show version.
Scenarios inherit tags declared on the Feature level. The simplest TAG_EXPRESSION is simply a tag:
--tags @dev
You may even leave off the “@” - behave doesn’t mind.
When a tag in a tag expression starts with a ~, this represents boolean NOT:
--tags ~@dev
A tag expression can have several tags separated by a comma, which represents logical OR:
--tags @dev,@wip
The –tags option can be specified several times, and this represents logical AND, for instance this represents the boolean expression “(@foo or not @bar) and @zap”:
--tags @foo,~@bar --tags @zap.
Beware that if you want to use several negative tags to exclude several tags you have to use logical AND:
--tags ~@fixme --tags ~@buggy.
Configuration files for behave are called either ”.behaverc”, “behave.ini” or “setup.cfg” (your preference) and are located in one of three places:
If you are wondering where behave is getting its configuration defaults from you can use the “-v” command-line argument and it’ll tell you.
Configuration files must start with the label “[behave]” and are formatted in the Windows INI style, for example:
[behave]
format=plain
logging_clear_handlers=yes
logging_filter=-suds
The following types are supported (and used):
These fields accept one or more values on new lines, for example a tag expression might look like:
tags=@foo,~@bar
@zap
which is the equivalent of the command-line usage:
--tags @foo,~@bar --tags @zap
Use ANSI color escapes. This is the default behaviour. This switch is used to override a configuration file setting.
Invokes formatters without executing the steps.
Define user-specific data for the config.userdata dictionary. Example: -D foo=bar to store it in config.userdata[“foo”].
Don’t run feature files matching regular expression PATTERN.
Only run feature files matching regular expression PATTERN.
Output JUnit-compatible reports. When junit is enabled, all stdout and stderr will be redirected and dumped to the junit report, regardless of the ‘–capture’ and ‘–no-capture’ options.
Directory in which to store JUnit reports.
Specify default formatter (default: pretty).
Specify a formatter. If none is specified the default formatter is used. Pass ‘–format help’ to get a list of available formatters.
Show a catalog of all available step definitions. SAME AS: –format=steps.catalog –dry-run –no-summary -q
Specify name annotation schema for scenario outline (default=”{name} – @{row.id} {examples.name}”).
Print skipped steps. This is the default behaviour. This switch is used to override a configuration file setting.
Print snippets for unimplemented steps. This is the default behaviour. This switch is used to override a configuration file setting.
Print multiline strings and tables under steps. This is the default behaviour. This switch is used to override a configuration file setting.
Only execute the feature elements which match part of the given name. If this option is given more than once, it will match against all the given names.
Capture stdout (any stdout output will be printed if there is a failure.) This is the default behaviour. This switch is used to override a configuration file setting.
Capture stderr (any stderr output will be printed if there is a failure.) This is the default behaviour. This switch is used to override a configuration file setting.
Capture logging. All logging during a step will be captured and displayed in the event of a failure. This is the default behaviour. This switch is used to override a configuration file setting.
Specify a level to capture logging at. The default is INFO - capturing everything.
Specify custom format to print statements. Uses the same format as used by standard logging handlers. The default is ‘%(levelname)s:%(name)s:%(message)s’.
Specify custom date/time format to print statements. Uses the same format as used by standard logging handlers.
Specify which statements to filter in/out. By default, everything is captured. If the output is too verbose, use this option to filter out needless output. Example: logging_filter = foo will capture statements issued ONLY to “foo” or “foo.what.ever.sub” but not “foobar” or other logger. Specify multiple loggers with comma: logging_filter = foo,bar,baz. If any logger name is prefixed with a minus, eg logging_filter = -foo, it will be excluded rather than included.
Clear all other logging handlers.
Display the summary at the end of the run.
Write to specified file instead of stdout.
Specify default feature paths, used when none are provided.
Alias for –no-snippets –no-source.
Print the file and line of the step definition with the steps. This is the default behaviour. This switch is used to override a configuration file setting.
Defines the current test stage. The test stage name is used as name prefix for the environment file and the steps directory (instead of default path names).
Stop running tests at the first failure.
Define default tags when non are provided. See –tags for more information.
Only execute certain features or scenarios based on the tag expression given. See below for how to code tag expressions in configuration files.
Print the time taken, in seconds, of each step after the step has completed. This is the default behaviour. This switch is used to override a configuration file setting.
Show the files and features loaded.
Only run scenarios tagged with “wip”. Additionally: use the “plain” formatter, do not capture stdout or logging output and stop at the first failure.
Expand scenario outline tables in output.
Use keywords for a language other than English.