Test Project Overview¶
Contents
Setup¶
Initialization¶
To generate files for a new test suite, change into the desired directory and run:
wtt init
This will generate a new test package with template files and project directories.
(Optional) Setup Virtual Environment¶
If using virtualenv, initialize the virtual environment before installing the test package:
virtualenv venv
source ./venv/bin/activate
Test Package Installation¶
After initializing the test project, run the following command from the project root directory:
pip install -e .
Installing with the -e
flag will update the package automatically when
changes are made to the source code.
Configuration¶
After initializing a project, the URL of the site to be tested will need to be
configured. In <test_package>/config/site.py
, set the SITE_URL
and
BASE_URL
of the SiteConfig
class. You can add any other URLs you’ll need
as class variables as well.
Basic Command Line Usage¶
Usage:
<test_package> [-h] <command>
If no <command>
is specified, the run
command will be executed by
default.
Note: If the test package was not installed with pip
, run test packages
commands using python -m <test_package> <command>
.
For info on command line arguments, use the --help
(or -h
) argument:
<test_package> --help
Creating New Project Files¶
New tests and page objects can be generated using the new
command:
<test_package> new [<type>] [<module_name>] [<ClassName>] [-d <description>] [-f]
Where:
<type>
: The type of file to create (test
orpage
)<module_name>
: Filename to use for the new python module<ClassName>
: Name to use for the initial class<description>
: (Optional) Description for the initial class-f
: (Optional) Force overwrite if a file with the same name already exists
If no arguments are provided, a prompt will walk you through generating the new file. Alternatively, you can skip the prompts by using the arguments shown in the following sections.
Creating New Tests¶
New test modules can be generated using the new test
command:
<test_package> new test <module_name> <TestCaseClass>
Where <module_name>
is the filename for the new test and <TestCaseClass>
is the class name for the test case.
The --description
(or -d
) argument can be used to add a description for
the initial test case class:
<test_package> new test <module_name> <TestCaseClass> -d "Test case description"
If a test module with the same <module_name>
already exists, new test
will not overwrite it by default. The --force
(or -f
) argument can be
used to force overwrite existing files:
<test_package> new test <module_name> <TestCaseClass> --force
Creating New Page Objects¶
New page object modules can be generated using the new page
command:
<test_package> new page <module_name> <PageObjectClass>
Where <module_name>
is the filename for the new module and
<PageObjectClass>
is the class name for the page object.
The --description
(or -d
) argument can be used to add a description for
the initial page object class:
<test_package> new page <module_name> <PageObjectClass> -d "Page object description"
By default, the new class will be a generic BasePage
subclass. The
--prototype
(or -p
) argument can be used to specify a page object
prototype class to use as a parent class for the new page object:
<test_package> new page <module_name> <PageObjectClass> -p <prototype>
For a list of valid <prototype>
options, run <test_package> new page
--help
.
Page object prototypes support YAML file parsing to simplify the syntax of
representing elements. Whether YAML files or Python-only files are generated by
default is configured in <test_package>/config/projectfiles.py
by setting
the ENABLE_PAGE_OBJECT_YAML
variable of the ProjectFilesConfig
class.
The default setting can be overridden by using command line arguments. If
ENABLE_PAGE_OBJECT_YAML
is True
, the --no-yaml
(or -Y
) argument
can be used to only generate .py
files:
<test_package> new page <args> --no-yaml
If ENABLE_PAGE_OBJECT_YAML
is False
, the --yaml
(or -y
) argument
can be used to generate .py
and .yml
files for supported prototypes:
<test_package> new page <args> --yaml
If a page module with the same <module_name>
already exists, new page
will not overwrite it by default. The --force
(or -f
) argument can be
used to force overwrite existing files:
<test_package> new page <module_name> <PageObjectClass> --force
Running Tests¶
Running Specific Tests¶
To run all test cases in one or more modules, use the --module
(or -m
)
argument:
<test_package> --module <test_module> [<test_module> ...]
To skip all test cases in one or more modules, use the --skip-module
(or
-S
) argument:
<test_package> --skip-module <test_module> [<test_module> ...]
To run specific test case classes or methods, use the --test
(or -t
)
argument:
<test_package> --test <TestClass>[.<test_method>] [<TestClass>[.<test_method>] ...]
To skip certain test cases or methods, use the --skip
(or -s
) argument:
<test_package> --skip <TestClass>[.<test_method>] [<TestClass>[.<test_method>] ...]
The --test
and --skip
arguments both support wildcards (*
) in class
and method names.
These arguments can be used together. When combined, they are processed in the following order:
--skip-module
removes the specified modules from the set of tests
--module
reduces the set of tests to those in the specified modules
--test
reduces the set of tests to the specified classes and methods
--skip
removes the specified classes and methods from the set of tests
Using Specific Browsers¶
To do any of the above in specific browsers rather than running in all available
browsers, use the --browser
(or -b
) argument:
<test_package> <args> --browser <browser> [<browser ...]
For a list of options you can specify with --browser
, run <test_package>
--help
.
Using Headless Browsers¶
By default, tests run using the browser’s GUI. While it can be helpful to see what’s going on during test execution, loading and rendering the browser window can be resource-intensive and slows down performance during test execution.
To improve performance, tests can be run in headless browsers using the
--headless
(or -H
) argument:
<test_package> <args> --headless
Note: When using the --headless
argument, tests will only be run with
the following web drivers that support running in a headless environment:
Using BrowserStack¶
Test projects can be configured to run tests on BrowserStack. Once
BrowserStack support is enabled, tests can be run on BrowserStack using the
--browserstack
(or -B
) argument:
<test_package> <args> --browserstack
See the documentation on BrowserStack Support for more details and setup instructions.
Configuring Output¶
By default, detailed output is displayed when running tests. To reduce or
suppress output, use the --verbosity
(or -v
) argument:
<test_package> <args> --verbosity <level>
Where <level>
is one of the following:
0 - Final results only
1 - Final results and progress indicator
2 - Full output
Note: The default output level can be changed in
<test_package>/config/test.py
by setting the DEFAULT_VERBOSITY
attribute of the TestSuiteConfig
class.
List Available Tests¶
Basic Usage¶
To print a list of available test classes and methods:
<test_package> list
To include docstrings for each test class and method in output:
<test_package> list --verbose
Listing Specific Tests¶
To only list test classes from specific modules:
<test_package> list --module <test_module> [<test_module> ...]
To omit specific modules:
<test_package> list --skip-module <test_module> [<test_module> ...]
To only list specific test classes:
<test_package> list --test <TestClass> [<TestClass> ...]
To skip certain test classes in output:
<test_package> --skip <TestClass> [<TestClass> ...]
See Running Specific Tests for more info on these arguments.
Project Structure¶
wtt init
will create the following files and directories
inside the project directory:
<project-directory>/
├── README.rst
├── setup.py
└── <test_package>/
├── __main__.py
├── __init__.py
├── config/
│ ├── __init__.py
│ ├── browser.py
│ ├── browserstack.py
│ ├── projectfiles.py
│ ├── site.py
│ ├── test.py
│ └── webdriver.py
├── data.py
├── log/
├── pages/
│ └── __init__.py
├── screenshot/
└── tests/
└── __init__.py
This test structure is designed to be used with the Page Object Model. Interaction with the page should be handled by page objects to minimize the need to alter tests whenever the HTML is changed.
Test Project Root Contents¶
setup.py
: Python package setup file that allows the new test suite to be installed as a pip package.
Test Package Root Contents¶
__main__.py
: Required to run tests from the command line.__init__.py
: Empty init file so Python recognizes the directory as a package.data.py
: Module for storing static data for tests that must use specific values (e.g. emails, usernames, etc).
Test Package Directories¶
config/¶
Configurations used by test scripts for site URLs, web driver options, and the python unittest framework.
browser.py
: Configure which browsers to run tests in.browserstack.py
: Enable and configure testing with BrowserStack.projectfiles.py
: Configure defaults for generating project files with thenew
command.site.py
: Configure URLs used for testing.test.py
: Configure theunittest.TestRunner
class.webdriver.py
: Configure WebDrivers and log output directory.
pages/¶
Page object classes for pages and components. These classes should handle locating and interacting with elements on the page. See Creating New Page Objects for info on generating new page object modules.
screenshot/¶
Default output directory for screenshots taken during test execution. This can
be changed in config/webdriver.py
.
tests/¶
Test case modules. These use page objects to interact with elements and assert that the expected behavior occurs. See Creating New Tests for info on generating new test modules.


Non-linear 2D embedding algorithms can be run through Single-Cell Toolkit (SCTK) using both interactive shiny application and R console. For the interactive analysis, the toolkit offers a streamlined workflow to both compute the embedding and then visualize the results. For the console analysis, SCTK offers a generic function runDimReduce()
to compute the 2D embedding.
Methods available with the toolkit include tSNE and UMAP from Seurat [1][2][3][4] package, tSNE from Rtsne [5][6] package and UMAP from scater [7] package.
To view detailed instructions on how to use these methods, please select “Interactive Analysis”, from the tabs below, for the usage in Shiny application or “Console Analysis” for using these methods in R console:
In general, the UI offers options for selection of data items and choice of parameters on the left side, and a visualization panel on the right side of the interface.
Here we show how to generate 2D embedding with the generic function runDimReduce()
, together with the method to visualize and explore the results.
1. Compute 2D embedding
sce <- runDimReduce(inSCE = sce, method = "scaterUMAP", useReducedDim = "PCA", reducedDimName = "UMAP")
The generic function runDimReduce()
allows "scaterUMAP"
from scater, "rTSNE"
from Rtsne, "seuratUMAP"
and "seuratTSNE"
from Seurat as options of 2D embedding for method
argument. For detailed parameter description, please click on the function name to be redirected to its reference page.
2. Visualization
There are multiple functions that can create scatter plot using dimensions stored in reducedDims
slot of the SCE object.
# Make scatter plot without annotation
plotDimRed(sce, useReduction = "UMAP")
# Short-cut for embedding named as "UMAP"
plotUMAP(sce)
# Customizing scatter plot with more information from cell metadata (colData)
plotSCEDimReduceColData(sce, colorBy = "cluster", reducedDimName = "UMAP")
# Color scatter plot with feature expression
plotSCEDimReduceFeatures(sce, feature = "CD8A", reducedDimName = "UMAP")
library(singleCellTK)
sce <- importExampleData("pbmc3k")
sce <- runNormalization(sce, normalizationMethod = "LogNormalize", useAssay = "counts", outAssayName = "logcounts")
sce <- runFeatureSelection(sce, useAssay = "counts", method = "modelGeneVar")
sce <- setTopHVG(sce, method = "modelGeneVar", hvgNumber = 2000, featureSubsetName = "HVG")
sce <- runDimReduce(sce, method = "seuratPCA", useAssay = "logcounts",
scale = TRUE, useFeatureSubset = "HVG", reducedDimName = "PCA",
nComponents = 50)
# Run UMAP on the PCA reducedDim
sce <- runDimReduce(sce, method = "scaterUMAP", useReducedDim = "PCA",
reducedDimName = "UMAP")
# Plot UMAP
plotDimRed(sce, useReduction = "UMAP")
While the runDimReduce()
wrapper function can be used for all 2D embedding algorithms including tSNE and UMAP, and additionally for dimension reduction methods like PCA and ICA, separate functions are also available for all of the included methods. The following functions can be used for specific methods:
Running tSNE from Rtsne package:
sce <- runTSNE(inSCE = sce, useReducedDim = "PCA", reducedDimName = "TSNE")
Using the Seurat tSNE wrapper is recommended only in the Seurat Curated Workflow.
sce <- runSeuratFindHVG(inSCE = sce, useAssay = "seuratNormData")
sce <- runSeuratPCA(inSCE = sce, useAssay = "seuratNormData", scale = TRUE, reducedDimName = "seuratPCA")
sce <- runSeuratTSNE(inSCE = sce, useReduction = "pca", reducedDimName = "seuratTSNE")
Running UMAP from scater package:
sce <- runUMAP(inSCE = sce, useReducedDim = "PCA", reducedDimName = "UMAP")
Using the Seurat UMAP wrapper is recommended only in the Seurat Curated Workflow.
sce <- runSeuratFindHVG(inSCE = sce, useAssay = "seuratNormData")
sce <- runSeuratPCA(inSCE = sce, useAssay = "seuratNormData", scale = TRUE, reducedDimName = "seuratPCA")
sce <- runSeuratUMAP(inSCE = sce, useReduction = "pca", reducedDimName = "seuratUMAP")
[1] A. Butler, P. Hoffman, P. Smibert, E. Papalexi, and R. Satija, “Integrating single-cell transcriptomic data across different conditions, technologies, and species,” Nature Biotechnology, vol. 36, no. 5, pp. 411–420, Jun. 2018, doi: 10.1038/nbt.4096.
[2] T. Stuart et al., “Comprehensive Integration of Single-Cell Data,” Cell, vol. 177, no. 7, pp. 1888–1902.e21, Jun. 2019, doi: 10.1016/j.cell.2019.05.031.
[3] R. Satija, J. A. Farrell, D. Gennert, A. F. Schier, and A. Regev, “Spatial reconstruction of single-cell gene expression data,” Nature Biotechnology, vol. 33, pp. 495–502, 2015, doi: 10.1038/nbt.3192.
[4] Y. Hao et al., “Integrated analysis of multimodal single-cell data,” Cell, 2021, doi: 10.1016/j.cell.2021.04.048.
[5] L. J. P. van der Maaten, “Accelerating t-sne using tree-based algorithms,” Journal of Machine Learning Research, vol. 15, pp. 3221–3245, 2014.
[6] L. J. P. van der Maaten and G. E. Hinton, “Visualizing high-dimensional data using t-sne,” Journal of Machine Learning Research, vol. 9, pp. 2579–2605, 2008.
[7] D. J. McCarthy, K. R. Campbell, A. T. L. Lun, and Q. F. Wills, “Scater: Pre-processing, quality control, normalization and visualization of single-cell RNA-seq data in R,” Bioinformatics, vol. 33, no. 8, pp. 1179–1186, Apr. 2017, doi: 10.1093/bioinformatics/btw777.


v{{ version }}
Developed and maintained by Shane Bell
Licensed under the Apache License v2.0
Available from the Chrome Web Store
Source code available at GitHub
Report an issue


schlib.cr
is a library with selected useful classes.
Installation
Add to your shard.yml
dependencies:
schlib.cr:
github: tpei/schlib.cr
branch: master
and then install the library into your project with
$ crystal deps
Usage
This shard consists of several helper classes. Require them and use them.
Cache
Cache helps to cache long running computations or I/O. It acts similar to Rails' cache and persists to a file. It is only possible to cache simple data structures like Array, String, Integer, etc... All cached data must work with JSON::Type
require "schlib/cache"
def super_long_running_method
sleep 10
"wow, so long!"
end
def complicated_stuff
c = Schlib::Cache.new("/tmp/my_cache_file.tmp")
c.cache(:precise_pi) do
super_long_running_method
end
end
puts complicated_stuff # first call takes long time
puts complicated_stuff # successive calls are fast
Command
Command is a wrapper around crystal's backticks and enables logging and raising exceptions on bad exitcodes.
require "logger"
require "schlib/command"
Schlib::Command.new.run("wtf", raise_errors: true)
# COMMAND FAILED! (ScriptError)
# 0x101806195: *CallStack::unwind:Array(Pointer(Void)) at ??
# 0x101806131: *CallStack#initialize:Array(Pointer(Void)) at ??
# 0x101806108: *CallStack::new:CallStack at ??
# 0x101805211: *raise<ScriptError>:NoReturn at ??
# 0x101872b06: *Schlib::Command#run<String, Bool>:String at ??
# 0x1017f2c72: __crystal_main at ??
# 0x101802b58: main at ??
logger = Logger.new(STDOUT)
Schlib::Command.new(logger).run "wtf????"
# --: wtf????: command not found
Spinner
Have a long running command? Use spinner to entertain.
require "schlib/spinner"
Schlib::Spinner.wait_for do
sleep 2
"well-rested"
end
# Loading ▇ ... done
#
# => "well-rested"
Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/tpei/schlib.cr. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.
License
The gem is available as open source under the terms of the MIT License.


Do you prefer cats or dogs?
Dogs:
Cats:
What is your favorite color?
Red
Orange
Yellow
Text area
Go!


This syllabus is subject to change based on specific class needs, especially the schedule. Significant deviations will be discussed in class. Individual exceptions to the policies and schedule are granted only in cases of true emergency. Please make arrangements with me if an emergency arises.
The purpose of this course is for students to gain practical experience with data science projects: planning, implementing, and getting to know the common tools. Students will work in small groups to develop three different data science applications. A central component of each application will be the collection, cleaning, and structuring of data sets. Each application will expose them to different kinds and sources of data such as relational database and web-based APIs. Groups will maintain and develop their projects using GitHub or GitLab and Git version control software. Students will also engage in peer-review of the work of their team members and the other development teams in the course. Upon completing the course students will know how to formulate basic data science problem statements, construct appropriate data sets to explore their problems, carry out the appropriate modeling and analysis for their problem, and present the findings. Where students’ prior experience covered these things in pieces, this course will have you work this process from start to end.
Books and reference materials will be based on projects assigned but are likely to be a combination of online resources and instructor provided handouts. As part of their projects students will learn to seek out and work with reference material for programming tools and languages in addition to textbooks.
Every project will use git
and GitHub for collaboration and version
control. If you are familiar with the command line you may prefer to
simply use the git
command; otherwise you should install a graphical
client. You will need to download
git
itself. Although it comes with a
basic graphical client, you may prefer to install a third-party
client; GitHub Desktop will suit our
needs, although you may choose whichever you wish.
Zoom classes: If the instructor’s video is turned on, yours should be, too. Any computer, tablet, or phone usage should be directly related to the course, e.g., Zoom or Socrative. Anything else is rude and distracting to others. Inappropriate use of devices, or not turning your video on, will result in a low participation grade. To fully participate in class, you should plan to attend each Zoom session on a laptop or desktop computer, NOT a tablet or phone. This will allow you to take part in any live-coding exercises with the rest of the class. Please let the instructor know ahead of time if this is not possible for any particular class meeting.
Late assignments: In general, late assignments will not be accepted. Exceptions may be made only for situations beyond your control. If you feel your reason is justified, schedule a meeting with the instructor to plead your case.
Academic dishonesty: Monmouth College’s official policy on academic dishonesty can be found here. You are responsible for reading and complying with that policy.
In this course, any violation of the academic honesty policy will have varying consequences depending on the severity of the infraction as judged by the instructor. Minimally, a violation will result in an “F” or 0 points on the assignment in question. Additionally, the student’s course grade may be lowered by one letter grade. In severe cases, the student will be assigned a course grade of “F” and dismissed from the class. All cases of academic dishonesty must be reported to the Associate Dean who may decide to recommend further action to the Admissions and Academic Status Committee, including suspension or dismissal. It is assumed that students will educate themselves regarding what is considered to be academic dishonesty, so excuses or claims of ignorance will not mitigate the consequences of any violations
General expectations: In short, I expect you to be respectful of others and take responsibility for your own learning. You are here to learn, so work hard and be professional.
Just attending class is not sufficient to truly learn the material. Read the text, use the resources available at Monmouth College, and go beyond the material.
If you miss class, you are responsible for everything covered on that day. College is, in some sense, your job. Take pride in creating quality work. Staple your assignments, label problems, and present your answers neatly and orderly.
Your job is to convince me that you have learned the material – show your work! Even if you do not know a particular answer, guide me through your thought process.
The weekly workload for this course will vary by student and by week but should be about 12-13 hours per week on average. The following table provides a rough estimate of the distribution of time over different course components for a 16 week semester, as well as detailing the type, amount, and relative value of all assignments.
| Category | Amount | Final Grade Weight | Time/Week (Hours) |
|---|---|---|---|
| Class Meetings | 42 | 15% (Participation) | 2.5 |
| Peer-Reviews | 6 | - | 0.5 |
| Presentations | 6 | 35% | 2 |
| Projects | 3 | 45% | 7-8 |
| Final Self-Evaluation | 1 | 5% | - |
| Total | 100% | 12-13 |
You can expect to spend most class meetings checking in with your current development team and the course instructor. Accompanying each project there will be two presentations: one checkpoint presentation and one final presentation with an application demo. These presentations will take place during scheduled class times as well. You will carry out peer-reviews and self-evaluations after each presentation.
Your individual project and presentation grades will be determined based on the overall group effort as well as your individual contributions to the application. Individual contributions will be assessed throughthe project tracking features on GitHub/GitLab, through feedback provided by peer-reviews done about your work, and through your own self-evaluations. It will not necessarily be the case that each member of a group receive the same grade on a project or presentation. Participation grades will be determined by class attendance, contributions to discussions on GitHub/GitLab, and through the quality of your peer-reviews submitted about other members of the class. During the final exam period you will be required to carry out one last self-evaluation and self-reflection about the work you did throughout the course of the semester.
Your final grade is based on a weighted average of particular assignment categories. You can estimate your current grade based on your scores and these weights. You may always visit the instructor outside of class to discuss your current standing. Assignments and final grades use a standard grading scale shown below and will not be curved except in rare cases when deemed necessary by the instructor.
This courses uses a standard grading scale. Assignments and final grades will not be curved except in rare cases when its deemed necessary by the instructor. Percentage grades translate to letter grades as follows:
| Score | Grade |
|---|---|
| 94–100 | A |
| 90–93 | A- |
| 88–89 | B+ |
| 82–87 | B |
| 80–81 | B- |
| 78–79 | C+ |
| 72–77 | C |
| 70–71 | C- |
| 68–69 | D+ |
| 62–67 | D |
| 60–61 | D- |
| 0–59 | F |
You are always welcome to challenge a grade that you feel is unfair or calculated incorrectly. Mistakes made in your favor will never be corrected to lower your grade. Mistakes made not in your favor will be corrected. Basically, after the initial grading your score can only go up as the result of a challenge*.
You are always welcome to challenge a grade that you feel is unfair or calculated incorrectly. Mistakes made in your favor will never be corrected to lower your grade. Mistakes made not in your favor will be corrected. Basically, after the initial grading your score can only go up as the result of a challenge.
The following tentative calendar should give you a feel for how work is distributed throughout the semester. Assignments and events are listed in the week they are due or when they occur. This calendar is subject to change based on the circumstances of the course.
| Date | Topic |
|---|---|
| Week 1: 01/25 – 01/29 | Logistics, Intro, Git, Github (1, 2, 3, 4) |
| Week 2: 02/01 – 02/05 | Project 1, Files |
| Week 3: 02/08 – 02/12 | Project 1 Checkpoint (Thu), Checkpoint Review Form |
| Week 4: 02/15 – 02/19 | Checkpoint Reviews Due (Tue) |
| Week 5: 02/22 – 02/26 | Project 1 Final: Presentation (Thu), Report (Fri), Final Review Form |
| Week 6: 03/01 – 03/05 | Project 1 Reviews Due (Tue), Project 2 |
| Week 7: 03/08 – 03/12 | |
| Week 8: 03/15 – 03/19 | Project 2 Checkpoint (Thu), Checkpoint Review Form |
| Week 9: 03/22 – 03/26 | Checkpoint Reviews Due (Tue) |
| Week 10: 03/29 – 04/01 | Project 2 Final (Thu), Final Review Form |
| (Fri 04/02 – Easter Break) | |
| Week 11: 04/05 – 04/09 | Project 2 Reviews Due (Tue), Project 3 |
| Week 12: 04/12 – 04/16 | |
| Week 13: 04/19 – 04/23 | Project 3 Checkpoint (Thu), |
| Week 14: 04/26 – 04/30 | Checkpoint Review Due (Tue) |
| Week 15: 05/03 – 05/05 | |
| (Fri 05/07 – Finals Begin) | |
| Wed, 05/12 8:00 AM | Project 3 Final Presentation, Final Review Form, Self-Evaluation |
Mental Health and Counseling Services: Monmouth College provides cost-free, professional mental health counseling to support you and to help you manage challenges that may impact your personal and academic success. The Counseling Center is located in the upper level of Poling Hall, offices 204 and 216, and the hours are Monday-Friday, 8:30 AM – 5:00 PM. To request a confidential appointment on-line, click here or email the center, Cindy Beadles or Tom Caudill.
Student Success and Accessibility Services offers FREE resources to assist Monmouth College students with their academic success. Programs include supplemental instruction for difficult classes, drop-in and appointment tutoring, and individual academic coaching. The office is here to help students excel academically, since everyone can work toward better grades, practice stronger study skills, and mange their time better.
Accessibility Services: If you have a disability or had academic accommodations in high school or another college, you may be eligible for academic accommodations at Monmouth College under the Americans with Disabilities Act (ADA). Monmouth College is committed to equal educational access. To discuss any of the services offered, please call or visit Student Success and Accessibility Services. SSAS is located in the ACE space on the first floor of Hewes Library, opposite Einstein Bros. Bagels. They can be reached at<PHONE_NUMBER> or via email at<EMAIL_ADDRESS>Hewes Library: Librarians can help you find appropriate sources for a speech, research paper, or project. #JustAsk!
Library Hours: library.monmouthcollege.edu/home/hours
How to contact a Hewes librarian:


Stephanie Sugandi Gan
Director
Chat Me
Enter Room
PT. Digital Netwerk Venture Indonesia
A Leapfrog Creative Technology Company 10 years experience in digital industry, we believe the keys of success in business are able to FORECAST & ADAPT.
W :
https://www.the-netwerk.com
P : (1234) 12345678
T :<PHONE_NUMBER>90 /<PHONE_NUMBER>21
About Me
Name
:
Stephanie Sugandi Gan
Title
:
Director
Email
:
<EMAIL_ADDRESS>Phone
:
081234567890
Office
HQ/Production Office
Pandanwangi Green Park B-1 Jl. Simpang LA. Sucipto Malang, Indonesia 65126
Operational Office
Jl. Hayam Wuruk No 3HH Kebon Kelapa, Gambir Jakarta Pusat, Indonesia 10120
or Share With Link :
gg.gg/stephaniegan
Save Contact
Visit Web
Schedule a Meeting
Schedule a Meeting
Topic
Date
Time Zone : Jakarta (GMT+7)
To
Type Meeting
Offline
Online
Description
Add Description...
Cancel
Schedule
Log In
Email
Password
Log In
Forgot Password?
Click Here


EBS Order Management Addin allows you to manage sales orders in Oracle E-Business Suite (EBS). It allows the Oracle Service Cloud (OSvC) user to perform following operations in EBS.
EBS PL/SQL
web services that need to be deployed for the Addin are listed below. Please read the accompanying documentation or request your EBS administrator to perform this initial setup.
| Name | Internal Name | Application Code | Responsibility Key |
|---|---|---|---|
| Process Order API | OE_ORDER_PUB | ONT | ORDER_MGMT_SUPER_USER |
| Sales Order Services | OE_INBOUND_INT | ONT | ORDER_MGMT_SUPER_USER |
| Custom API to get orders by incident | OE_ORDER_CUST | ONT | ORDER_MGMT_SUPER_USER |
Configure the EBS web service endpoints in OSvC. A sample configuration of the EBS endpoints used in the Addin is shown below.
"order": {
"read": {
"service_name": "GET_ORDER",
"soap_action": "http://ebs.example.com:8000/webservices/SOAProvider/plsql/oe_order_pub/",
"relative_path": "webservices/SOAProvider/plsql/oe_order_pub/"
}
},
"order_list": {
"read": {
"service_name": "GET_ORDERS_BY_CONTACT",
"soap_action": "http://ebs.example.com:8000/webservices/SOAProvider/plsql/oe_order_cust/",
"relative_path": "webservices/SOAProvider/plsql/oe_order_cust/"
}
},
"order_save": {
"read": {
"service_name": "PROCESS_ORDER",
"soap_action": "http://ebs.example.com:8000/webservices/SOAProvider/plsql/oe_inbound_int/",
"relative_path": "webservices/SOAProvider/plsql/oe_inbound_int/"
}
}
Accelerator.EBS.OrderManagementAddin
to OSvC using agent desktop.Design
> Size
> Enable Auto Sizing
.Sales
> Product Catalog
. EBS Products must be added to the folder called EBS Products
. Addin fetches products under this folder using RightNow Object Query Language (ROQL
).This addin uses the fields mentioned below to map EBS to OSvC. You will find these mappings useful to create a report or to add an EBS product to OSvC.
| EBS GET_ORDER | OSvC | |
|---|---|---|
| X_HEADER_REC.ATTRIBUTE15 | Incident.ID | |
| X_LINE_TBL.INVENTORY_ITEM_ID | SalesProduct.ID | |
| X_LINE_TBL.UNIT_SELLING_PRICE | SalesProduct.Schedules.SalesProductScheduleList.Price | |
| X_LINE_VAL_TBL.INVENTORY_ITEM_DESC | SalesProduct.Name |
ROQL
is limited to 1000.Suggested steps for troubleshooting in case you run into a problem.
Get sales orders for an OSvC incident, from the EBS database, using a query similar to the one given below. You may also wrap a similar query inside a PL/SQL
API and expose it as a web service.
SELECT HEADER_ID,
SOLD_TO_CONTACT_ID,
CREATION_DATE,
LAST_UPDATE_DATE,
ORDER_NUMBER,
FLOW_STATUS_CODE,
ORDER_CATEGORY_CODE,
ORDER_TYPE_ID,
ORIG_SYS_DOCUMENT_REF,
TRANSACTIONAL_CURR_CODE,
CANCELLED_FLAG,
OPEN_FLAG,
BOOKED_FLAG,
VERSION_NUMBER,
ATTRIBUTE15,
ATTRIBUTE16
FROM oe_order_headers_all
WHERE ATTRIBUTE15 = :incident_id
ORDER BY creation_date DESC;
If you are getting products from the OSvC sales product catalog, test using the ROQL
given below.
SELECT sp.PartNumber, sp.Name, sp.Schedules.SalesProductScheduleList.Price.Value
FROM SalesProduct sp
WHERE sp.Folder.Name = 'EBS Products'
AND sp.Schedules.SalesProductScheduleList.Price.Currency.Name = 'USD'
AND sp.Schedules.SalesProductScheduleList.Price.Value > 0
LIMIT 1000
ebs_default_sr_owner_id
is configured correctly.After you have collected all the information in the previous steps, ask for support and have your EBS and OSvC administrators on the call.


Madeleine McCann family's friend slams ex-detective over 'spiteful' search remark
Former officer John Coxon took aim at Scotland Yard's efforts to find missing Maddie - but his comments have been branded "ludicrous"
by Jerry LawtonA family friend of the McCanns has slammed an ex-detective over his 'spiteful' remark about the search for missing Madeleine.
Retired vice squad officer John Coxon demanded an end to efforts to find the missing girl.
And he said Scotland Yard’s £12million probe Operation Grange is a “disgraceful waste of resources,” reports the Daily Star.
A source close to the couple has slammed Mr Coxon and fumed: “The opinion of a retired officer who has not even worked on the case is quite frankly ludicrous.
“It is insensitive and spiteful towards Madeleine’s family and the detectives who are trying their utmost to find out what happened.”
Madeleine vanished from her family’s Portuguese holiday apartment in 2007 when she was just three years old.
Mr Coxon has called on the Independent Office Of Police Conduct to shut down the inquiry, branding it “the biggest scandal in the history of the Met”.
But the body has confirmed it will not investigate his gripe. They say his complaint is invalid in law because he has not been personally affected by the case.
Mr Coxon has not responded to requests for comment on the decision not to pursue his complaint.
Tonight, doctor parents Kate and Gerry, who believe their daughter was abducted and continue to hope she may still be alive, thanked police for continuing their hunt for Madeleine.
A spokesman for the McCanns said tonight: “Kate and Gerry have been advised not to talk about the inquiry while it is still ongoing and they remain extremely grateful to the Met Police.”


--- title: Yes!Delft Co-Lab author: Daniel Antal date: '2020-03-14' slug: yes-delft-co-lab categories: [] tags: - team-building subtitle: '' summary: '' authors: [] lastmod: '2020-03-14T20:55:37+01:00' featured: yes draft: no image: caption: '' focal_point: '' preview_only: no projects: [] ---
I participated on the Yes!Delft Co-Lab in Delft.


Select a bitcoin address to receive funds in the event of a dispute
Select an email address to receive your private key
We have sent your escrow private key to you via e-mail, please confirm that you have recieved this before proceeding.
Have you recieved your private key via e-mail?


How Sammy Went to Coral-Land
by Emily Paret Atwater
Introduction
Additional Information
- Year Published: 1920
- Language: English
- Country of Origin: United States of America
- Source: Atwater, E.P. (1920). How Sammy Went to Coral-Land. Philadelphia: George W. Jacobs and Co.
-
Readability:
- Flesch–Kincaid Level: 9.0
- Word Count: 521
- Genre: Adventure
- Keywords: imagination
- ✎ Cite This
Downloads
“Well, children,” said grandma, “which shall it be, fairy stories, stories about giants, or ‘really truly,’ stories?”
They had been spending a month at the seashore, grandma, Bob and Eleanor. Little Bob had been very ill in the spring, and when hot weather came the doctor ordered sea air and sea bathing to bring back color to the pale cheeks, and strength to the thin little body.
But Bob’s father was a poor country parson and there seemed no way to fill the doctor’s prescription. At this juncture grandma, like the charming fairy godmother that she was, appeared on the scene. She knew a quiet spot (one of the few still in existence), where there were no big hotels, no board-walks, and no merry-go-rounds. It was the very place where she wanted to go to get rid of her rheumatism; Bob and Eleanor should go with her, and their father and mother could follow later when the parson’s vacation came.
It took but a short time to carry out this delightful plan, and at the opening of my story the children had already been a week at the seashore. Such fun as they had been having bathing, digging in the sand, gathering shells and seaweed, or sitting quietly with grandma under the big umbrella, watching the waves break and roll up on the shore! And after supper there was always that pleasant half hour, on the little balcony overlooking the ocean, when grandma told her bedtime stories.
 The little folks had been begging for their usual treat, for grandma’s stories were delightful, and her fund of knowledge (to the children), quite limitless.
“I’m getting too old for fairy stories,” said Eleanor, who was eleven and had advanced ideas. “Only real little children believe in goblins and giants, and I’m in the third reader now.”
“I like ‘em,” said dreamy, nine-year old Bob, “fairies and giants can always do things that just ordinary people can’t. Please do tell us some fairy stories, grandma.”
“No, true stories,” insisted Eleanor.
“How would it do to make a compromise?” suggested grandma. “You were asking me some questions yesterday about the shells, seaweed and all the fascinating things found on the shore. Suppose I tell you a story about all the wonderful creatures that live in the ocean? The part of it that tells how they live and grow, and get their food will be all true, and I think Eleanor will find it more marvelous than the make-believe part, which will tell about the adventures, and the conversations that our hero had with the strange creatures that he met with in his wanderings.”
This proposition was agreeable; the children settled themselves comfortably to listen, and grandma, with her eyes on a passing sail, began—


Plugin Information |
|---|
View HPE Network Virtualization on the plugin site for more information. |
This plugin allows HPE Network Virtualization to run tests under various network conditions.
Summary
HPE Network Virtualization (NV) helps you to understand how networks affect your application's performance, and what you can do to optimize client and server performance in your application.
Do your customers complain that your application works slowly? Are there timeout exceptions? Has your application ever failed when moved to production, even though the application worked perfectly when tested under lab conditions? Does your application suffer from non-reproducible issues?
HPE Network Virtualization plugin enables you to impose network impairments and constraints on your testing environment, to improve the accuracy of your application testing. You can:
- Emulate real-world network conditions, including bandwidth, latency, and packet loss.
- Run tests under multiple network conditions.
- Configure SLA's for your tests. The plugin can fail the tests that break these SLA's. By integrating a specific job into the plugin, and then running a selected set of tests with your CI/CD process, you can make sure that your main flow’s response time remains acceptable under various network conditions.
Note that currently this plugin supports tests in JUnit format only.
For further information about HPE Network Virtualization, click here.
Requirements
- An installation of HPE Network Virtualization version 9.10 or newer.
- Jenkins version 1.625.3 or newer.
- JUnit plugin version 1.10 or newer.
Configuration
Global Settings
In the Configure System page, this plugin provides the following configuration options:
NV Test Manager Hosts
Lets you specify one or more NV Test Manager hosts that the plugin can use. You must specify at least one NV Test Manager host. These hosts will be available for selection when you configure a job. For each NV Test Manager host, you must provide:
- A logical name for the host.
- The host’s connection details.
- Sign-in credentials for the host.
In addition, you can configure a proxy port. This is required only if NV Test Manager is configured to serve as a proxy server. You can read more about proxy settings in the HPE Network Virtualization documentation.
Custom Network Profiles
In order to emulate specific network conditions, you must provide HPE Network Virtualization with a network profile. A network profile is a set of parameters that define network impairments and conditions. When your tests run, these network condition are applied. You can read more about network profiles in the HPE Network Virtualization documentation. The HPE Network Virtualization plugin is installed with several predefined network profiles. In addition, you can configure your own “custom” network profiles. For each custom network profile, you must provide the network profile name and the parameters that define the network conditions. These custom network profiles, along with the predefined network profiles, will be available for selection when you configure a job.
Jobs
General
Create any job where the plugin can be added as a build step.
The HPE Network Virtualization plugin allows you to run your tests under one or more sets of network conditions, by selecting one or more network profiles. At the beginning of the job execution, the plugin creates a new test in the selected NV Test Manager. For each network profile, the plugin creates a separate transaction, and adds it to the test. Therefore, each test you configure will run the same number of times as the number of network profiles you selected for the test. This enables you to test several application flows under various network conditions in a single job execution.
You can specify a “thresholds file” for any test. A thresholds file is a simple text file. It contains SLA's (duration, in seconds) for each test you run. These SLA’s determine the status of each test run, according to the test’s network performance. At the end of each network profile cycle, the plugin checks the JUnit test’s results XML file. For each test that ended successfully, the plugin checks the test’s duration. If the duration is greater than the SLA defined in the thresholds file for that test, the plugin marks the test as failed and adds a message to the results XML file. You can bypass this functionality by either not specifying a thresholds file, or by specifying a file with a large value.
Note that the duration you specify as the threshold should be relative to the durations that are recorded in the JUnit results XML file – these values typically include a system overhead.
Setup
NV Test Manager
Select one of the NV Test Managers configured in the global settings. This host will apply the network conditions you specify, and collect the relevant network data.
Proxy Configuration
Select this option if NV Test Manager should be connected as a proxy. There are two scenarios that require NV Test Manager to be connected as a proxy:
- NV Test Manager is not installed on the same host where the tests are run.
- The traffic is secured.
If neither of these conditions exist, leave this option unselected.
After you select to use the NV Test Manager host as a proxy, you must specify the Environment Variable property. The plugin will set an environment variable using the name you provide, together with the proxy details, host IP:port. For example, in our case, <IP_ADDRESS>:8888. You must read this environment variable into your tests and configure the proxy accordingly. This will enable the network traffic to go through NV Test Manager, and enable NV Test Manager to apply the required network conditions.
Test Results Manipulation
Specify the location of the results XML file, and the name and location of the thresholds file. This enables the plugin to manipulate the results XML files.
Network Profiles
Select one or more network profiles from the lists. The lists contain both the predefined network profiles and the custom profiles defined in Global Settings > Custom Network Profiles. If no network profile is selected, the tests will run with HPE Network Virtualization imposing no network conditions.
Steps to Run
Define how to run the selected tests. You can run one or more steps. The only requirement is that the test results be in JUnit format. Other than that, you can select any steps that you want. In the example below, Maven step is used to run the selected tests by running a specific test suite.
Advanced Settings
Configure Include Client IPs and Exclude Server IPs. The flow's network impairments and constraints are applied to network traffic between the specified client and server IP addresses. Both the client IPs and the server IPs must be "included" in order for the network impairments and constraints to be applied. Currently, only IPv4 IP addresses are supported. You can read more about Setting Client and Server IP Ranges in the HPE Network Virtualization documentation.
By default, the server “Include IPs” list contains the entire IPv4 address range, thereby including all traffic. You must manually exclude all the servers for which you do not want traffic to be affected. In addition, all the IPv4 of the host machine where the tests run are included in the client IPs list and excluded in the server IPs list.
Each list can include single IP addresses and/or IP ranges. Separate multiple IPs using a semi-colon ';'. Define an IP range using the minus sign '-', for example, <IP_ADDRESS>-<IP_ADDRESS>.
How it Works
The core of the plugin is the network profiles you select and the tests you configure to run. If no network profiles are selected, HPE Network Virtualization will not intervene in the tests invocation and will not change the network conditions.
The main flow is as follows:
- In case a proxy was set, set an environment variable where the name is the name configured in Proxy Configuration and the value is <IP:proxy port> taken from the selected NV Test Manager configured in the Global Settings > NV Test Manager Hosts.
- Create and start a new test. The name of the test should be in the form <job name>_<build number>_test*.
- Update the test with the first selected network profile.
- Create a new transaction and add it to the test.
- Do the following until all the network profiles are run:
- Run all the steps defined in Steps to Run.
- Process the test results based on Test Results Manipulation. For each successful test, change its name by adding the profile name as a suffix. If the duration of the test is greater than the threshold defined in the Thresholds file, the plugin fails the test and adds an appropriate message. The plugin updates the results XML file with the new results.
- Use the next network profile to change the network conditions.
- When all the network profiles have been used, the plugin will stop the network emulation.
Attachments:
custom profile.png (image/png)
nv host.png (image/png)
nv proxy.png (image/png)
nv select.png (image/png)
nv proxy.png (image/png)
profile select.png (image/png)
test config.png (image/png)
test result.png (image/png)
nv select.png (image/png)
nv select.png (image/png)
nv select.png (image/png)
advanced.png (image/png)
advanced.png (image/png)


GFR PES Admins ONLY!
Select sheets for emails
Select all
Select required columns
Select all
Email body (to recipient)
"Hello <recipient>,
Thank you,
PES Admins"
placeholder warning
placeholder confirm
Select email data to preview
Data preview


JS Solutions Staff Orientation Videos
Introduction
Orientation
Using JS Solution Portal and other useful resources
How to use GitHib
Back to Portal


Plugin Information |
|---|
View Bitbucket Server Notifier on the plugin site for more information. |
Overview
This plugin notifies an Atlassian Bitbucket Server (formerly known as Stash) instance of Jenkins builds in progress and of their results.
The build results will show up in the commit or pull request list in Bitbucket and provide immediate and easy to scan feedback about a commit.
It is possible to navigate from build result information in Bitbucket directly to the build in question.
The plugin can be configured on a per-job basis, globally for all jobs or both to minimize the configuration overhead.
Usage
A detailed description can be found in the plugin's readme.


Find the future fast by automatically scanning Sources
My Sources
@Twitter users, #Tags, RSS feeds and search terms
Search Forecasts
Search the entire database of Forecasts
Challenges
This forecast is created by our robot (Athena) from latest analyzed daily Indicators
My Forecasts
Discover emerging change
View by tag
View by sector


{% extends "base_generic.html" %} {% block title %}
Number of franchise entries: {{ mov_franchise.num_of_entries_in_franchise }}
No available horror film franchises


| Field Summary | ||
|---|---|---|
const Number | RECT | |
| Represents the rectangle shape. | ||
const Number | ROUND_RECT | |
| Represents the round rectangle shape. | ||
const Number | ELLIPSE | |
| Represents the ellips shape. | ||
const Number | RIGHT_ARROW_CALLOUT | |
| Represents the right arrow callout shape. | ||
const Number | DOWN_ARROW_CALLOUT | |
| Represents the down arrow callout shape. | ||
const Number | LEFT_ARROW_CALLOUT | |
| Represents the left arrow callout shape. | ||
const Number | UP_ARROW_CALLOUT | |
| Represents the up arrow callout shape. | ||
const Number | WEDGE_RECT_CALLOUT | |
| Represents the wedge rectangle callout shape. | ||
const Number | WEDGE_ROUND_RECT_CALLOUT | |
| Represents the wedge round rectangle callout shape. | ||
const Number | WEDGE_ELLIPSE_CALLOUT | |
| Represents the wedge ellipse callout shape. | ||
const Number | LINE_CALLOUT | |
| Represents the line callout shape. | ||
const Number | BENT_LINE_CALLOUT | |
| Represents the bent line callout shape. | ||
const Number | LINE_WITH_ACCENT_BAR_CALLOUT | |
| Represents the line with accent bar callout shape. | ||
const Number | BENT_LINE_WITH_ACCENT_BAR_CALLOUT | |
| Represents the bent line with accent bar callout shape. |
| Field Detail |
|---|
RECT | |
const Number RECT |
ROUND_RECT | |
const Number ROUND_RECT |
ELLIPSE | |
const Number ELLIPSE |
RIGHT_ARROW_CALLOUT | |
const Number RIGHT_ARROW_CALLOUT |
DOWN_ARROW_CALLOUT | |
const Number DOWN_ARROW_CALLOUT |
LEFT_ARROW_CALLOUT | |
const Number LEFT_ARROW_CALLOUT |
UP_ARROW_CALLOUT | |
const Number UP_ARROW_CALLOUT |
WEDGE_RECT_CALLOUT | |
const Number WEDGE_RECT_CALLOUT |
WEDGE_ROUND_RECT_CALLOUT | |
const Number WEDGE_ROUND_RECT_CALLOUT |
WEDGE_ELLIPSE_CALLOUT | |
const Number WEDGE_ELLIPSE_CALLOUT |
LINE_CALLOUT | |
const Number LINE_CALLOUT |
BENT_LINE_CALLOUT | |
const Number BENT_LINE_CALLOUT |
LINE_WITH_ACCENT_BAR_CALLOUT | |
const Number LINE_WITH_ACCENT_BAR_CALLOUT |
BENT_LINE_WITH_ACCENT_BAR_CALLOUT | |
const Number BENT_LINE_WITH_ACCENT_BAR_CALLOUT |


001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019package org.apache.shiro.authz.annotation; 020 021import java.lang.annotation.Documented; 022import java.lang.annotation.ElementType; 023import java.lang.annotation.Retention; 024import java.lang.annotation.RetentionPolicy; 025import java.lang.annotation.Target; 026 027/** 028 * Requires the currently executing {@link org.apache.shiro.subject.Subject Subject} to have all of the 029 * specified roles. If they do not have the role(s), the method will not be executed and 030 * an {@link org.apache.shiro.authz.AuthorizationException AuthorizationException} is thrown. 031 *
 032 * For example, 033 *
 034 * @RequiresRoles("aRoleName");
 035 * void someMethod(); 036 *
 037 * means <tt>someMethod()</tt> could only be executed by subjects who have been assigned the 038 * 'aRoleName' role. 039 * 040 *
*Usage Note*: Be careful using this annotation if your application has a dynamic 041 * security model where roles can be added and deleted at runtime. If your application allowed the 042 * annotated role to be deleted during runtime, the method would not be able to 043 * be executed by anyone (at least until a new role with the same name was created again). 044 * 045 *
If you require such dynamic functionality, only the 046 * {@link RequiresPermissions RequiresPermissions} annotation makes sense - Permission 047 * types will not change during runtime for an application since permissions directly correspond to how 048 * the application's functionality is programmed (that is, they reflect the application's functionality only, not 049 * who is executing the the functionality). 050 * 051 * @see org.apache.shiro.subject.Subject#hasRole(String) 052 * @since 0.1 053 */ 054@Target({ElementType.TYPE, ElementType.METHOD}) 055@Retention(RetentionPolicy.RUNTIME) 056@Documented 057public @interface RequiresRoles { 058 059 /** 060 * A single String role name or multiple comma-delimited role names required in order for the method 061 * invocation to be allowed. 062 */ 063 String[] value(); 064 065 /** 066 * The logical operation for the permission check in case multiple roles are specified. AND is the default 067 * @since 1.1.0 068 */ 069 Logical logical() default Logical.AND; 070}


Oops ... your browser doesn't support the HTML5 canvas element
Increase Theta
Decrease Theta
Increase Phi
Decrease Phi
Increase Subdivisions
Decrease Subdivisions


<script src="RGraph.common.core.js"></script> <script src="RGraph.hbar.js"></script>Put this where you want the chart to show up:
<canvas id="cvs" width="600" height="550">[No canvas support]</canvas>This is the code that generates the chart - it should be placed AFTER the canvas tag(s):


In this project we will be making an animated face that will move its mouth while the Raspberry Pi is speaking text. This will make it look like the face is actually speaking the words.
We first create sprite variable for both when the face's mouth is open and when its
closed by using led_matrix.LEDSprite()
followed by the location of the .spr files
have been made.
Then just has before in easy we use speaker.say()
to
start speaking, however this time we wait wait=False
because we want the program
to continue executing the next lines of code while the speaker is playing the speech.
Finally, we create a while
loop that will continuously loop until the speech that we just started
playing has finished playing. This loop will continuously open and close the mouth while the speech is playing
by displaying the open and closed mouth sprites one after the other. (Similar to
scrolling text medium)
Try using longer and shorter text.
time.sleep(.1)
.


| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Chapter 31. libpq - C Library | Next |
The PQexec
function is adequate for submitting
commands in normal, synchronous applications. It has a couple of
deficiencies, however, that can be of importance to some users:
PQexec
waits for the command to be completed.
The application might have other work to do (such as maintaining a
user interface), in which case it won't want to block waiting for
the response.
Since the execution of the client application is suspended while it waits for the result, it is hard for the application to decide that it would like to try to cancel the ongoing command. (It can be done from a signal handler, but not otherwise.)
PQexec
can return only one
PGresult structure. If the submitted command
string contains multiple SQL commands, all but
the last PGresult are discarded by
PQexec
.
Applications that do not like these limitations can instead use the
underlying functions that PQexec
is built from:
PQsendQuery
and PQgetResult
.
There are also
PQsendQueryParams
,
PQsendPrepare
,
PQsendQueryPrepared
,
PQsendDescribePrepared
, and
PQsendDescribePortal
,
which can be used with PQgetResult
to duplicate
the functionality of
PQexecParams
,
PQprepare
,
PQexecPrepared
,
PQdescribePrepared
, and
PQdescribePortal
respectively.
PQsendQuery
Submits a command to the server without waiting for the result(s).
1 is returned if the command was successfully dispatched and 0 if
not (in which case, use PQerrorMessage
to get more
information about the failure).
int PQsendQuery(PGconn *conn, const char *command);
After successfully calling PQsendQuery
, call
PQgetResult
one or more times to obtain the
results. PQsendQuery
cannot be called again
(on the same connection) until PQgetResult
has returned a null pointer, indicating that the command is done.
PQsendQueryParams
Submits a command and separate parameters to the server without waiting for the result(s).
int PQsendQueryParams(PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char * const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat);
This is equivalent to PQsendQuery
except that
query parameters can be specified separately from the query string.
The function's parameters are handled identically to
PQexecParams
. Like
PQexecParams
, it will not work on 2.0-protocol
connections, and it allows only one command in the query string.
PQsendPrepare
Sends a request to create a prepared statement with the given parameters, without waiting for completion.
int PQsendPrepare(PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes);
This is an asynchronous version of PQprepare
: it
returns 1 if it was able to dispatch the request, and 0 if not.
After a successful call, call PQgetResult
to
determine whether the server successfully created the prepared
statement. The function's parameters are handled identically to
PQprepare
. Like
PQprepare
, it will not work on 2.0-protocol
connections.
PQsendQueryPrepared
Sends a request to execute a prepared statement with given parameters, without waiting for the result(s).
int PQsendQueryPrepared(PGconn *conn, const char *stmtName, int nParams, const char * const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat);
This is similar to PQsendQueryParams
, but
the command to be executed is specified by naming a
previously-prepared statement, instead of giving a query string.
The function's parameters are handled identically to
PQexecPrepared
. Like
PQexecPrepared
, it will not work on
2.0-protocol connections.
PQsendDescribePrepared
Submits a request to obtain information about the specified prepared statement, without waiting for completion.
int PQsendDescribePrepared(PGconn *conn, const char *stmtName);
This is an asynchronous version of PQdescribePrepared
:
it returns 1 if it was able to dispatch the request, and 0 if not.
After a successful call, call PQgetResult
to
obtain the results. The function's parameters are handled
identically to PQdescribePrepared
. Like
PQdescribePrepared
, it will not work on
2.0-protocol connections.
PQsendDescribePortal
Submits a request to obtain information about the specified portal, without waiting for completion.
int PQsendDescribePortal(PGconn *conn, const char *portalName);
This is an asynchronous version of PQdescribePortal
:
it returns 1 if it was able to dispatch the request, and 0 if not.
After a successful call, call PQgetResult
to
obtain the results. The function's parameters are handled
identically to PQdescribePortal
. Like
PQdescribePortal
, it will not work on
2.0-protocol connections.
PQgetResult
Waits for the next result from a prior
PQsendQuery
,
PQsendQueryParams
,
PQsendPrepare
, or
PQsendQueryPrepared
call, and returns it.
A null pointer is returned when the command is complete and there
will be no more results.
PGresult *PQgetResult(PGconn *conn);
PQgetResult
must be called repeatedly until
it returns a null pointer, indicating that the command is done.
(If called when no command is active,
PQgetResult
will just return a null pointer
at once.) Each non-null result from
PQgetResult
should be processed using the
same PGresult accessor functions previously
described. Don't forget to free each result object with
PQclear
when done with it. Note that
PQgetResult
will block only if a command is
active and the necessary response data has not yet been read by
PQconsumeInput
.
Using PQsendQuery
and
PQgetResult
solves one of
PQexec
's problems: If a command string contains
multiple SQL commands, the results of those commands
can be obtained individually. (This allows a simple form of overlapped
processing, by the way: the client can be handling the results of one
command while the server is still working on later queries in the same
command string.) However, calling PQgetResult
will still cause the client to block until the server completes the
next SQL command. This can be avoided by proper
use of two more functions:
PQconsumeInput
If input is available from the server, consume it.
int PQconsumeInput(PGconn *conn);
PQconsumeInput
normally returns 1 indicating
"no error", but returns 0 if there was some kind of
trouble (in which case PQerrorMessage
can be
consulted). Note that the result does not say whether any input
data was actually collected. After calling
PQconsumeInput
, the application can check
PQisBusy
and/or
PQnotifies
to see if their state has changed.
PQconsumeInput
can be called even if the
application is not prepared to deal with a result or notification
just yet. The function will read available data and save it in
a buffer, thereby causing a select()
read-ready indication to go away. The application can thus use
PQconsumeInput
to clear the
select()
condition immediately, and then
examine the results at leisure.
PQisBusy
Returns 1 if a command is busy, that is,
PQgetResult
would block waiting for input.
A 0 return indicates that PQgetResult
can be
called with assurance of not blocking.
int PQisBusy(PGconn *conn);
PQisBusy
will not itself attempt to read data
from the server; therefore PQconsumeInput
must be invoked first, or the busy state will never end.
A typical application using these functions will have a main loop that
uses select()
or poll()
to wait for
all the conditions that it must respond to. One of the conditions
will be input available from the server, which in terms of
select()
means readable data on the file
descriptor identified by PQsocket
. When the main
loop detects input ready, it should call
PQconsumeInput
to read the input. It can then
call PQisBusy
, followed by
PQgetResult
if PQisBusy
returns false (0). It can also call PQnotifies
to detect NOTIFY messages (see Section 31.7).
A client that uses
PQsendQuery
/PQgetResult
can also attempt to cancel a command that is still being processed
by the server; see Section 31.5. But regardless of
the return value of PQcancel
, the application
must continue with the normal result-reading sequence using
PQgetResult
. A successful cancellation will
simply cause the command to terminate sooner than it would have
otherwise.
By using the functions described above, it is possible to avoid blocking while waiting for input from the database server. However, it is still possible that the application will block waiting to send output to the server. This is relatively uncommon but can happen if very long SQL commands or data values are sent. (It is much more probable if the application sends data via COPY IN, however.) To prevent this possibility and achieve completely nonblocking database operation, the following additional functions can be used.
PQsetnonblocking
Sets the nonblocking status of the connection.
int PQsetnonblocking(PGconn *conn, int arg);
Sets the state of the connection to nonblocking if arg is 1, or blocking if arg is 0. Returns 0 if OK, -1 if error.
In the nonblocking state, calls to
PQsendQuery
, PQputline
,
PQputnbytes
, and
PQendcopy
will not block but instead return
an error if they need to be called again.
Note that PQexec
does not honor nonblocking
mode; if it is called, it will act in blocking fashion anyway.
PQisnonblocking
Returns the blocking status of the database connection.
int PQisnonblocking(const PGconn *conn);
Returns 1 if the connection is set to nonblocking mode and 0 if blocking.
PQflush
Attempts to flush any queued output data to the server. Returns 0 if successful (or if the send queue is empty), -1 if it failed for some reason, or 1 if it was unable to send all the data in the send queue yet (this case can only occur if the connection is nonblocking).
int PQflush(PGconn *conn);
After sending any command or data on a nonblocking connection, call
PQflush
. If it returns 1, wait for the socket
to be write-ready and call it again; repeat until it returns 0. Once
PQflush
returns 0, wait for the socket to be
read-ready and then read the response as described above.


Military Mail holiday deadline for ground service is this week
by WFTX Digital TeamLEE COUNTY, Fla. -- You need to get a move on holiday shipping if you're sending anything to a military or diplomatic post office.
Some United States Post Office holiday deadlines are rapidly approaching.
The deadline is Wednesday.
For regular ground service, it's December 14th.
For priority mail its December 21st.
Keep in mind the busiest time for the post office starts about two weeks before Christmas.


Home
Blog
Blog
Latest Posts
Jekyll - not that easy
First post in a blog created in
https://jekyllrb.com/
and
https://pages.github.com/
. Finally!


Collection View
-
A Collection View manages the presentation of items, your app’s main job is to provide the data that those items are to represent.
A collection view gets its data from the data source, which is an object that conforms to the CollectionViewDataSource protocol. Data provided by the data source is represented items, which can also be organized into sections, and ultimately displayed as cells.
Gathings Data
The data source only has 3 requirements, provide the number of sections, the number of items, and a cell for each item. For performance, cells in a collection view are reusable since only a subset of all the items will often be visbile.
Before you can load a cell, you need to register the cells you will need to represet your data. Cells can be registered from a nib or from a class using
register(class:forCellWithReuseIdentifier:)
orregister(nib:forCellWithReuseIdentifier:)
. The reuse identifier will later be use to get instances of the cell.To create the cells for each item in your data, implement the data source method
func collectionView(_:cellForItemAt:) -> CollectionViewCell
. In here you will calldequeueReusableCell(withReuseIdentifier:for:)
which will load an instance of the cell your previously registered for that resuse identifier. After you have dequeued the cell, update it as needed to properly represent the object at the given index path in your data, then return it.Laying Out Items
After the data source has provided all the cells to be displayed, the collection view looks to its CollectionViewLayout to determine where to place each one. The base layout object is designed to be subclassed to generate layout information for different use cases. The goal of a layout is to be able to provide information about the layout to the collection view quickly, this inlcudes the location of each cell, the overall size of all the items, etc.
The following layouts are provided for common uses, for more custom layouts, create a custom CollectionViewLayout subclass.
- CollectionViewColumnLayout
- CollectionViewListLayout
- CollectionViewFlowLayout
- CollectionViewHorizontalLayout
Declaration
Swift
open class CollectionView : ScrollView, NSDraggingSource
-
The CollectionViewDataSource is responsible for providing the data and views required by a collection view
Overview
At a minimum, all data source objects must implement:
numberOfSections(in:)
collectionView(_:numberOfItemsInSection:)
collectionView(_:cellForItemAt:)
.
These methods are responsible for returning the number of items in the collection view along with the items themselves.
See moreDeclaration
Swift
@objc public protocol CollectionViewDataSource
-
The CollectionViewDelegate protocol defines methods that allow you to manage the status, selection, highlighting, and scrolling of items in a collection view and to perform actions on those items. The methods of this protocol are all optional.
See moreDeclaration
Swift
@objc public protocol CollectionViewDelegate
-
The CollectionViewDragDelegate forwards system drag functions to the delegate in the context of a Collection View.
See moreDeclaration
Swift
@objc public protocol CollectionViewDragDelegate : CollectionViewDelegate
-
A CollectionViewCell object presents the content for a single data item when that item is within the collection view’s visible bounds. You can use this class as-is or subclass it to add additional properties and methods. The layout and presentation of cells is managed by the collection view and its corresponding layout object.
See moreDeclaration
Swift
open class CollectionViewCell : CollectionReusableView
-
The CollectionReusableView class defines the behavior for all cells and supplementary views presented by a collection view. Reusable views are so named because the collection view places them on a reuse queue rather than deleting them when they are scrolled out of the visible bounds. Such a view can then be retrieved and repurposed for a different set of content.
See moreDeclaration
Swift
open class CollectionReusableView : NSView
-
The UICollectionViewController class represents a view controller whose content consists of a collection view.
See moreDeclaration
Swift
open class CollectionViewController : NSViewController, CollectionViewDataSource, CollectionViewDelegate
-
CollectionViewLayoutElementKind
Declaration
Swift
public struct CollectionViewLayoutElementKind
-
CollectionElementCategory
- cell:
- supplementaryView:
Declaration
Swift
public enum CollectionElementCategory
-
CollectionViewDirection
- left:
- right:
- up:
- down:
Declaration
Swift
public enum CollectionViewDirection
-
CollectionViewScrollDirection
- vertical:
- horizontal:
Declaration
Swift
public enum CollectionViewScrollDirection
-
CollectionViewScrollPosition
- none:
- nearest:
- leading:
- centered:
- trailing:
Declaration
Swift
public enum CollectionViewScrollPosition
-
AnimationCompletion
Declaration
Swift
public typealias AnimationCompletion = (_ finished: Bool) -> Void
-
A default implementation of CollectionViewPreviewTransitionCell
See moreDeclaration
Swift
open class CollectionViewPreviewCell : CollectionViewCell, CollectionViewPreviewTransitionCell
-
A protocol for CollectionViewCells that need to customize their transition when used in CollectionViewPreviewController.
If you adopt this protocol in a custom CollectionViewCell subclass, see the source code for CollectionViewPreviewCell for an example implementation.
See moreDeclaration
Swift
public protocol CollectionViewPreviewTransitionCell : AnyObject
-
An easy to use CollectionViewController that transitions from a source collection view.
Presentation & Data
The controller is presented from a source collection view. The data source of the source collection view is used to load data for the preview collection view. The preview controller will act as a proxy between the preview collection view and your source colleciton views data source.
Important
The data source for the collection view passed to present(in:) must conform to CollectionViewPreviewControllerDelegateTransitions
The preview controller manages the transitions to and from the source and allows the preview cell to customize the transition.
Although the The preview controller will accept any cell class, supporting transitions requires a small amount of additional setup.
The simplest way to support transitions is to create your subclass from CollectionViewPreviewCell. CollectionViewPreviewCell will animate the frame of the cell from the source and back.
For custom transitions, if you subclass CollectionViewPreviewCell you can simply override the the transition methods, otherwise conform your CollectionViewCell subclass and implement the methods yourself. See CollectionViewPreviewTransitionCell for more about how to implement custom transitions
See moreDeclaration
Swift
open class CollectionViewPreviewController : CollectionViewController, CollectionViewDelegatePreviewLayout
-
a CollectionViewPreviewControllerDelegate is responsible for providing data to a CollectionViewPreviewController.
See moreDeclaration
Swift
public protocol CollectionViewPreviewControllerDelegate : AnyObject


|
(icon background by Galaxy Photography) The Serious* Interactive Astronomical Software Ephemeris Version 3.7.7 | ||
|
* "It takes some getting used to, but it's worth the effort. Once you
understand its peculiarities, you'll find that XEphem can do just about
anything you ask ...". Quoted with permission from
Astronomy Hacks
Copyright © 2005 Robert Bruce Thompson and Barbara Fritchman Thompson.
| |
| XEphem \eks-i-'fem\ n. [X Window System + Ephemeris] (1990) : | |
| 1. |
From Xceptional Astronomical Software by Jeff Medkeff, Sky and Telescope magazine February 2000, page 65: "XEphem, the brainchild of programmer Elwood Downey, is a star-charting, sky-simulating, ephemeris-generating celestial virtuoso that can do just about everything ... what's not to like?" From X Marks the Spot by David Ratledge, Sky and Telescope magazine August 2002, page 67: "If everyday sky charting is all you want, then one of several more user-friendly and cheaper Windows packages will suffice. However, that's not what XEphem is all about. It's for those who need that little extra and are willing to put the effort in to achieve it. If, like me, you are in that category then I would certainly recommend XEphem."
|
| |
| 2. |
The scientific-grade interactive astronomical ephemeris software
package for UNIX-like* systems. Written in C, X11 and Motif with full
source code
freely available, easily ported to systems including:
* XEphem does not run under native Windows but it works fine using a virtualization toolkit such as Virtualbox and a free linux distro such as OpenSUSE. |
| |
| Thank you for your interest in XEphem. Feel free to browse by clicking on the screen shots above and from the panel at the left for more information. For specific questions, contact us at<EMAIL_ADDRESS>|


Our Humble Beginnings
We gave him movement and character
A vampire bat APPEARS
Add some vegetation
Developer A
Developer B


level
namespace level
a level manager. once ressources loaded, the level manager contains all references of defined levels.
Summary
Methods from level
| boolean |
|
| TMXTileMap |
|
| string |
|
| number |
|
| boolean |
|
| boolean |
|
| boolean |
|
| object |
|
Public Methods
add(format: string, levelId: string, callback: Function) → {boolean}
add a level into the game manager (usually called by the preloader)
| Name | Type | Attributes | Description |
|---|---|---|---|
| format | string |
level format (only "tmx" supported) |
|
| levelId | string |
the level id (or name) |
|
| callback | Function |
<optional> |
a function to be called once the level is loaded |
| Type | Description |
|---|---|
| boolean |
true if the level was loaded |
getCurrentLevel() → {TMXTileMap}
return the current level definition. for a reference to the live instantiated level, rather use the container in which it was loaded (e.g. me.game.world)
| Type | Description |
|---|---|
| TMXTileMap |
getCurrentLevelId() → {string}
return the current level id
| Type | Description |
|---|---|
| string |
levelCount() → {number}
return the amount of level preloaded
| Type | Description |
|---|---|
| number |
the amount of level preloaded |
load(levelId: string, options: object) → {boolean}
load a level into the game manager
(will also create all level defined entities, etc..)
// the game assets to be be preloaded
// TMX maps
let resources = [
{name: "a4_level1", type: "tmx", src: "data/level/a4_level1.tmx"},
{name: "a4_level2", type: "tmx", src: "data/level/a4_level2.tmx"},
{name: "a4_level3", type: "tmx", src: "data/level/a4_level3.tmx"},
// ...
];
// ...
// load a level into the game world
me.level.load("a4_level1");
...
...
// load a level into a specific container
let levelContainer = new me.Container();
me.level.load("a4_level2", {container:levelContainer});
// add a simple transformation
levelContainer.currentTransform.translate(levelContainer.width / 2, levelContainer.height / 2 );
levelContainer.currentTransform.rotate(0.05);
levelContainer.currentTransform.translate(-levelContainer.width / 2, -levelContainer.height / 2 );
// add it to the game world
me.game.world.addChild(levelContainer);
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
| levelId | string |
level id |
||
| options | object |
<optional> |
additional optional parameters |
|
| options.container | Container |
<optional> |
game.world |
container in which to load the specified level |
| options.onLoaded | Function |
<optional> |
game.onLevelLoaded |
callback for when the level is fully loaded |
| options.flatten | boolean |
<optional> |
game.mergeGroup |
if true, flatten all objects into the given container |
| options.setViewportBounds | boolean |
<optional> |
true |
if true, set the viewport bounds to the map size |
| Type | Description |
|---|---|
| boolean |
true if the level was successfully loaded |
next(options: object) → {boolean}
load the next level
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
| options | object |
<optional> |
additional optional parameters |
|
| options.container | Container |
<optional> |
game.world |
container in which to load the specified level |
| options.onLoaded | Function |
<optional> |
game.onLevelLoaded |
callback for when the level is fully loaded |
| options.flatten | boolean |
<optional> |
game.mergeGroup |
if true, flatten all objects into the given container |
| Type | Description |
|---|---|
| boolean |
true if the next level was successfully loaded |
previous(options: object) → {boolean}
load the previous level
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
| options | object |
<optional> |
additional optional parameters |
|
| options.container | Container |
<optional> |
game.world |
container in which to load the specified level |
| options.onLoaded | Function |
<optional> |
game.onLevelLoaded |
callback for when the level is fully loaded |
| options.flatten | boolean |
<optional> |
game.mergeGroup |
if true, flatten all objects into the given container |
| Type | Description |
|---|---|
| boolean |
true if the previous level was successfully loaded |
reload(options: object) → {object}
reload the current level
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
| options | object |
<optional> |
additional optional parameters |
|
| options.container | Container |
<optional> |
game.world |
container in which to load the specified level |
| options.onLoaded | Function |
<optional> |
game.onLevelLoaded |
callback for when the level is fully loaded |
| options.flatten | boolean |
<optional> |
game.mergeGroup |
if true, flatten all objects into the given container |
| Type | Description |
|---|---|
| object |
the current level |


Based on best of class enterprise level architecture, EduERP is ready to be used from local infrastructure to a highly scalable cloud environment.
A complete student management system which enables you to store all information related to students such as address, blood group, achievements and much more.
Faculty management system with integrated HR management system gives full control over information related to faculty like educational degree, skills and payroll.
Subject management system to manage details of subject like name, code and type such as theory, practical or both.
A Course management system provides detailed information of course and subjects related to that course. You can manage parent-child relationship between courses.
Batch management system to manage batches of students from different courses.


Don't miss a beat, QUARANTINE is coming in Rainbow Six Siege. Experience first hand as the Rainbow Operators take on a dangerous bioterrorist group. New Operators specialized in rescue missions join the Rainbow Team. With them, expect a new massive and action-filled map into the game.
For the fifth year of Rainbow 7 Siege, give some space to our two new operators as they break into this new game mode with their unique abilities. Two operators, Amaru and Goyo, were recruited from Peru and Mexico, bringing with them innovation and change to Rainbow Seven Siege.


PixKit is a Codekit kickoff stack with Bootstrap 3, SASS, jQuery, jQuery.mMenu
Install PixKit either by direct download, or git:
git clone https://github.com/PixLandMedia/PixKit.git
The following files are automatically compiled by PixKit and should not be edited directly. - css/style.min.css - css/style.min.map - js/app.min.js
All Build files reside in the build directory
The project use Codekit’s kit language ( more info to Kit ) This allows you to build html includes (such as header/footer, etc.) without the need to use a dynamic language. All Production HTML files reside in the html folder. As mentioned, it is best in most circumstances to not edit these files, since they are compiled from other sources.
All third-party library files reside in the build/bower_components directory. The library’s js files include the build/js/app.js file. For example:
// @codekit-prepend "../bower_components/jquery/dist/jquery.min.js"
The library’s sass files include the build/sass/style.scss file. For example:
@import '../bower_components/bootstrap-sass-official/assets/stylesheets/_bootstrap';
The library’s css files copy the build/sass/layouts or build/sass/modules. You should change the file’s extension .scss for example:
/build/bower_components/jQuery.mmenu/dist/css/jquery.mmenu.all.css.css
to
/build/sass/layouts/_mmenu.scss
PixLand Media
web: www.pixlandmedia.com
email<EMAIL_ADDRESS>Tamás Németh
The MIT License (MIT)
Copyright © 2015 PixLand Media
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
04.21.15 v0.1.4: - ADDED /build/kits/partials/menu.kit - ADDED jQuery.mMenu - ADDED .gitignore - REMOVED Slidebars.js - UPDATED Bootstrap 3.3.4 - UPDATED Font Awesome 4.3.0
01.20.15 v0.1.3: - CHANGED navigation links - REMOVED index.html - ADDED /html/index.html
01.18.15 v0.1.2:
01.18.15 v0.1.1:
01.18.15 v0.1.0:


TemplatesRepository
class TemplatesRepository
Class TemplatesRepository is used to retrieve template data
Methods
No description
Get template and any related data by using its template path to retrieve its related data from the templates config
Get an array of all template paths and human names
Get an array of all registered templates as an array of paths and human names; registered means already in templates config
Get list of unregistered templates by finding all app template files which are not stored (do not have path key) in the templates config
compiles an array of all of the variables used in the application
Details
at line 13
__construct(TemplatesManager $TemplatesManager, Framework $Framework, $File = null)
at line 31
array
getTemplateByPath(string $templatePath)
Get template and any related data by using its template path to retrieve its related data from the templates config
at line 62
array
allTemplatesPaginated(integer $perPage = 25)
Get an array of all template paths and human names
at line 85
array
registeredTemplatesList(boolean $showHumanName = true)
Get an array of all registered templates as an array of paths and human names; registered means already in templates config
at line 119
array
unregisteredTemplatesList()
Get list of unregistered templates by finding all app template files which are not stored (do not have path key) in the templates config
at line 158
array
compileAllUsedVars()
compiles an array of all of the variables used in the application