Hello! Welcome to Thingsberry.com.We are your one stop information portal for the Internet of Things (IoT) and related products on the market.
Thank you for visiting our site and we hope you find everything you need.
These are our guidelines and rules for using Thingsberry.com, which is owned and run by Mint Maxer LLC. The terms “we” and “Thingsberry.com” refer to Mint Maxer LLC.
Please do not use Thingberry.com if you don’t agree with and/or accept the terms of Terms and Conditions of our website.
You are agreeing to be legally bound to these terms by browsing Thingsberry.com, by creating an account with Thingsberry.com, or by asking to be listed on Thingsberry.com.
The use of Thingsberry.com is limited to expressly permitted purposes. You promise you will not use Thingberry.com for any unlawful purpose or contrary to its Terms and Conditions.
Unless specified consumer use of Thingsberry.com is for non-commercial and informational use.
Business use of Thingsberry.com is for promotional and informational use.
You must obtain our express consent to use the website in a way not stated. You may not change, copy, reproduce, distribute, create derivative work from, post, license, or sell information, content, software, products or services related to Thingsberry.com.
You can delete your account with Thingsberry.com or stop using the website at any time.
You need to be at least 13 years old to browse this website. We don’t knowingly collect personally identifiable information from anyone under the age of 13.
You must not be prohibited from using or receiving our website by national laws.
You will be asked to provide your first name, last name and email address to create an account with Thingsberry.com.
You will also be asked to provide a contact name and telephone number to list your product on Thingsberry.com.
You need to be 18 years or older to create an account with Thingsberry.com. By opening an account with Thingsberry.com you are declaring that you’re at least 18 years old. You will need to use the account of a parent or legal guardian who will be responsible for all your activities if you are under 18 years old. PLEASE GET THEIR PERMISSION BEFORE USING THEIR ACCOUNT.
If you create an account or ask that a product be listed on behalf of someone else, you are representing that you have the legal authority to do so and to bind them to our Terms and Conditions.
When you open an account or list a product on Thingsberry.com you’re responsible for providing us with information that is complete, up-to-date, and factual.
You are also required to keep your account information up-to-date.
Mint Maxer LLC reserves the right to suspend or terminate an account or listing that is not complete, up-to-date, or factual.
This means you may be denied access toThingsberry.com and its resources at any time. This is at the sole discretion of Mint Maxer LLC.
You agree to only post, send or receive information that is related to the content and services that Thingberry.com provides.
If you submit content to or generate content on Thingsberry.com you are agreeing to the following:
You grant Mint Maxer LLC a royalty-free, unending, irreversible, worldwide, transferable, non-exclusive right and license to use, replicate, change, adjust, issue, translate, create derivative works from, dispense, publicly perform, and publicly exhibit all content, remarks, suggestions, ideas, graphics, or information without any royalties, consideration to you or credit.
And a license to combine any submission with other works in any form, media, or technology now used or developed later. Mint Maxer LLC will not treat submitted information as confidential. The submission may be used for branding, advertising, or marketing. We will not be required to pay any royalties, any other consideration or credit.
You represent you have the legal right to grant this license for submitted or generated content by posting on content on Thingsberry.com.
Please do not submit content to Thingsberry.com if you do not want to grant these rights.
Mint Maxer LLC reserves the right to suspend or terminate your account at any time and at its sole discretion. We may use IP mapping, technological barriers or other mean available to stop unauthorized access to our site if your account is terminated.
We also reserve the right to edit, delete or decline content at our discretion.
Your account will be suspended or terminated if you participate in any of the activities listed below. This is not a complete list of activities that will cause your account to be suspended or terminated.
You are not allowed to do the following while onThingsberry.com:
i. Post information not directly connected to the website;
ii. Post vulgar, obscene, pornographic, or indecent material;
iii. Post material owned by other people that is protected by intellectual property laws, or by rights of privacy;
iv. Post material that promotes illegal conduct or an intent to engage in illegal conduct;
v. Post material that violate any laws;
vi. Engage in conduct which is abusive, threatening, libelous, defamatory, obscene, offensive, pornographic, racist, sexist, homophobic, harassing, hateful, invades another’s privacy or stalking;
vii. Collect information from other’s without their knowledge or approval;
viii. Impersonate someone else;
ix. Misrepresent your connection to another entity or person;
x. Modify headers or identifiers to conceal the origin of content;
xi. Engage in commercial activity not authorized by Mint Maxer LLC, such as raffles, contests, and soliciting goods and services;
xii. Disrupt the operation of Thingsberry.com by uploading viruses, worms, Trojan horses, or any other computer program or code designed to limit, interrupt, or destroy functionality of computer software or hardware;
xiii. Disobey the terms, conditions, rules, and guidelines of Thingsberry.com.
Thingsberry.com contains links to other websites that are not owned, operated, maintained, or connected to Mint Maxer LLC. Links are provided as service to users.
Mint Maxer LLC does not review, investigate or screen the content of these websites.
Mint Maxer LLC is in no way responsible for the content on linked websites. We make no guarantees or warranties about content, completeness or truth of these links or their websites.
We do not endorse positions, ideas, or opinions of theses websites.
Nothing in these Terms and Conditions is to be interpreted as forming a partnership, joint venture, employment, or agency relationship between you and us.
We do not have the authority to bind each other in any way.
You understand that Mint Maxer LLC cannot and does not guarantee the accuracy of the information on products listed on the website. This means you are responsible for doing further research to make sure the product suits your needs.
You are responsible for all loss and damages you suffer as a result of using our website or its content.
We respect the intellectual property rights of others but we can’t promise that all the content on this website doesn’t infringe on the rights of others.

MINT MAXER LLC MAKES NO WARRANTIES EXCEPT THOSE MADE EXPRESSLY IN THESE TERMS AND CONDITIONS.
MINT MAXER LLC DOES NOT MAKE ANY RERESENTATIONS RELATING TO THE USE, OR THE RESULTS OF USE, OF THE CONTENT IN TERMS OF ACCURACY, RELIABILITY, OR OTHERWISE.
THIS WEBSITE MAY CONTAIN TECHNICAL OR TYPOGRAPHICAL ERRORS.

MINT MAXER LLC MAKES NO WARRANTIES THAT YOUR USE OF THE CONTENT WILL NOT INFRINGE THE RIGHTS OF OTHERS AND ASSUSMES NO LIABILTY OR RESPONSIBILITY FOR ERRORS OR OMISSIONS IN SUCH CONTENT.
MINT MAXER LLC does not accept liability for the following damages experienced by the users of Thingsberry.com or any third party.
MINT MAXER LLC, ITS SUBSIDIARIES, AFFLIATES, LICENSORS, SERVICE PROVIDERS, CONTENT PROVIDERS, EMPLOYEES, AGENTS, OFFICERS, AND DIRECTORS WILL NOT BE LIABLE FOR ANY INCIDENTIAL, DIRECT, INDIRECT, PUNITIVE, ACTUAL, CONSEQUENTIAL, SPECIAL, EXEMPLARY, OR OTHER DAMAGES INCLUDING LOSS OF DATA, REVENUE OR INCOME, GOODWILL, PAIN AND SUFFERING, EMOTIONAL DISTRESS, OR SIMILAR DAMAGES, RELATED TO THE USE THIS WEBSITE NO MATTER THE CAUSE OF ACTION THEY ARE BASED ON, EVEN IF THINGSBERRY.COM HAS BEEN ADVISED OF THE POSSIBILITY OF THOSE DAMAGES.
There is no liability related to the Terms and Conditions and services provided by Thingsberry.com. At Thingsberry.com we provide our service for free.
Some of these DISCLAIMERS may not apply to you if your state prevents limitations on implied warranties or limitations or exclusions on damages, and you may have more rights.
IN NO EVENT WILL THERE BE ANY COLLECTIVE LIABILTY OF MINT MAXER LLC. AND ITS SUBSIDIARIES, AFFLIATES, LICENSORS, SERVICE PROVIDERS, CONTENT PROVIDERS, EMPLOYEES, AGENTS, OFFICERS, AND DIRECTORS TO ANY PARTY (REGARDLESS OF THE FORM OF ACTION, WHETHER IN CONTRACT, TORT, OR OTHERWISE.)
CERTAIN STATE LAWS DO NOT ALLOW LIMITATIONS ON IMPLIED WARRANTIES OR THE EXCLUSION OR LIMITATION OF CERTAIN DAMAGES. SOME OR ALL OF THE ABOVE DISCLAIMERS MAY NOT APPLY TO YOU, AND YOU MAY HAVE ADDITIONAL RIGHTS. UNLESS LIMITED OR MODIFIED BY APPLICABLE LAW, THE ABOVE-STATED DISCLAIMERS, EXCLUSION AND LIMITATIONS APPLY, EVEN IF ANY REMEDY FAILS OF ITS ESSENTIAL PURPOSE.
You promise to protect Mint Maxer LLC from lawsuits and claims that are a result of your wrongdoing.
You will indemnify, defend, and hold Mint Maxer LLC, its subsidiaries, affiliates, licensors, content providers, service providers, employees, agents, directors, and contractors (the Indemnified Parties) harmless from any breach of these Terms and Conditions by you. This includes using content in a way not expressly authorized in the Terms and Conditions.
You also agree that the Indemnified Parties will have no liability in connection with any breach or unauthorized use. You will indemnify any and all resulting loss, damages, judgments, awards, costs, expenses, and attorney’s fees of the Indemnified Parties related to your breach or unauthorized use.
You will also indemnify and hold Indemnified Parties harmless from and against any claims brought by third parties arising out of your use of the information accessed from this website.
What we promise to you.
Mint Mixer LLC will provide our services with reasonable skill and care.
WE DO NOT WARRANT THAT THE FUNCTIONS OR CONTENT CONTAINED IN THIS WEBSITE WILL BE UNITERRUPTED, FREE FROM DELAYS OR ERROR-FREE, THAT DEFECTS WILL BE CORRECTED, OR THAT THIS WEBSITE OR THE SERVER THAT MAKES IT AVAILABLE WILL BE FREE OF VIRUSES OR OTHER HARMFUL CODE OR WORK IN THE CONFIGURATION OR WITH THE HARDWARE OR SOFTWARE YOU USE.
We are not responsible for claims that are the result of unauthorized changes to the website or the use of the website with prohibited software or hardware.
These Terms and Conditions are governed by the laws of the State of New Jersey, United States of America, notwithstanding any principles of conflicts of law. You agree to submit to personal jurisdiction in New Jersey in connection with any dispute arising out of these Terms and Conditions.
If any part of these Terms and Conditions is unlawful, void, or unenforceable, that part will be deemed to fulfill its intended purpose to the maximum permitted by applicable law and will not affect the validity and enforceability of any remaining provisions.
These Terms and Conditions constitute the entire agreement among the parties relating to this subject matter and supersedes all prior Terms and Conditions.
Thingsberry.com is not available to anyone located in any U.S. sanctioned countries or to anyone on the U.S. Treasury Department’s list of Specially Designated Nationals List (SDN List).
All disputes must go through an informal dispute resolution process.
Please provideMint Maxer LLC with a brief written account of the dispute and your contact information.Send all information to:
Mint Maxer LLC
Legal Department
1200 US-22
Suite #2000
Bridgewater, NJ 08807
We will attempt to resolve all disputes to your satisfaction within 30 business days of receiving notification.
If our informal dispute process fails, the claiming party may take the matter to small claims court in Somerset County, New Jersey.
Mint Maxer LLC is not responsible for:
i. any vendor materials including whether materials are suitable or available for your use.
ii. The accuracy and veracity of vendor information.
iii. The performance or operation of any third party website.
iv. For any products or services advertised or sold by any third party (including on or through a third party’s website),
v. For any other action or inaction by any third party.
Your use of third party websites will be subject to those terms to which you and the third party agree.
Trademarks, service marks, logos, and copyrighted works appearing on this website are the property of Mint Maxer LLC or the party that provided the trademarks, service marks, logos, and copyrighted works to Mint Maxer LLC.
What we have rights to
Mint Maxer LLC retains all rights with respect to its respective trademarks, service marks, logos, and copyrighted materials appearing on Thingsberry.com.
Basically, we own all Thingsberry.com content that we put on the website. You may not change, copy, reproduce, distribute, create derivative work from, post, reproduce, license, or sell information, content, software, products or services related to Thingsberry.com.
What we don’t have rights to
Any party that provided the trademarks, service marks, logos, and copyrighted works to Mint Maxer LLC retain their rights to the material they provided.
We do not own the items listed on Thingsberry.com. They are owned by their vendors.
We do not and cannot take responsibility for the quality, or safety of the items.
To notify Mint Maxer LLC that your copyright has been infringed, please provide us with the following information:
i. An electronic or physical signature of the person authorized to act on the copyright owner’s behalf;
ii. A description of the copyrighted work you claim has been infringed upon;
iii. A description of where the claimed infringed material is located on the website;
iv. Your address, telephone number, and email address;
v. A statement that you have a good faith belief that the disputed use is not authorized by the copyright owner, its agent, or the law;
vi. A statement, signed by an attorney or public notary, that the above information in your notice is accurate and that you are the copyright owner or authorized to act on the copyright owner’s behalf.
Please sent notice of claim of copyright infringement to:
Mint Maxer LLC
Legal Department
1200 US-22
Suite #2000
Bridgewater, NJ 08807
ALL NOTICES MUST COMPLY WITH THE REQUIREMENTS OF TITLE 17, UNITED STATES CODE, SECTION 512(c)(3) TO RECEIVE A RESPONSE.
Please contact us if you have any comments, complaints, or questions about Thingsberry.com.
We can be reached by email<EMAIL_ADDRESS>Any passwords used for this website are for your individual use only. It is your responsibility to protect and keep confidential your username, password, and your private information. If you suspect your username, password, or private information has been compromised or used by an unauthorized third party you must notify us as soon as reasonably possible.
You are prohibited from using any service or facilities provided in connection with this site to compromise security or tamper with system resources and/or accounts.
The use or distribution of tools designed to compromise security is strictly prohibited.
Allowing someone to use your account to compromise security is strictly prohibited.
We reserve the right to investigate any suspected violations of these Terms and Conditions.
We reserve the right to fully cooperate with any law enforcement authorities or court order requesting or directing Mint Maxer LLC to disclose the identity of anyone posting any messages, emails, or materials that violate the Terms and Conditions.

The Terms and Conditions for Thingsberry.com can be changed at any time to reflect changes to services offered, the operation of the website, to meet legal requirements or at Mint Maxer LLC’s discretion.
Thingberry.com may or may not notify users of impending changes. It is your responsibility to check the Terms and Conditions for changes.
All changes are effective the date they are posted.
You can cancel your account if you don’t agree with the changes
If you continue to use Thingberry.com after the effective date of change, you have accepted and agreed to all changes to the Terms and Conditions of Thingberry.com The effective date is located in the footer of the Terms and Conditions.


{% extends "_base.html" %} {% load staticfiles %} {% block title %} Castle Apartments - Login {% endblock %} {% block content %}
New to Castle apartments?  RESET PASSWORD


DIY
store.in
Home
Products
Soldering Accessories
Modules
Active Components
Passive Components
Contact Us


Available remotes and commands:
{{ remote }} {% for cmd in possible_commands %} {{cmd}} {% endfor %}


I'm the page itself. Nice, huh?
I can reference images, and what nots, from this directory without needing to generate a path.
{ { page | render:'summary' } }I'm the page itself. Nice, huh?
I can reference images, and what nots, from this directory without needing to generate a path.
{ { page | render:'summary' } }


Before Change
Multiply loss_inner_vecs by factor of Hessian of total loss.
return tuple(
loss.multiply_hessian_factor(loss_vec)
for loss, loss_vec in zip(self._losses, loss_inner_vecs))
def _multiply_loss_hessian_factor_transpose(self, loss_vecs):
Multiply loss_vecs by transpose factor of Hessian of total loss.
After Change
def _multiply_loss_hessian_factor(self, loss_inner_vecs):
Multiply loss_inner_vecs by factor of Hessian of total loss.
mult_func = lambda loss, vec: loss.multiply_hessian_factor(vec)
return self._multiply_across_losses(mult_func, loss_inner_vecs)
def _multiply_loss_hessian_factor_transpose(self, loss_vecs):
Multiply loss_vecs by transpose factor of Hessian of total loss.
mult_func = lambda loss, vec: loss.multiply_hessian_factor_transpose(vec)


| From | {{source}} |
|---|---|
| To | {{operation.destination}} |
| From | {{source}} |
|---|---|
| Inflation Destination | {{operation.inflationDest}} |
| From | {{source}} |
|---|---|
| Value | {{operation.dataValue}} |
| Selling | {{operation.selling.code}} - {{operation.selling.issuer}} | {{operation.selling.code}} |
|---|---|---|
| Buying | {{operation.buying.code}} - {{operation.buying.issuer}} | {{operation.buying.code}} |
| Amount | {{operation.amount}} | |
| Price | {{operation.price}} |
| From | {{source}} |
|---|---|
| Issuer | {{operation.line.issuer}} |
| From | {{source}} |
|---|---|
| Destination | {{operation.destination}} |
| From | {{source}} |
|---|---|
| Destination | {{operation.destination}} |


Klearchos-Angelos Gkountras site
About me
Born in Theesaloniki 🇬🇷 , I am using as main machine a Gnu/Linux distro . I can do IT stuff.
Hobbies
In my free time I enjoy play chess , I am not good player but I really enjoy the game.
Contact
My email andress is jemadux SPAMFREE cryptolab DOT net


| draft {rmarkdown} | R Documentation |
Create (and optionally edit) a draft of an R Markdown document based on a template.
draft(file, template, package = NULL, create_dir = "default", edit = TRUE)
file |
File name for the draft |
template |
Template to use as the basis for the draft. This is either
the full path to a template directory or the name of a template directory
within the |
package |
(Optional) Name of package where the template is located. |
create_dir |
|
edit |
|
The draft
function creates new R Markdown documents based on
templates that are either located on the filesystem or within an R package.
The template and its supporting files will be copied to the location
specified by file
.
The file name of the new document (invisibly).
An R Markdown template consists of a directory that contains a description of the template, a skeleton Rmd file used as the basis for new documents, and optionally additional supporting files that are provided along with the skeleton (e.g. a logo graphic).
If the template directory is contained within a package then it should be
located at inst/rmarkdown/templates
. For example, a package named
pubtools that wanted to provide a template named
quarterly_report
would need to provide the following files within
the pubtools/inst/rmarkdown/templates
directory:
quarterly_report/template.yaml
quarterly_report/skeleton/skeleton.Rmd
The template.yaml
file should include a name
field. If you
want to ensure that a new directory is always created for a given template,
then you can add the create_dir
field to the template.yaml
file. For example:
create_dir: true
The skeleton/skeleton.Rmd
file should include the initial contents
you want for files created from this template. Additional files can be
added to the skeleton
directory, for example:
skeleton/logo.png
These files will automatically be copied to the directory containing the new R Markdown draft.
## Not run: rmarkdown::draft("Q4Report.Rmd", template="/opt/rmd/templates/quarterly_report") rmarkdown::draft("Q4Report.Rmd", template="quarterly_report", package="pubtools") ## End(Not run)


Reports on calls to BigDecimal
constructors which accept a double value.
These constructors can have somewhat unpredictable results because many numbers
cannot be represented exactly in a double.
It is recommend to use the constructors which accept a String instead.
Powered by InspectionGadgets


The bank is considering loaning you $5,000, at a rate of 8.75%, compounded monthly, to be paid back after 3 years. They calculate that there is a 2% chance you won't pay the loan back, and they'll have to sell the debt to a debt collector for $3000. What is the expected value for the bank?
in-context


seg1d.processing.Features.match_len¶
-
static
Features.
match_len
(dataset)[source]¶ interpolate to the maximum sized data in the reference set
Parameters: - datasetList[Dict{feature:val}]
list of multiple datasets containing dictionary of 1d features that will be matched to same length
Returns: - interp_dList[Dict{feature:val}]
feature length-matched data
Notes
Requires all features within each dataset to be of same length
Examples
>>> import numpy as np >>> import seg1d.processing as process >>> s20 = np.linspace(-np.pi*2, np.pi*2, 20) >>> s30 = np.linspace(-np.pi*2, np.pi*2, 30) >>> s40 = np.linspace(-np.pi*2, np.pi*2, 40) >>> s_longest = np.sin(s40) >>> a1 = {'s':np.sin(s20), 'c':np.cos(s20)} >>> a2 = {'s':np.sin(s30), 'c':np.cos(s30)} >>> a3 = {'s':s_longest, 'c':np.cos(s40)} >>> d = [a1, a2, a3] >>> r = process.Features.match_len(d) >>> print(len(r[0]['s']) == len(s_longest)) True


About John Romero
A Little bit about me
I enjoy being with my family. Again, coaching my kids in baseball and talking about how I made the famous video games DOOM and Quake.
I am the oldest of 5. (Only 31 or 52, depending on if you Google me or not), Not that old lol for someone who made the famous video games DOOM and Quake.
Enjoy the outdoors, riding in my old Cj-5 (1979 Renegade), riding our bikes, playing sports, and talking about how I made the famous video games DOOM and Quake.
Making custom DOOM WADS and talking about how I made the famous video games DOOM and Quake.


This class implements a source for SVN environments.
An SVN source generates environments by enumerating the branches and trunk for a given SVN remote. SVN repositories must conform to the conventional SVN repository structure with the directories trunk/, branches/, and optionally tags/ in the root of the repository. The trunk/ directory is specifically mapped to the production environment, branches are created as environments with the name of the given branch.
@see svnbook.red-bean.com/en/1.7/svn.branchmerge.maint.html @since 1.3.0
@!attribute [r] remote
@return [String] The URL to the base directory of the SVN repository
@!attribute [r] #svn_remote
@api private @return [R10K::SVN::Remote]
Initialize the given source.
@param name [String] The identifier for this source. @param basedir [String] The base directory where the generated environments will be created. @param options [Hash] An additional set of options for this source.
@option options [Boolean] :prefix Whether to prefix the source name to the
environment directory names. Defaults to false.
@option options [String] :remote The URL to the base directory of the SVN repository
# File lib/r10k/source/svn.rb, line 39 def initialize(name, basedir, options = {}) super @remote = options[:remote] @environments = [] @svn_remote = R10K::SVN::Remote.new(@remote) end
# File lib/r10k/source/svn.rb, line 81 def current_contents Dir.glob(File.join(@basedir, '*')).map do |fname| File.basename fname end end
List all environments that should exist in the basedir for this source @note This implements a required method for the Purgeable mixin @return [Array<String>]
# File lib/r10k/source/svn.rb, line 90 def desired_contents @environments.map {|env| env.dirname } end
Enumerate the environments associated with this SVN source.
@return [Array<R10K::Environment::SVN>] An array of environments created
from this source.
# File lib/r10k/source/svn.rb, line 52 def environments if @environments.empty? @environments = generate_environments() end @environments end
Generate a list of currently available SVN environments
@todo respect environment name corrections
@api protected @return [Array<R10K::Environment::SVN>] An array of environments created
from this source.
# File lib/r10k/source/svn.rb, line 67 def generate_environments branch_names.map do |branch| R10K::Environment::SVN.new(branch.name, @basedir, branch.dirname, { :remote => branch.remote }) end end
# File lib/r10k/source/svn.rb, line 77 def managed_directory @basedir end
# File lib/r10k/source/svn.rb, line 98 def branch_names branches = [] branch_opts = { :prefix => @prefix, :sourcename => @name, } branches << BranchName.new('production', "#{@remote}/trunk", branch_opts) @svn_remote.branches.each do |branch| branches << BranchName.new(branch, "#{@remote}/branches/#{branch}", branch_opts) end branches end


EU approves state aid for Dutch rail transport
BRUSSELS (Reuters) - The European Commission said on Tuesday it approved 22.2 million euros in state aid for an upgrade of freight locomotives traffic management equipment in the Netherlands, saying the support would not distort EU competition.
“It will improve the competitiveness of European railways and foster the shift of freight traffic from road to rail, in line with the EU’s environmental and transport objectives, without unduly distorting competition,” the EU’s competition chief Margrethe Vestager said in a statement.


Plots can be performed as the results of pipelines by piping elements to stages corresponding to matplotlib.pyplot operations.
matplotlib.pyplot contains three types of relevant commands for pipelines:
The first type is modeled as filter stages that merely relay whatever is passed to them, and the other two types are modeled as sink stages. The stages are in the dagpype.plot, and correspond to pyplot functions: each has the same name as a pyplot command, and takes the same arguments.
For example, to plot the exponential function between 0 and 3, we can do the following:
a = numpy.arange(0, 3, 0.2)
source(numpy.exp(a)) | plot.plot()
which uses a sink stage. This will create the plot:
To add labels and a title, we can use filter stages:
a = numpy.arange(0, 3, 0.2)
source(numpy.exp(a)) | plot.xlabel('x') | plot.ylabel('exp') | plot.title('Exponential functions') | plot.plot()
This will create the plot:
In order to manipulate the output, e.g., to save the graph to a file, we can use sink chaining, e.g.,
source(numpy.exp(a)) | \
plot.xlabel('x') | plot.ylabel('exp') | plot.title('Exponential functions') | \
(plot.plot() | plot.savefig('foo.png'))
As stated before, the stages closely resemble the corresponding pyplot functions.
The dagpype.plot.plot() stage, for example, can plot multiple lines simultaneously. For example,
a = numpy.arange(0, 3, 0.2)
source(a) + source(a) + source(a) + source(numpy.exp(a)) | plot.plot()
will create the plot
When using pyplot, the figure() function might be needed in order to clear what has been plotted, and start a new figure. The library contains a corresponding stage (which takes the same arguments):
a = numpy.arange(0, 3, 0.2)
source(a) | plot.figure() | plot.plot()
or
a = numpy.arange(0, 3, 0.2)
source(a) | plot.figure(8) | plot.plot()
pyplot supports other types of plots as well. The following code
source(numpy.random.randn(1000)) + source(numpy.random.randn(1000) + 5) | plot.hexbin()
produces the plot:


What does it mean for a sentence to be a first order logical consequence of some other sentences? (2 points)
It means that the sentence follows necessarily from the others in part due to the meaning of the quantifiers involved in the sentences.
What does it mean for a sentence to be an axiom of a logical system? (3 points)
It means that it is a sentence that we take to be a logical truth without any support from other sentences in the logical system
Explain why ∀x (Dodec(x) ∧ ∃y Larger(x,y)) → Tet(y) is not a sentence of FOL? (3 points)
The last occurrence of y in the formula lies outside the scope of any quantifier. This means that it is unbound, and all variables in sentences of FOL must be bound.
Fill in the blanks below with the logical concept that best completes the sentence. Draw your answers from the list of concepts provided. Each concept is used at most once; some will not be used at all. (3 points each)
∀x (Cube(x) ∨ Tet(x) ∨ Dodec(x)) is an example of a presupposition of a set of circumstances for the blocks universe.
If substituting an object in for a variable in a wff creates a true sentence, then we say the object satisfies the wff.
¬∀x Happy(x) ⇔ ∃x ¬Happy(x) is an instance of DeMorgan's laws for quantifiers.
We know that ∀x (P(x) ∧ Q(x)) is equivalent to ∀x P(x) ∧ ∀x Q(x) because the universal quantifier distributes over conjunction.
The basic forms of quantificational sentences, such as No Ps are Qs, are called the Aristotelian forms .
Logical truths whose status depends on the meaning of the predicates in the sentence are known as analytic truths .
A bound variable is within the scope of a quantifier.
¬∃x (Large(x) ∧ Medium(x)) is an example of a basic size axiom of the blocks language.
When a sentence follows from other sentences on the basis of the quantifiers involved, it is called a first-order logical consequence.
Quantifiers are used in FOL to talk about objects in a general way.
Translations
For each of the English sentences below, write an appropriate translation into FOL. (3 points each)
Everything is either a cube or a tetrahedron. ∀x (Cube(x) ∨ Tet(x))
Every cube is to the left of every tetrahedron. ∀x (Cube(x) → ∀y (Tet(y) → LeftOf(x,y))
Every small cube is in back of some large cube. ∀x ((Small(x) ∧ Cube(x)) → ∃y (Large(y) ∧ Cube(y) ∧ BackOf(x,y)))
No cube is to the right of anything. ¬∃x (Cube(x) ∧ ∃y RightOf(x,y))
Everything is the same size as something else. ∀x ∃y SameSize(x,y)
Anyone who owns a dog feeds it. ∀x ∀y ((Owns(x,y) ∧ Dog(y)) → Feeds(x,y))
Only pets that are hungry are fed. ∀x (Fed(x) → (Pet(x) ∧ Hungry(x)))
Everybody want somebody to love. ∀x ∃y Want-to-Love(x,y)
Some students attended every class. ∃x (Student(x) ∧ ∀y (Class(y) → Attend(x,y)))
There is someone out there for everyone. ∃x (OutThere(x) ∧ ∀y For(x,y))
Assessing truth
Using the world above, indicate whether each of the FOL sentences below is true, false, or not evaluable by placing a T, an F, or an N to the left of each sentence. (2 points each)
Logical consequence
Each of the arguments below is valid, but they may be invalid by certain notions of logical consequence. For each argument state whether it is tautologically valid, first-order valid, or analytically valid(2 points each). If the argument is tautologically valid, translate it into truth-functional form and indicate what proof rule it is an instance of.  If it is analytically valid provide a replacement form that shows it is not a first order consequence. (2 points each)
Argument 1
Argument 2
Argument 3
Imagine a world in which a is a cube, and b and c are tetrahedrons.
Bonus
The argument below is first-order invalid. Replace the predicates with random ones, and describe a counterexample world that shows the argument to be invalid. (3 points)
Replace "Larger" with "Adjoins" and imagine a world in which c and d are next to each other, but a and b are in opposite corners away from everything else.
English has lots of quantificational language that is neither universal nor existential. Provide an example. (2 points)
Most, many, a few, at least 3, a bunch, ...
Translate the following English sentence into FOL. (3 points)
You can fool all of the people some of the time, and some of the people all of the time, but you can't fool all of the people all of the time.


Welcome!
My name is Cheryl Muli.
About 20 years.
Joined campus Chuka university did Project planning and management.
Joined an acting agency did this for about a year
Later joined Moringa school For a crash course in software dev.
Wrote my first line of code one year two months ago.
Strumming a guitar.
I cook.
Cozy up with a novel and hot cocoa.
Watch Anime
HTML
CSS3
JavaScript
Angular
This project entails a github search engine whereby a person can input another person's username on github and after the search is complete, one gets to see the number of repositories.
ViewIts a quotes generating application where a client can input and save a quote, he/she can post it.He/she can also like or dislike a quote.It also shows when a post was created and posted.And lastly one can delete a quote.
ViewThis is a landing page where one can buy and sell stuff online with no stress of paying as one can pay in installments. One can login to the website post an item for sell or add to cart an item on sale.
View


Your payment succeeded
Check your email for your requested files!
Thank you for supporting my work :)
Back to home


| | |
- flask.app.Flask(flask.helpers._PackageBoundObject)
-
- Server
class Server(flask.app.Flask) |
| |
The flask object implements a WSGI application and acts as the central
object. It is passed the name of the module or package of the
application. Once it is created it will act as a central registry for
the view functions, the URL rules, template configuration and much more.
The name of the package is used to resolve resources from inside the
package or the folder the module is contained in depending on if the
package parameter resolves to an actual python package (a folder with
an :file:`__init__.py` file inside) or a standard module (just a ``.py`` file).
For more information about resource loading, see :func:`open_resource`.
Usually you create a :class:`Flask` instance in your main module or
in the :file:`__init__.py` file of your package like this::
from flask import Flask
app = Flask(__name__)
.. admonition:: About the First Parameter
The idea of the first parameter is to give Flask an idea of what
belongs to your application. This name is used to find resources
on the filesystem, can be used by extensions to improve debugging
information and a lot more.
So it's important what you provide there. If you are using a single
module, `__name__` is always the correct value. If you however are
using a package, it's usually recommended to hardcode the name of
your package there.
For example if your application is defined in :file:`yourapplication/app.py`
you should create it with one of the two versions below::
app = Flask('yourapplication')
app = Flask(__name__.split('.')[0])
Why is that? The application will work even with `__name__`, thanks
to how resources are looked up. However it will make debugging more
painful. Certain extensions can make assumptions based on the
import name of your application. For example the Flask-SQLAlchemy
extension will look for the code in your application that triggered
an SQL query in debug mode. If the import name is not properly set
up, that debugging information is lost. (For example it would only
pick up SQL queries in `yourapplication.app` and not
`yourapplication.views.frontend`)
.. versionadded:: 0.7
The `static_url_path`, `static_folder`, and `template_folder`
parameters were added.
.. versionadded:: 0.8
The `instance_path` and `instance_relative_config` parameters were
added.
.. versionadded:: 0.11
The `root_path` parameter was added.
.. versionadded:: 1.0
The ``host_matching`` and ``static_host`` parameters were added.
.. versionadded:: 1.0
The ``subdomain_matching`` parameter was added. Subdomain
matching needs to be enabled manually now. Setting
:data:`SERVER_NAME` does not implicitly enable it.
:param import_name: the name of the application package
:param static_url_path: can be used to specify a different path for the
static files on the web. Defaults to the name
of the `static_folder` folder.
:param static_folder: the folder with static files that should be served
at `static_url_path`. Defaults to the ``'static'``
folder in the root path of the application.
:param static_host: the host to use when adding the static route.
Defaults to None. Required when using ``host_matching=True``
with a ``static_folder`` configured.
:param host_matching: set ``url_map.host_matching`` attribute.
Defaults to False.
:param subdomain_matching: consider the subdomain relative to
:data:`SERVER_NAME` when matching routes. Defaults to False.
:param template_folder: the folder that contains the templates that should
be used by the application. Defaults to
``'templates'`` folder in the root path of the
application.
:param instance_path: An alternative instance path for the application.
By default the folder ``'instance'`` next to the
package or module is assumed to be the instance
path.
:param instance_relative_config: if set to ``True`` relative filenames
for loading the config are assumed to
be relative to the instance path instead
of the application root.
:param root_path: Flask by default will automatically calculate the path
to the root of the application. In certain situations
this cannot be achieved (for instance if the package
is a Python 3 namespace package) and needs to be
manually defined. |
| |
- Method resolution order:
- Server
- flask.app.Flask
- flask.helpers._PackageBoundObject
- builtins.object
Methods defined here:
- __init__(self, *args, **kwargs)
- Constructor for Server
:param args: arguments
:param kwargs: arguments with keys
Methods inherited from flask.app.Flask:
- __call__(self, environ, start_response)
- The WSGI server calls the Flask application object as the
WSGI application. This calls :meth:`wsgi_app` which can be
wrapped to applying middleware.
- __repr__(self)
- Return repr(self).
- add_template_filter(self, f, name=None)
- Register a custom template filter. Works exactly like the
:meth:`template_filter` decorator.
:param name: the optional name of the filter, otherwise the
function name will be used.
- add_template_global(self, f, name=None)
- Register a custom template global function. Works exactly like the
:meth:`template_global` decorator.
.. versionadded:: 0.10
:param name: the optional name of the global function, otherwise the
function name will be used.
- add_template_test(self, f, name=None)
- Register a custom template test. Works exactly like the
:meth:`template_test` decorator.
.. versionadded:: 0.10
:param name: the optional name of the test, otherwise the
function name will be used.
- add_url_rule(self, rule, endpoint=None, view_func=None, provide_automatic_options=None, **options)
- Connects a URL rule. Works exactly like the :meth:`route`
decorator. If a view_func is provided it will be registered with the
endpoint.
Basically this example::
@app.route('/')
def index():
pass
Is equivalent to the following::
def index():
pass
app.add_url_rule('/', 'index', index)
If the view_func is not provided you will need to connect the endpoint
to a view function like so::
app.view_functions['index'] = index
Internally :meth:`route` invokes :meth:`add_url_rule` so if you want
to customize the behavior via subclassing you only need to change
this method.
For more information refer to :ref:`url-route-registrations`.
.. versionchanged:: 0.2
`view_func` parameter added.
.. versionchanged:: 0.6
``OPTIONS`` is added automatically as method.
:param rule: the URL rule as string
:param endpoint: the endpoint for the registered URL rule. Flask
itself assumes the name of the view function as
endpoint
:param view_func: the function to call when serving a request to the
provided endpoint
:param provide_automatic_options: controls whether the ``OPTIONS``
method should be added automatically. This can also be controlled
by setting the ``view_func.provide_automatic_options = False``
before adding the rule.
:param options: the options to be forwarded to the underlying
:class:`~werkzeug.routing.Rule` object. A change
to Werkzeug is handling of method options. methods
is a list of methods this rule should be limited
to (``GET``, ``POST`` etc.). By default a rule
just listens for ``GET`` (and implicitly ``HEAD``).
Starting with Flask 0.6, ``OPTIONS`` is implicitly
added and handled by the standard request handling.
- after_request(self, f)
- Register a function to be run after each request.
Your function must take one parameter, an instance of
:attr:`response_class` and return a new response object or the
same (see :meth:`process_response`).
As of Flask 0.7 this function might not be executed at the end of the
request in case an unhandled exception occurred.
- app_context(self)
- Create an :class:`~flask.ctx.AppContext`. Use as a ``with``
block to push the context, which will make :data:`current_app`
point at this application.
An application context is automatically pushed by
:meth:`RequestContext.push() <flask.ctx.RequestContext.push>`
when handling a request, and when running a CLI command. Use
this to manually create a context outside of these situations.
::
with app.app_context():
init_db()
See :doc:`/appcontext`.
.. versionadded:: 0.9
- auto_find_instance_path(self)
- Tries to locate the instance path if it was not provided to the
constructor of the application class. It will basically calculate
the path to a folder named ``instance`` next to your main file or
the package.
.. versionadded:: 0.8
- before_first_request(self, f)
- Registers a function to be run before the first request to this
instance of the application.
The function will be called without any arguments and its return
value is ignored.
.. versionadded:: 0.8
- before_request(self, f)
- Registers a function to run before each request.
For example, this can be used to open a database connection, or to load
the logged in user from the session.
The function will be called without any arguments. If it returns a
non-None value, the value is handled as if it was the return value from
the view, and further request handling is stopped.
- context_processor(self, f)
- Registers a template context processor function.
- create_global_jinja_loader(self)
- Creates the loader for the Jinja2 environment. Can be used to
override just the loader and keeping the rest unchanged. It's
discouraged to override this function. Instead one should override
the :meth:`jinja_loader` function instead.
The global loader dispatches between the loaders of the application
and the individual blueprints.
.. versionadded:: 0.7
- create_jinja_environment(self)
- Creates the Jinja2 environment based on :attr:`jinja_options`
and :meth:`select_jinja_autoescape`. Since 0.7 this also adds
the Jinja2 globals and filters after initialization. Override
this function to customize the behavior.
.. versionadded:: 0.5
.. versionchanged:: 0.11
``Environment.auto_reload`` set in accordance with
``TEMPLATES_AUTO_RELOAD`` configuration option.
- create_url_adapter(self, request)
- Creates a URL adapter for the given request. The URL adapter
is created at a point where the request context is not yet set
up so the request is passed explicitly.
.. versionadded:: 0.6
.. versionchanged:: 0.9
This can now also be called without a request object when the
URL adapter is created for the application context.
.. versionchanged:: 1.0
:data:`SERVER_NAME` no longer implicitly enables subdomain
matching. Use :attr:`subdomain_matching` instead.
- dispatch_request(self)
- Does the request dispatching. Matches the URL and returns the
return value of the view or error handler. This does not have to
be a response object. In order to convert the return value to a
proper response object, call :func:`make_response`.
.. versionchanged:: 0.7
This no longer does the exception handling, this code was
moved to the new :meth:`full_dispatch_request`.
- do_teardown_appcontext(self, exc=<object object at 0x7f159eea84e0>)
- Called right before the application context is popped.
When handling a request, the application context is popped
after the request context. See :meth:`do_teardown_request`.
This calls all functions decorated with
:meth:`teardown_appcontext`. Then the
:data:`appcontext_tearing_down` signal is sent.
This is called by
:meth:`AppContext.pop() <flask.ctx.AppContext.pop>`.
.. versionadded:: 0.9
- do_teardown_request(self, exc=<object object at 0x7f159eea84e0>)
- Called after the request is dispatched and the response is
returned, right before the request context is popped.
This calls all functions decorated with
:meth:`teardown_request`, and :meth:`Blueprint.teardown_request`
if a blueprint handled the request. Finally, the
:data:`request_tearing_down` signal is sent.
This is called by
:meth:`RequestContext.pop() <flask.ctx.RequestContext.pop>`,
which may be delayed during testing to maintain access to
resources.
:param exc: An unhandled exception raised while dispatching the
request. Detected from the current exception information if
not passed. Passed to each teardown function.
.. versionchanged:: 0.9
Added the ``exc`` argument.
- endpoint(self, endpoint)
- A decorator to register a function as an endpoint.
Example::
@app.endpoint('example.endpoint')
def example():
return "example"
:param endpoint: the name of the endpoint
- errorhandler(self, code_or_exception)
- Register a function to handle errors by code or exception class.
A decorator that is used to register a function given an
error code. Example::
@app.errorhandler(404)
def page_not_found(error):
return 'This page does not exist', 404
You can also register handlers for arbitrary exceptions::
@app.errorhandler(DatabaseError)
def special_exception_handler(error):
return 'Database connection failed', 500
.. versionadded:: 0.7
Use :meth:`register_error_handler` instead of modifying
:attr:`error_handler_spec` directly, for application wide error
handlers.
.. versionadded:: 0.7
One can now additionally also register custom exception types
that do not necessarily have to be a subclass of the
:class:`~werkzeug.exceptions.HTTPException` class.
:param code_or_exception: the code as integer for the handler, or
an arbitrary exception
- finalize_request(self, rv, from_error_handler=False)
- Given the return value from a view function this finalizes
the request by converting it into a response and invoking the
postprocessing functions. This is invoked for both normal
request dispatching as well as error handlers.
Because this means that it might be called as a result of a
failure a special safe mode is available which can be enabled
with the `from_error_handler` flag. If enabled, failures in
response processing will be logged and otherwise ignored.
:internal:
- full_dispatch_request(self)
- Dispatches the request and on top of that performs request
pre and postprocessing as well as HTTP exception catching and
error handling.
.. versionadded:: 0.7
- handle_exception(self, e)
- Default exception handling that kicks in when an exception
occurs that is not caught. In debug mode the exception will
be re-raised immediately, otherwise it is logged and the handler
for a 500 internal server error is used. If no such handler
exists, a default 500 internal server error message is displayed.
.. versionadded:: 0.3
- handle_http_exception(self, e)
- Handles an HTTP exception. By default this will invoke the
registered error handlers and fall back to returning the
exception as response.
.. versionchanged:: 1.0.3
``RoutingException``, used internally for actions such as
slash redirects during routing, is not passed to error
handlers.
.. versionchanged:: 1.0
Exceptions are looked up by code *and* by MRO, so
``HTTPExcpetion`` subclasses can be handled with a catch-all
handler for the base ``HTTPException``.
.. versionadded:: 0.3
- handle_url_build_error(self, error, endpoint, values)
- Handle :class:`~werkzeug.routing.BuildError` on :meth:`url_for`.
- handle_user_exception(self, e)
- This method is called whenever an exception occurs that
should be handled. A special case is :class:`~werkzeug
.exceptions.HTTPException` which is forwarded to the
:meth:`handle_http_exception` method. This function will either
return a response value or reraise the exception with the same
traceback.
.. versionchanged:: 1.0
Key errors raised from request data like ``form`` show the
bad key in debug mode rather than a generic bad request
message.
.. versionadded:: 0.7
- inject_url_defaults(self, endpoint, values)
- Injects the URL defaults for the given endpoint directly into
the values dictionary passed. This is used internally and
automatically called on URL building.
.. versionadded:: 0.7
- iter_blueprints(self)
- Iterates over all blueprints by the order they were registered.
.. versionadded:: 0.11
- jinja_env(...)
- The Jinja2 environment used to load templates.
- log_exception(self, exc_info)
- Logs an exception. This is called by :meth:`handle_exception`
if debugging is disabled and right before the handler is called.
The default implementation logs the exception as error on the
:attr:`logger`.
.. versionadded:: 0.8
- logger(...)
- The ``'flask.app'`` logger, a standard Python
:class:`~logging.Logger`.
In debug mode, the logger's :attr:`~logging.Logger.level` will be set
to :data:`~logging.DEBUG`.
If there are no handlers configured, a default handler will be added.
See :ref:`logging` for more information.
.. versionchanged:: 1.0
Behavior was simplified. The logger is always named
``flask.app``. The level is only set during configuration, it
doesn't check ``app.debug`` each time. Only one format is used,
not different ones depending on ``app.debug``. No handlers are
removed, and a handler is only added if no handlers are already
configured.
.. versionadded:: 0.3
- make_config(self, instance_relative=False)
- Used to create the config attribute by the Flask constructor.
The `instance_relative` parameter is passed in from the constructor
of Flask (there named `instance_relative_config`) and indicates if
the config should be relative to the instance path or the root path
of the application.
.. versionadded:: 0.8
- make_default_options_response(self)
- This method is called to create the default ``OPTIONS`` response.
This can be changed through subclassing to change the default
behavior of ``OPTIONS`` responses.
.. versionadded:: 0.7
- make_null_session(self)
- Creates a new instance of a missing session. Instead of overriding
this method we recommend replacing the :class:`session_interface`.
.. deprecated: 1.0
Will be removed in 1.1. Use ``session_interface.make_null_session``
instead.
.. versionadded:: 0.7
- make_response(self, rv)
- Convert the return value from a view function to an instance of
:attr:`response_class`.
:param rv: the return value from the view function. The view function
must return a response. Returning ``None``, or the view ending
without returning, is not allowed. The following types are allowed
for ``view_rv``:
``str`` (``unicode`` in Python 2)
A response object is created with the string encoded to UTF-8
as the body.
``bytes`` (``str`` in Python 2)
A response object is created with the bytes as the body.
``tuple``
Either ``(body, status, headers)``, ``(body, status)``, or
``(body, headers)``, where ``body`` is any of the other types
allowed here, ``status`` is a string or an integer, and
``headers`` is a dictionary or a list of ``(key, value)``
tuples. If ``body`` is a :attr:`response_class` instance,
``status`` overwrites the exiting value and ``headers`` are
extended.
:attr:`response_class`
The object is returned unchanged.
other :class:`~werkzeug.wrappers.Response` class
The object is coerced to :attr:`response_class`.
:func:`callable`
The function is called as a WSGI application. The result is
used to create a response object.
.. versionchanged:: 0.9
Previously a tuple was interpreted as the arguments for the
response object.
- make_shell_context(self)
- Returns the shell context for an interactive shell for this
application. This runs all the registered shell context
processors.
.. versionadded:: 0.11
- name(...)
- The name of the application. This is usually the import name
with the difference that it's guessed from the run file if the
import name is main. This name is used as a display name when
Flask needs the name of the application. It can be set and overridden
to change the value.
.. versionadded:: 0.8
- open_instance_resource(self, resource, mode='rb')
- Opens a resource from the application's instance folder
(:attr:`instance_path`). Otherwise works like
:meth:`open_resource`. Instance resources can also be opened for
writing.
:param resource: the name of the resource. To access resources within
subfolders use forward slashes as separator.
:param mode: resource file opening mode, default is 'rb'.
- open_session(self, request)
- Creates or opens a new session. Default implementation stores all
session data in a signed cookie. This requires that the
:attr:`secret_key` is set. Instead of overriding this method
we recommend replacing the :class:`session_interface`.
.. deprecated: 1.0
Will be removed in 1.1. Use ``session_interface.open_session``
instead.
:param request: an instance of :attr:`request_class`.
- preprocess_request(self)
- Called before the request is dispatched. Calls
:attr:`url_value_preprocessors` registered with the app and the
current blueprint (if any). Then calls :attr:`before_request_funcs`
registered with the app and the blueprint.
If any :meth:`before_request` handler returns a non-None value, the
value is handled as if it was the return value from the view, and
further request handling is stopped.
- process_response(self, response)
- Can be overridden in order to modify the response object
before it's sent to the WSGI server. By default this will
call all the :meth:`after_request` decorated functions.
.. versionchanged:: 0.5
As of Flask 0.5 the functions registered for after request
execution are called in reverse order of registration.
:param response: a :attr:`response_class` object.
:return: a new response object or the same, has to be an
instance of :attr:`response_class`.
- raise_routing_exception(self, request)
- Exceptions that are recording during routing are reraised with
this method. During debug we are not reraising redirect requests
for non ``GET``, ``HEAD``, or ``OPTIONS`` requests and we're raising
a different error instead to help debug situations.
:internal:
- register_blueprint(self, blueprint, **options)
- Register a :class:`~flask.Blueprint` on the application. Keyword
arguments passed to this method will override the defaults set on the
blueprint.
Calls the blueprint's :meth:`~flask.Blueprint.register` method after
recording the blueprint in the application's :attr:`blueprints`.
:param blueprint: The blueprint to register.
:param url_prefix: Blueprint routes will be prefixed with this.
:param subdomain: Blueprint routes will match on this subdomain.
:param url_defaults: Blueprint routes will use these default values for
view arguments.
:param options: Additional keyword arguments are passed to
:class:`~flask.blueprints.BlueprintSetupState`. They can be
accessed in :meth:`~flask.Blueprint.record` callbacks.
.. versionadded:: 0.7
- register_error_handler(self, code_or_exception, f)
- Alternative error attach function to the :meth:`errorhandler`
decorator that is more straightforward to use for non decorator
usage.
.. versionadded:: 0.7
- request_context(self, environ)
- Create a :class:`~flask.ctx.RequestContext` representing a
WSGI environment. Use a ``with`` block to push the context,
which will make :data:`request` point at this request.
See :doc:`/reqcontext`.
Typically you should not call this from your own code. A request
context is automatically pushed by the :meth:`wsgi_app` when
handling a request. Use :meth:`test_request_context` to create
an environment and context instead of this method.
:param environ: a WSGI environment
- route(self, rule, **options)
- A decorator that is used to register a view function for a
given URL rule. This does the same thing as :meth:`add_url_rule`
but is intended for decorator usage::
@app.route('/')
def index():
return 'Hello World'
For more information refer to :ref:`url-route-registrations`.
:param rule: the URL rule as string
:param endpoint: the endpoint for the registered URL rule. Flask
itself assumes the name of the view function as
endpoint
:param options: the options to be forwarded to the underlying
:class:`~werkzeug.routing.Rule` object. A change
to Werkzeug is handling of method options. methods
is a list of methods this rule should be limited
to (``GET``, ``POST`` etc.). By default a rule
just listens for ``GET`` (and implicitly ``HEAD``).
Starting with Flask 0.6, ``OPTIONS`` is implicitly
added and handled by the standard request handling.
- run(self, host=None, port=None, debug=None, load_dotenv=True, **options)
- Runs the application on a local development server.
Do not use ``run()`` in a production setting. It is not intended to
meet security and performance requirements for a production server.
Instead, see :ref:`deployment` for WSGI server recommendations.
If the :attr:`debug` flag is set the server will automatically reload
for code changes and show a debugger in case an exception happened.
If you want to run the application in debug mode, but disable the
code execution on the interactive debugger, you can pass
``use_evalex=False`` as parameter. This will keep the debugger's
traceback screen active, but disable code execution.
It is not recommended to use this function for development with
automatic reloading as this is badly supported. Instead you should
be using the :command:`flask` command line script's ``run`` support.
.. admonition:: Keep in Mind
Flask will suppress any server error with a generic error page
unless it is in debug mode. As such to enable just the
interactive debugger without the code reloading, you have to
invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
Setting ``use_debugger`` to ``True`` without being in debug mode
won't catch any exceptions because there won't be any to
catch.
:param host: the hostname to listen on. Set this to ``'<IP_ADDRESS>'`` to
have the server available externally as well. Defaults to
``'<IP_ADDRESS>'`` or the host in the ``SERVER_NAME`` config variable
if present.
:param port: the port of the webserver. Defaults to ``5000`` or the
port defined in the ``SERVER_NAME`` config variable if present.
:param debug: if given, enable or disable debug mode. See
:attr:`debug`.
:param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
files to set environment variables. Will also change the working
directory to the directory containing the first file found.
:param options: the options to be forwarded to the underlying Werkzeug
server. See :func:`werkzeug.serving.run_simple` for more
information.
.. versionchanged:: 1.0
If installed, python-dotenv will be used to load environment
variables from :file:`.env` and :file:`.flaskenv` files.
If set, the :envvar:`FLASK_ENV` and :envvar:`FLASK_DEBUG`
environment variables will override :attr:`env` and
:attr:`debug`.
Threaded mode is enabled by default.
.. versionchanged:: 0.10
The default port is now picked from the ``SERVER_NAME``
variable.
- save_session(self, session, response)
- Saves the session if it needs updates. For the default
implementation, check :meth:`open_session`. Instead of overriding this
method we recommend replacing the :class:`session_interface`.
.. deprecated: 1.0
Will be removed in 1.1. Use ``session_interface.save_session``
instead.
:param session: the session to be saved (a
:class:`~werkzeug.contrib.securecookie.SecureCookie`
object)
:param response: an instance of :attr:`response_class`
- select_jinja_autoescape(self, filename)
- Returns ``True`` if autoescaping should be active for the given
template name. If no template name is given, returns `True`.
.. versionadded:: 0.5
- shell_context_processor(self, f)
- Registers a shell context processor function.
.. versionadded:: 0.11
- should_ignore_error(self, error)
- This is called to figure out if an error should be ignored
or not as far as the teardown system is concerned. If this
function returns ``True`` then the teardown handlers will not be
passed the error.
.. versionadded:: 0.10
- teardown_appcontext(self, f)
- Registers a function to be called when the application context
ends. These functions are typically also called when the request
context is popped.
Example::
ctx = app.app_context()
ctx.push()
...
ctx.pop()
When ``ctx.pop()`` is executed in the above example, the teardown
functions are called just before the app context moves from the
stack of active contexts. This becomes relevant if you are using
such constructs in tests.
Since a request context typically also manages an application
context it would also be called when you pop a request context.
When a teardown function was called because of an unhandled exception
it will be passed an error object. If an :meth:`errorhandler` is
registered, it will handle the exception and the teardown will not
receive it.
The return values of teardown functions are ignored.
.. versionadded:: 0.9
- teardown_request(self, f)
- Register a function to be run at the end of each request,
regardless of whether there was an exception or not. These functions
are executed when the request context is popped, even if not an
actual request was performed.
Example::
ctx = app.test_request_context()
ctx.push()
...
ctx.pop()
When ``ctx.pop()`` is executed in the above example, the teardown
functions are called just before the request context moves from the
stack of active contexts. This becomes relevant if you are using
such constructs in tests.
Generally teardown functions must take every necessary step to avoid
that they will fail. If they do execute code that might fail they
will have to surround the execution of these code by try/except
statements and log occurring errors.
When a teardown function was called because of an exception it will
be passed an error object.
The return values of teardown functions are ignored.
.. admonition:: Debug Note
In debug mode Flask will not tear down a request on an exception
immediately. Instead it will keep it alive so that the interactive
debugger can still access it. This behavior can be controlled
by the ``PRESERVE_CONTEXT_ON_EXCEPTION`` configuration variable.
- template_filter(self, name=None)
- A decorator that is used to register custom template filter.
You can specify a name for the filter, otherwise the function
name will be used. Example::
@app.template_filter()
def reverse(s):
return s[::-1]
:param name: the optional name of the filter, otherwise the
function name will be used.
- template_global(self, name=None)
- A decorator that is used to register a custom template global function.
You can specify a name for the global function, otherwise the function
name will be used. Example::
@app.template_global()
def double(n):
return 2 * n
.. versionadded:: 0.10
:param name: the optional name of the global function, otherwise the
function name will be used.
- template_test(self, name=None)
- A decorator that is used to register custom template test.
You can specify a name for the test, otherwise the function
name will be used. Example::
@app.template_test()
def is_prime(n):
if n == 2:
return True
for i in range(2, int(math.ceil(math.sqrt(n))) + 1):
if n % i == 0:
return False
return True
.. versionadded:: 0.10
:param name: the optional name of the test, otherwise the
function name will be used.
- test_cli_runner(self, **kwargs)
- Create a CLI runner for testing CLI commands.
See :ref:`testing-cli`.
Returns an instance of :attr:`test_cli_runner_class`, by default
:class:`~flask.testing.FlaskCliRunner`. The Flask app object is
passed as the first argument.
.. versionadded:: 1.0
- test_client(self, use_cookies=True, **kwargs)
- Creates a test client for this application. For information
about unit testing head over to :ref:`testing`.
Note that if you are testing for assertions or exceptions in your
application code, you must set ``app.testing = True`` in order for the
exceptions to propagate to the test client. Otherwise, the exception
will be handled by the application (not visible to the test client) and
the only indication of an AssertionError or other exception will be a
500 status code response to the test client. See the :attr:`testing`
attribute. For example::
app.testing = True
client = app.test_client()
The test client can be used in a ``with`` block to defer the closing down
of the context until the end of the ``with`` block. This is useful if
you want to access the context locals for testing::
with app.test_client() as c:
rv = c.get('/?vodka=42')
assert request.args['vodka'] == '42'
Additionally, you may pass optional keyword arguments that will then
be passed to the application's :attr:`test_client_class` constructor.
For example::
from flask.testing import FlaskClient
class CustomClient(FlaskClient):
def __init__(self, *args, **kwargs):
self._authentication = kwargs.pop("authentication")
super(CustomClient,self).__init__( *args, **kwargs)
app.test_client_class = CustomClient
client = app.test_client(authentication='Basic ....')
See :class:`~flask.testing.FlaskClient` for more information.
.. versionchanged:: 0.4
added support for ``with`` block usage for the client.
.. versionadded:: 0.7
The `use_cookies` parameter was added as well as the ability
to override the client to be used by setting the
:attr:`test_client_class` attribute.
.. versionchanged:: 0.11
Added `**kwargs` to support passing additional keyword arguments to
the constructor of :attr:`test_client_class`.
- test_request_context(self, *args, **kwargs)
- Create a :class:`~flask.ctx.RequestContext` for a WSGI
environment created from the given values. This is mostly useful
during testing, where you may want to run a function that uses
request data without dispatching a full request.
See :doc:`/reqcontext`.
Use a ``with`` block to push the context, which will make
:data:`request` point at the request for the created
environment. ::
with test_request_context(...):
generate_report()
When using the shell, it may be easier to push and pop the
context manually to avoid indentation. ::
ctx = app.test_request_context(...)
ctx.push()
...
ctx.pop()
Takes the same arguments as Werkzeug's
:class:`~werkzeug.test.EnvironBuilder`, with some defaults from
the application. See the linked Werkzeug docs for most of the
available arguments. Flask-specific behavior is listed here.
:param path: URL path being requested.
:param base_url: Base URL where the app is being served, which
``path`` is relative to. If not given, built from
:data:`PREFERRED_URL_SCHEME`, ``subdomain``,
:data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
:param subdomain: Subdomain name to append to
:data:`SERVER_NAME`.
:param url_scheme: Scheme to use instead of
:data:`PREFERRED_URL_SCHEME`.
:param data: The request body, either as a string or a dict of
form keys and values.
:param json: If given, this is serialized as JSON and passed as
``data``. Also defaults ``content_type`` to
``application/json``.
:param args: other positional arguments passed to
:class:`~werkzeug.test.EnvironBuilder`.
:param kwargs: other keyword arguments passed to
:class:`~werkzeug.test.EnvironBuilder`.
- trap_http_exception(self, e)
- Checks if an HTTP exception should be trapped or not. By default
this will return ``False`` for all exceptions except for a bad request
key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to ``True``. It
also returns ``True`` if ``TRAP_HTTP_EXCEPTIONS`` is set to ``True``.
This is called for all HTTP exceptions raised by a view function.
If it returns ``True`` for any exception the error handler for this
exception is not called and it shows up as regular exception in the
traceback. This is helpful for debugging implicitly raised HTTP
exceptions.
.. versionchanged:: 1.0
Bad request errors are not trapped by default in debug mode.
.. versionadded:: 0.8
- try_trigger_before_first_request_functions(self)
- Called before each request and will ensure that it triggers
the :attr:`before_first_request_funcs` and only exactly once per
application instance (which means process usually).
:internal:
- update_template_context(self, context)
- Update the template context with some commonly used variables.
This injects request, session, config and g into the template
context as well as everything template context processors want
to inject. Note that the as of Flask 0.6, the original values
in the context will not be overridden if a context processor
decides to return a value with the same key.
:param context: the context as a dictionary that is updated in place
to add extra variables.
- url_defaults(self, f)
- Callback function for URL defaults for all view functions of the
application. It's called with the endpoint and values and should
update the values passed in place.
- url_value_preprocessor(self, f)
- Register a URL value preprocessor function for all view
functions in the application. These functions will be called before the
:meth:`before_request` functions.
The function can modify the values captured from the matched url before
they are passed to the view. For example, this can be used to pop a
common language code value and place it in ``g`` rather than pass it to
every view.
The function is passed the endpoint name and values dict. The return
value is ignored.
- wsgi_app(self, environ, start_response)
- The actual WSGI application. This is not implemented in
:meth:`__call__` so that middlewares can be applied without
losing a reference to the app object. Instead of doing this::
app = MyMiddleware(app)
It's a better idea to do this instead::
app.wsgi_app = MyMiddleware(app.wsgi_app)
Then you still have the original application object around and
can continue to call methods on it.
.. versionchanged:: 0.7
Teardown events for the request and app contexts are called
even if an unhandled error occurs. Other events may not be
called depending on when an error occurs during dispatch.
See :ref:`callbacks-and-errors`.
:param environ: A WSGI environment.
:param start_response: A callable accepting a status code,
a list of headers, and an optional exception context to
start the response.
Data descriptors inherited from flask.app.Flask:
- debug
- env
- Makes an attribute forward to the config
- got_first_request
- This attribute is set to ``True`` if the application started
handling the first request.
.. versionadded:: 0.8
- permanent_session_lifetime
- Makes an attribute forward to the config
- preserve_context_on_exception
- Returns the value of the ``PRESERVE_CONTEXT_ON_EXCEPTION``
configuration value in case it's set, otherwise a sensible default
is returned.
.. versionadded:: 0.7
- propagate_exceptions
- Returns the value of the ``PROPAGATE_EXCEPTIONS`` configuration
value in case it's set, otherwise a sensible default is returned.
.. versionadded:: 0.7
- secret_key
- Makes an attribute forward to the config
- send_file_max_age_default
- Makes an attribute forward to the config
- session_cookie_name
- Makes an attribute forward to the config
- templates_auto_reload
- Reload templates when they are changed. Used by
:meth:`create_jinja_environment`.
This attribute can be configured with :data:`TEMPLATES_AUTO_RELOAD`. If
not set, it will be enabled in debug mode.
.. versionadded:: 1.0
This property was added but the underlying config and behavior
already existed.
- testing
- Makes an attribute forward to the config
- use_x_sendfile
- Makes an attribute forward to the config
Data and other attributes inherited from flask.app.Flask:
- app_ctx_globals_class = <class 'flask.ctx._AppCtxGlobals'>
- A plain object. Used as a namespace for storing data during an
application context.
Creating an app context automatically creates this object, which is
made available as the :data:`g` proxy.
.. describe:: 'key' in g
Check whether an attribute is present.
.. versionadded:: 0.10
.. describe:: iter(g)
Return an iterator over the attribute names.
.. versionadded:: 0.10
- config_class = <class 'flask.config.Config'>
- Works exactly like a dict but provides ways to fill it from files
or special dictionaries. There are two common patterns to populate the
config.
Either you can fill the config from a config file::
app.config.from_pyfile('yourconfig.cfg')
Or alternatively you can define the configuration options in the
module that calls :meth:`from_object` or provide an import path to
a module that should be loaded. It is also possible to tell it to
use the same module and with that provide the configuration values
just before the call::
DEBUG = True
SECRET_KEY = 'development key'
app.config.from_object(__name__)
In both cases (loading from any Python file or loading from modules),
only uppercase keys are added to the config. This makes it possible to use
lowercase values in the config file for temporary values that are not added
to the config or to define the config keys in the same file that implements
the application.
Probably the most interesting way to load configurations is from an
environment variable pointing to a file::
app.config.from_envvar('YOURAPPLICATION_SETTINGS')
In this case before launching the application you have to set this
environment variable to the file you want to use. On Linux and OS X
use the export statement::
export YOURAPPLICATION_SETTINGS='/path/to/config/file'
On windows use `set` instead.
:param root_path: path to which files are read relative from. When the
config object is created by the application, this is
the application's :attr:`~flask.Flask.root_path`.
:param defaults: an optional dictionary of default values
- default_config = ImmutableDict({'ENV': None, 'DEBUG': None, 'TEST...TES_AUTO_RELOAD': None, 'MAX_COOKIE_SIZE': 4093})
- import_name = None
- jinja_environment = <class 'flask.templating.Environment'>
- Works like a regular Jinja2 environment but has some additional
knowledge of how Flask's blueprint works so that it can prepend the
name of the blueprint to referenced templates if necessary.
- jinja_options = ImmutableDict({'extensions': ['jinja2.ext.autoescape', 'jinja2.ext.with_']})
- json_decoder = <class 'flask.json.JSONDecoder'>
- The default JSON decoder. This one does not change the behavior from
the default simplejson decoder. Consult the :mod:`json` documentation
for more information. This decoder is not only used for the load
functions of this module but also :attr:`~flask.Request`.
- json_encoder = <class 'flask.json.JSONEncoder'>
- The default Flask JSON encoder. This one extends the default simplejson
encoder by also supporting ``datetime`` objects, ``UUID`` as well as
``Markup`` objects which are serialized as RFC 822 datetime strings (same
as the HTTP date format). In order to support more data types override the
:meth:`default` method.
- request_class = <class 'flask.wrappers.Request'>
- The request object used by default in Flask. Remembers the
matched endpoint and view arguments.
It is what ends up as :class:`~flask.request`. If you want to replace
the request object used you can subclass this and set
:attr:`~flask.Flask.request_class` to your subclass.
The request object is a :class:`~werkzeug.wrappers.Request` subclass and
provides all of the attributes Werkzeug defines plus a few Flask
specific ones.
- response_class = <class 'flask.wrappers.Response'>
- The response object that is used by default in Flask. Works like the
response object from Werkzeug but is set to have an HTML mimetype by
default. Quite often you don't have to create this object yourself because
:meth:`~flask.Flask.make_response` will take care of that for you.
If you want to replace the response object used you can subclass this and
set :attr:`~flask.Flask.response_class` to your subclass.
.. versionchanged:: 1.0
JSON support is added to the response, like the request. This is useful
when testing to get the test client response data as JSON.
.. versionchanged:: 1.0
Added :attr:`max_cookie_size`.
- root_path = None
- session_interface = <flask.sessions.SecureCookieSessionInterface object>
- template_folder = None
- test_cli_runner_class = None
- test_client_class = None
- url_rule_class = <class 'werkzeug.routing.Rule'>
- A Rule represents one URL pattern. There are some options for `Rule`
that change the way it behaves and are passed to the `Rule` constructor.
Note that besides the rule-string all arguments *must* be keyword arguments
in order to not break the application on Werkzeug upgrades.
`string`
Rule strings basically are just normal URL paths with placeholders in
the format ``<converter(arguments):name>`` where the converter and the
arguments are optional. If no converter is defined the `default`
converter is used which means `string` in the normal configuration.
URL rules that end with a slash are branch URLs, others are leaves.
If you have `strict_slashes` enabled (which is the default), all
branch URLs that are matched without a trailing slash will trigger a
redirect to the same URL with the missing slash appended.
The converters are defined on the `Map`.
`endpoint`
The endpoint for this rule. This can be anything. A reference to a
function, a string, a number etc. The preferred way is using a string
because the endpoint is used for URL generation.
`defaults`
An optional dict with defaults for other rules with the same endpoint.
This is a bit tricky but useful if you want to have unique URLs::
url_map = Map([
Rule('/all/', defaults={'page': 1}, endpoint='all_entries'),
Rule('/all/page/<int:page>', endpoint='all_entries')
])
If a user now visits ``http://example.com/all/page/1`` he will be
redirected to ``http://example.com/all/``. If `redirect_defaults` is
disabled on the `Map` instance this will only affect the URL
generation.
`subdomain`
The subdomain rule string for this rule. If not specified the rule
only matches for the `default_subdomain` of the map. If the map is
not bound to a subdomain this feature is disabled.
Can be useful if you want to have user profiles on different subdomains
and all subdomains are forwarded to your application::
url_map = Map([
Rule('/', subdomain='<username>', endpoint='user/homepage'),
Rule('/stats', subdomain='<username>', endpoint='user/stats')
])
`methods`
A sequence of http methods this rule applies to. If not specified, all
methods are allowed. For example this can be useful if you want different
endpoints for `POST` and `GET`. If methods are defined and the path
matches but the method matched against is not in this list or in the
list of another rule for that path the error raised is of the type
`MethodNotAllowed` rather than `NotFound`. If `GET` is present in the
list of methods and `HEAD` is not, `HEAD` is added automatically.
.. versionchanged:: 0.6.1
`HEAD` is now automatically added to the methods if `GET` is
present. The reason for this is that existing code often did not
work properly in servers not rewriting `HEAD` to `GET`
automatically and it was not documented how `HEAD` should be
treated. This was considered a bug in Werkzeug because of that.
`strict_slashes`
Override the `Map` setting for `strict_slashes` only for this rule. If
not specified the `Map` setting is used.
`build_only`
Set this to True and the rule will never match but will create a URL
that can be build. This is useful if you have resources on a subdomain
or folder that are not handled by the WSGI application (like static data)
`redirect_to`
If given this must be either a string or callable. In case of a
callable it's called with the url adapter that triggered the match and
the values of the URL as keyword arguments and has to return the target
for the redirect, otherwise it has to be a string with placeholders in
rule syntax::
def foo_with_slug(adapter, id):
# ask the database for the slug for the old id. this of
# course has nothing to do with werkzeug.
return 'foo/' + Foo.get_slug_for_id(id)
url_map = Map([
Rule('/foo/<slug>', endpoint='foo'),
Rule('/some/old/url/<slug>', redirect_to='foo/<slug>'),
Rule('/other/old/url/<int:id>', redirect_to=foo_with_slug)
])
When the rule is matched the routing system will raise a
`RequestRedirect` exception with the target for the redirect.
Keep in mind that the URL will be joined against the URL root of the
script so don't use a leading slash on the target URL unless you
really mean root of that domain.
`alias`
If enabled this rule serves as an alias for another rule with the same
endpoint and arguments.
`host`
If provided and the URL map has host matching enabled this can be
used to provide a match rule for the whole host. This also means
that the subdomain feature is disabled.
.. versionadded:: 0.7
The `alias` and `host` parameters were added.
Methods inherited from flask.helpers._PackageBoundObject:
- get_send_file_max_age(self, filename)
- Provides default cache_timeout for the :func:`send_file` functions.
By default, this function returns ``SEND_FILE_MAX_AGE_DEFAULT`` from
the configuration of :data:`~flask.current_app`.
Static file functions such as :func:`send_from_directory` use this
function, and :func:`send_file` calls this function on
:data:`~flask.current_app` when the given cache_timeout is ``None``. If a
cache_timeout is given in :func:`send_file`, that timeout is used;
otherwise, this method is called.
This allows subclasses to change the behavior when sending files based
on the filename. For example, to set the cache timeout for .js files
to 60 seconds::
class MyFlask(flask.Flask):
def get_send_file_max_age(self, name):
if name.lower().endswith('.js'):
return 60
return flask.Flask.get_send_file_max_age(self, name)
.. versionadded:: 0.9
- jinja_loader(...)
- The Jinja loader for this package bound object.
.. versionadded:: 0.5
- open_resource(self, resource, mode='rb')
- Opens a resource from the application's resource folder. To see
how this works, consider the following folder structure::
/myapplication.py
/schema.sql
/static
/style.css
/templates
/layout.html
/index.html
If you want to open the :file:`schema.sql` file you would do the
following::
with app.open_resource('schema.sql') as f:
contents = f.read()
do_something_with(contents)
:param resource: the name of the resource. To access resources within
subfolders use forward slashes as separator.
:param mode: resource file opening mode, default is 'rb'.
- send_static_file(self, filename)
- Function used internally to send static files from the static
folder to the browser.
.. versionadded:: 0.5
Data descriptors inherited from flask.helpers._PackageBoundObject:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
- has_static_folder
- This is ``True`` if the package bound object's container has a
folder for static files.
.. versionadded:: 0.5
- static_folder
- The absolute path to the configured static folder.
- static_url_path
- The URL prefix that the static route will be registered for.
| |


Section 4.1 Braille Sense Skills Checklist
|
Scoring Key |
|
I = independent VC = verbal cue(s) PA = physical assist(s) X = not worked on yet or not applicable (explain reason) |
|
Braille Sense Skills |
Date and Evaluator Initials |
Score |
Date and Evaluator Initials |
Score |
Date and Evaluator Initials |
Score |
|
Lesson 1 |
|
|
|
|
|
|
|
1.   Locate the six Braille writer keys and the space. |
|
|
|
|
|
|
|
4. Identify the backspace and enter keys. |
|
|
|
|
|
|
|
5.  Identify the scroll keys. |
|
|
|
|
|
|
|
7. Locate the Braille display and cursor keys. |
|
|
|
|
|
|
|
8.  Use the scroll keys to move up and down the list of applications. |
|
|
|
|
|
|
|
10. Use F! to go to the File Manager. |
|
|
|
|
|
|
|
11. Move to the end (bottom) of a file list (space + 4 5 6). |
|
|
|
|
|
|
|
12. Move to the beginning of a file list (space with 1 2 3). |
|
|
|
|
|
|
|
13. Get help when needed (space + h). |
|
|
|
|
|
|
|
14. Adjust the speech rate (space + F4 or space + F1). |
|
|
|
|
|
|
|
15.  Adjust the voice pitch (enter with F1 or enter with F4). |
|
|
|
|
|
|
|
17. Open a new word document. |
|
|
|
|
|
|
|
18. Write in a document. |
|
|
|
|
|
|
|
19. Use backspace to delete the previous character. |
|
|
|
|
|
|
|
20. Use the enter key to begin a new line. |
|
|
|
|
|
|
|
21. Read a document using the scroll keys. |
|
|
|
|
|
|
|
22. Save a document (enter with s). |
|
|
|
|
|
|
|
23. Exit a document and return to the File Manager. |
|
|
|
|
|
|
|
24. Check the time (enter with t). |
|
|
|
|
|
|
|
25.  Insert the date into a document (enter with w). |
|
|
|
|
|
|
|
27. Jump to top of document (space with 1 2 3). |
|
|
|
|
|
|
|
28. Jump to end of document (space with 4 5 6). |
|
|
|
|
|
|
|
29. Use the cursor keys when necessary. |
|
|
|
|
|
|
|
30. Use F2 to access word processor menu options. |
|
|
|
|
|
|
|
31.  Open the utilities menu. |
|
|
|
|
|
|
|
33. Perform basic functions involved with using the scientific calculator. |
|
|
|
|
|
|
|
34. Obtain help and learn about the calculator. |
|
|
|
|
|
|
|
35. Exit the calculator. |
|
|
|
|
|
|
|
36. Set the Braille Sense time and date. |
|
|
|
|
|
|
|
37. Use F3 for tab when needed. |
|
|
|
|
|
|
|
38.  Open the Options Menu (space with o). |
|
|
|
|
|
|
|
40. Navigate through the options menu. |
|
|
|
|
|
|
|
41. Make changes to the options menu. |
|
|
|
|
|
|
|
42.  Open the Address Book Manager. |
|
|
|
|
|
|
|
44. Add and save an address record. |
|
|
|
|
|
|
|
45. Search for an address record. |
|
|
|
|
|
|
|
46. Move back and forward through address fields (space with 2 and space with 5). |
|
|
|
|
|
|
|
47. Modify a record when needed (enter with m). |
|
|
|
|
|
|
|
48.  Open the schedule manager. |
|
|
|
|
|
|
|
50. Add a new schedule (enter with i to begin). |
|
|
|
|
|
|
|
51. Turn check today’s schedule on or off as needed. |
|
|
|
|
|
|
|
52.  Open the pronunciation dictionary. |
|
|
|
|
|
|
|
54. Add a word to the pronunciation dictionary. |
|
|
|
|
|
|
|
55. Search for a word in the pronunciation dictionary. |
|
|
|
|
|
|
|
56. Modify a word as necessary. |
|
|
|
|
|
|
|
57.  Open the web browser. |
|
|
|
|
|
|
|
59. Move forward by link (F3). |
|
|
|
|
|
|
|
60. Move back by link (F3 with F4). |
|
|
|
|
|
|
|
61. Open a line (enter). |
|
|
|
|
|
|
|
62.  Open the Bookshare or other site where books can be obtained. |
|
|
|
|
|
|
|
54. Log in to site as needed. |
|
|
|
|
|
|
|
55. Locate and download a book. |
|
|
|
|
|
|
|
56. Unzip the book if using Bookshare. |
|
|
|
|
|
|
|
Lesson 13 |
|
|
|
|
|
|
|
57. Find text (space with f). |
|
|
|
|
|
|
|
58. Find the next occurrence of a text string (enter with f). |
|
|
|
|
|
|
|
59. Replace text as needed (enter with r). |
|
|
|
|
|
|
|
60. Search forward or back from the cursor. |
|
|
|
|
|
|
|
Lesson 14 |
|
|
|
|
|
|
|
61.  Change the “range” of the spelling check as needed. |
|
|
|
|
|
|
|
63.  Go to the previously opened document (space with b). |
|
|
|
|
|
|
|
65. Switch to the next “open” document (space with 4 5). |
|
|
|
|
|
|
|
66.  Change the printer port setting as needed. |
|
|
|
|
|
|
|
68. Print or emboss a document. |
|
|
|
|
|
|
|
69. Handle hardware as appropriate. |
|
|
|
|
|
|
|
70. Handle paper and re-filling tray when appropriate. |
|
|
|
|
|
|
|
Total Independent Score |
|
|
|
|
|
|


Sometimes users may need to select specific set of data from the data table to run their own operations. In such cases, you might want to turn row selectable on.
To enable row selectable option, simply set rowSelectable
to true and by default rowSelectable
is
false.
{{demoSnippet.row_selectable}}
In default the table doesn't allow you to select rows. But if you are going to select row(s), there are some additional configurations available to do the job easily. Those properties will be discuss on Useful Properties section.
As mentioned earlier, there are some additional configurations which helps users to control the row selection.
selectMode: string = 'single' | 'single_toggle' | 'multi'
This control allows you to configure the dropdown row selection type. There are 3 types of row selections are available in the data table. The available types are,
Users are only allowed to select one row at a time. Once the selection is made, it can only be changed by selecting other row. That means, only one row item can be selected.
Users are only allowed to select one row at a time. Can toggle the row selection. But in this type, once the selection is made, it can be removed by clicking the row itself (if select on row click is enabled) or by unchecking the checkbox (if check boxes enabled).
Users can select multiple rows at a time. Can toggle the row selection.
showRowSelectCheckbox: boolean
The page property lets you to enable/disable table row selection check boxes as shown in the Row Selection Mode section's examples. Selection checkboxes are enabled in all those examples.
selectOnRowClick: boolean
The page property lets you to enable/disable table row selection on row click event as shown in the Row Selection Mode section's examples. Select on row click is enabled in all those examples.
selectTrackBy: string
This control helps users to identify selected row(s) uniquely. When selecting row(s), data table will emit the value of the column specified by the user. Please refer Data Table Events section for more details. All the examples shown in Row Selection Mode section has "id" as selectTrackBy property.
selectedRow: any
The page property lets you to set specific row selected in the data table. This can be only used with the single & single_toggle selection modes mentioned in the above. Refer following example,
selectedRows: any[]
The page property lets you to set specific rows selected in the data table. This can be only used with the multi selection mode mentioned in the above. Refer following example,


Fathom Tools
Fathom has a number of built-in tools for network monitoring and troubleshooting available in the Fathom Menu :
- Pageload Performance displays the pageload time of the current active tab.
- Debug My Connection test your network configuration and connectivity if you are having problems with your network.
- Home Network Discovery discover devices and network connectivity in your home network.
- Monitoring Graphs explore web browsing, network and system performance over time.
Contribute Data for Research
Fathom is a joint research project betweek MUSE team of Inria Paris-Rocquencourt (FR) and International Computer Science Institute (ICSI) at Berkeley (CA, US). We do research on on network quality of experience and root cause detection of performance degradations.
We use Fathom to collect data for our research. Data sharing is optional and you can use the Fathom extension and tools without contributing any data.
Next three slides present our privacy policy and collected data, and ask you for your data sharing preferences.
Privacy Policy
The collected data is stored on our secure servers and never shared with 3rd parties. In accordance with the French legislation (see the full data protection notice in french below) you have the right to access and correct, or for legitimate reasons, deny processing of any data conserning you by contacting us.
Les informations recueillies font l’objet d’un traitement informatique destiné à l'etude de la qualité d’experience Internet et le diagnostique des "root causes" des degradations de performance. Les destinataires des données sont : l'équipe MUSE / Inria Paris-Rocquencourt.
Conformément à la loi « informatique et libertés » du 6 janvier 1978 modifiée en 2004, vous bénéficiez d’un droit d’accès et de rectification aux informations qui vous concernent, que vous pouvez exercer en vous adressant à Fathom Team.
Vous pouvez également, pour des motifs légitimes, vous opposer au traitement des données vous concernant.
Pageload Performance
Fathom monitors on the background the pageload times of the sites you visit (except when in private-browsing mode). The monitoring is light-weight and does not impact your internet browsing. You can check the pageload performance of the current active tab in the Fathom Menu and historical data using the Monitoring Graphs tool.
If you choose to share data with us, the names of the sites you visit are anonymized except for a small number of popular whitelisted domains (such as google.com) that you can edit here. Any personally identifiable information (such as URL request parameters) are never recorded.
System Performance
Fathom monitors on the background the performance of your system (CPU, load, memory) and network connectivity (signal quality on Wifi, cross-traffic and network delays). The monitoring is light-weight and does not impact your internet browsing. You can explore the performance statistics using the Monitoring Graphs tool.


JS Topic-Functions
Home
(current)
Java
Advanced JAVA
MYSQL
HTML
CSS
JAVASCRIPT
JDBC
JS Functions
JS Functions
Download zip
Prev
JS Home
Next


Gladiator *** rated R 154 minutes DreamWorks/Universal starring Russell Crowe, Joaquin Phoenix, Connie Nielsen, Oliver Reed, Derek Jacobi, Djimon Hounsou, Richard Harris, David Schofield written by David H. Franzoni, John Logan, William Nicholson directed by Ridley Scott
A Review by Akiva Gottlieb
Summer is beginning earlier than ever, with each year's first blockbuster action picture being released in early May. Last year, early May brought us `The Mummy', easily the worst film to hit screens in 1999. The summer of 2000, however, seems to be a more ambitious one, with its May blockbuster being Ridley Scott's thrilling `Gladiator', a solid, high-octane period picture that wears the guise of a sweeping, emotionally-charged epic.
The success of `Gladiator' (both critically and commercially) should be attributed to two film veterans. The first is director Ridley Scott; a man who, in the early 80's, changed the face of science-fiction forever with `Blade Runner' and `Alien', and showed a knack for female-exploitation with his estrogen-fueled `Thelma and Louise' and `G.I. Jane'.
The second reason for the event-movie status of `Gladiator' is Australian heartbreaker Russell Crowe, who was recently robbed of an Oscar for his riveting work in Michael Mann's `The Insider'. After years of stunning bit roles in American films like `L.A. Confidential', he may finally become a recognized star with his compelling performance in `Gladiator'.
The film begins with a battle sequence so sharply edited that it rivals the football matches in Oliver Stone's `Any Given Sunday'. The Roman army, led by General Maximus (Russell Crowe), engages in bloody combat with an incompetent squad of Germanians, and comes out victorious. The battle brings to an end another tireless war, and the dying king Marcus Aurelius (Richard Harris) feels that it is time to pass his crown on to another man.
The expected choice would be Aurelius' son, the brutally unscrupulous Commodus (Joaquin Phoenix). But Aurelius has a different agenda, and tells General Maximus in closed quarters that it is he who he wants as heir. When not on the battlefield, Maximus is a humble farmer with a wife and son, and claims not to know a thing about Rome and/or politics. Aurelius claims that his lack of political knowledge proves only that he has not been corrupted by Roman wealth, unlike his son.
When Commodus learns of his father's proposal to Maximus, he murders his father and then orders Maximus to be put to death. Maximus escapes his execution, and his wife and son suffer the fate that he was planned to receive. In the desert, a wounded Maximus is captured and sold as a slave to a man who plans barbaric gladiator fights in large stadiums. Because of his former stature in the army, he is quite a fighter, and becomes known as `The Spaniard'. He plans to use his new `power', and some help from the radiant Lucilla (Connie Nielsen), to help exact his revenge on her brother, Commodus.
`Gladiator' is full of intense, strategic scenes of gladiatorial battle, and beautiful, wide-angle cinematography. It is a slick action film, entertaining and often thrilling, but if Ridley Scott is aspiring to a sweeping, `Braveheart'-like epic, then his work is unsuccessful. `Gladiator's' plotline is the generic revenge tale, somewhere along the lines of `Hamlet' and `The Count of Monte Cristo'.
`Gladiator' is glorious on a technical level, but the emotional aspects of the film are not on par. Crowe's Maximus is a traditional hero, Phoenix's Commodus his traditional villain, and like most action films, `Gladiator' is traditionally predictable. Though the film has been blamed for some historical inaccuracies, the period detail of ancient Rome seems particularly genuine.
Ridley Scott is a master of the movie blockbuster, and his films are often revered by his legion of fans long after their original release. Despite a number of shortcomings, `Gladiator', a film magnificent in its scope, should prove to be no exception. It is a wonderful way to kick off a long summer.
Akiva Gottlieb<EMAIL_ADDRESS>http://pictureshow.8m.com
Do You Yahoo!? Send instant messages & get email alerts with Yahoo! Messenger. http://im.yahoo.com/
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


ASA
Classes Tracker
Fill out this form to be added to our
classes info page
and find other people taking the same classes as you!
Full Name:
*
Andrew Email:
*
Phone Number:
*
Year:
*
Freshman

Sophomore

Junior

Senior

Major/College:
*
Social Handles:
Where will you be for the semester?
Course 1 Number:
Course 2 Number:
Course 3 Number:
Course 4 Number:
Course 5 Number:
Course 6 Number:
*
= required