Pyblosxom uses the file system for data storage allowing you to use the text-based tools that you use for other parts of your workflow for your blog.
Pyblosxom has a plugin system allowing users to augment and extend Pyblosxom’s behavior to meet their specific needs.
This chapter covers Pyblosxom’s architecture.
The code is fairly well documented and you should always consider the code to be the authority when the code and this manual are in disagreement.
Pyblosxom is composed of several parts:
pyblosxom.cgi - This is the CGI script that is executed by your web server, pulls in configuration variables from config.py and then instantiates Pyblosxom objects to handle the request.
PyblosxomWSGIApp - This is the WSGI application for Pyblosxom.
Pyblosxom package - This is the Python package that holds the Pyblosxom objects and utility functions that handle the request.
the entries package - Handles the abstraction allowing Pyblosxom to use entries other than those solely found on the file system.
the renderers package - Pyblosxom can handle different renderers. The renderer gets a list of entries to be rendered and can render them using whatever means it so desires: blosxom templates, htmltmpl templates, Cheetah templates, hard-coded RSS 2.0 markup, ...
Pyblosxom comes with two renderers: blosxom and debug.
the cache package - Pyblosxom allows for entry-level caching. This helps in cases where your entries are stored in a format that requires a lot of processing to convert to HTML.
Pyblosxom’s behavior and output is then augmented by:
This is the life cycle of a single Pyblosxom CGI request. It involves the following “entities”:
The Pyblosxom request lifecycle starts with the web server executing pyblosxom.cgi.
pyblosxom.cgi loads config.py
pyblosxom.cgi instantiates a Request object
pyblosxom.cgi instantiates a Pyblosxom.pyblosxom.Pyblosxom object passing it the Request object
pyblosxom.cgi calls run() on the Pyblosxom object
Pyblosxom instance, run method: calls initialize
- Pyblosxom instance, initialize method: calls the entry parser callback to get a map of all the entry types Pyblosxom can handle
Pyblosxom instance, run method: calls the start callback to allow plugins to do any initialization they need to do
Pyblosxom instance, run method: calls the handle callback allowing plugins to handle the request
If a plugin handles the request, the plugin should return a 1 signifying it has handled the request and Pyblosxom should stop. FINISHED.
If no plugin handles the request, then we continue using the blosxom_handler.
Pyblosxom instance, run method: calls the end callback to allow plugins to do any cleanup they need to do.
FIXME - add lifecycle for long-running processes through WSGI—it’s slightly different.
This describes what the blosxom_handler does. This is the default handler for Pyblosxom. It’s called by the Pyblosxom instance in the run method if none of the plugins have handled the request already.
Calls the renderer callback to get a renderer instance.
If none of the plugins return a Renderer instance, then Pyblosxom checks to see if the renderer property is set in config.py.
If there renderer is specified, Pyblosxom instantiates that.
If there renderer is not specified, Pyblosxom uses the blosxom renderer in the renderer package.
Calls the pathinfo callback which allows all plugins to help figure out what to do with the HTTP URI/QUERYSTRING that’s been requested.
Calls the filelist callback which returns a list of entries to render based on what the pathinfo is.
Calls the prepare callback which allows plugins to transform the entries and any other data in the Request object prior to rendering.
Renders the entries.
The blosxom renderer renders the entries in a similar fashion to what Blosxom does. The blosxom renderer uses flavour templates and template variables. It also has a series of callbacks allowing plugins to modify templates and entry data at the time of rendering that specific piece.
Callbacks allow plugins to override behavior in Pyblosxom or provide additional behavior. The callback mechanism actually encompasses a series of different functions. Callbacks can act as handlers, as notifiers, and also as modifiers.
In the case of handler callbacks, Pyblosxom will query each plugin implementing the callback until one of the plugins returns that it has handled the callback. At that point, execution of handling code stops. If none of the plugins handle the callback, then Pyblosxom will run its default behavior code.
In the case of notifier callbacks, Pyblosxom will notify each plugin implementing the callback regardless of return values.
In the case of modifier callbacks, Pyblosxom will query each plugin implementing the callback passing in some input. It takes the output from the callback function and passes that in as input to the next callback function. In this way, each plugin has a chance to modify and transform the data.
There’s no reason you can’t implement a handler-type callback and use it for notification purposes—that’s fine. You should know that in the case of handler callbacks and modifier callbacks, the return value that your plugin gives will affect Pyblosxom’s execution.
There are a series of callbacks in Pyblosxom that have equivalents in blosxom 2.0. The names are sometimes different and in most cases the arguments the Pyblosxom versions take are different than the blosxom 2.0 versions. Even so, the Pyblosxom versions serve the same purpose as the blosxom 2.0 versions.
This isn’t very interesting unless you’re trying to implement the functionality of a blosxom 2.0 plugin in Python for Pyblosxom.
The available blosxom renderer callbacks are:
Additionally, we have these lifecycle callbacks available:
The prepare callback is called in the default blosxom handler after we’ve figured out what we’re rendering and before we actually go to the renderer.
Plugins should implement cb_prepare to modify the data dict which is in the Request. Inside the data dict is entry_list (amongst other things) which holds the list of entries to be renderered (in the order they will be rendered).
Functions that implement this callback will get an args dict containing:
Functions that implement this callback can return whatever they want—it doesn’t affect the callback chain.
Example of a cb_prepare function in a plugin:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | def cb_prepare(args):
"""
This plugin shows the number of entries we are going to render and
place the result in $entrycount
"""
request = args['request']
data = request.get_data()
config = request.get_configuration()
# Can anyone say Ternary? :)
IF = lambda a, b, c: (a() and [b()] or [c()])[0]
num_entry = config['num_entries']
entries = len(data['entry_list'])
data['entrycount'] = IF(num_entry > entries, num_entry, entries)
|
The logrequest callback is used to notify plugins of the current Pyblosxom request for the purposes of logging.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback can return whatever they want—it doesn’t affect the callback chain.
cb_logrequest is called after rendering and will contain all the modifications to the Request object made by the plugins.
An example input args dict is like this:
{'filename': filename, 'return_code': '200', 'request': Request()}
The filelist callback allows plugins to generate the list of entries to be rendered. Entries should be EntryBase derivatives—either by instantiating EntryBase, FileEntry, or creating your own EntryBase subclass.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback should return None if they don’t plan on generating the entry list or a list of entries if they do. When a function returns None, the callback will continue to the next function to see if it will return a list of entries. When a function returns a list of entries, the callback will stop.
The sortlist callback allows plugins to implement their own sorting of entries. This callback gets called by filelist handlers.
Functions that implement this callback will get an args dict containing:
Return None if the function doesn’t sort the list. Return the sorted list if the function does sort the list.
Example of a cb_sortlist function:
1 2 3 4 5 6 7 8 9 10 11 12 | def cb_sortlist(args):
"""Sorts the list from oldest (beginning) to newest (end)
for a site that's less like a blog and more like a
journal.
"""
entrylist = args["entry_list"]
entrylist = [(e._mtime, e) for e in entrylist]
entrylist.sort()
entrylist = [e[1] for e in entrylist]
return entrylist
|
The truncatelist callback allows plugins to implement their own truncation rules. This callback gets called by filelist handlers.
Functions that implement this callback will get an args dict containing:
Return None if the function doesn’t truncate the list. Return the new list if the function does truncate the list.
Example of a cb_truncatelist function:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | def cb_truncatelist(args):
request = args["request"]
entrylist = args["entry_list"]
data = request.data
config = request.config
num_entries = config.get("num_entries", 5)
truncate = data.get("truncate", 0)
if num_entries and truncate:
entrylist = entrylist[:num_entries]
return entrylist
return None
|
The filestat callback allows plugins to provide mtimes for entries. Plugins may use this to override the mtime stored in the filesystem. For example, one of the contributed plugins uses this to set the mtime to the time specified in the entry’s filename.
Plugins may also use this to provide a cheaper alternative to filesystem stat calls—a notorious performance drag. The hardcodedates plugin, for example, stores mtimes in a file: it reads the file once at startup then returns mtimes from its in-memory database.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback must return the input args dict whether or not they adjust anything in it. The callback chain will stop as soon as a callback modifies mtime. If no plugin handles the callback, Pyblosxom will fall back to calling os.stat().
The pathinfo callback allows plugins to parse the HTTP PATH_INFO item. This item is stored in the http dict of the Request object. Functions would parse this as they desire, then set the following variables in the data dict of the Request object:
Functions that implement this callback will get an args dict containing:
Functions that implement this callback should make the modifications to the data dict in place—no need to return anything.
The commandline callback allows plugins to implement additional pyblosxom-cmd commands. This allows a plugin to expose maintenance and setup functionality to the user at the command line or through cron.
For example. if you wrote a plugin that built an map of tags to entries that used that tag, you’d probably want to write a command that updates the index which the user could create a cron job for.
The cb_commandline function takes a single args argument which is a map of command -> tuple of handler and help text. It then returns the args dict.
For example:
def cb_commandline(args):
args["printargs"] = (printargs, "prints command line arguments")
See Writing a plugin that adds a commandline command for more details.
The renderer callback allows plugins to specify a renderer to use by returning a renderer instance to use. If no renderer is specified, we use the default blosxom renderer.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback should return None if they don’t want to specify a renderer or the renderer object instanct if they do. When a function returns a renderer instance, processing stops.
The entryparser callback allows plugins to register the entryparsers they have. Entry parsers are linked with a filename extension. For example, the default blosxom text entry parser will be used for any file ending in .txt.
Functions that implement this callback will get the entryparser dict consisting of file extension -> entry parsing function pairs.
Functions that implement this callback should return the entryparser dict after modifying it.
Example:
def cb_entryparser(entryparsingdict):
entryparsingdict["txtl"] = txtl_parse
return entryparsingdict
Then the plugin would define txtl_parse which takes a filename and a Request and returns an entrydata dict with title and body (or whatever the templates need to render this entry).
The preformat callback acts in conjunction with the entryparser that handled the entry to do a two-pass formatting of the entry.
Functions that implement cb_preformat are text transformation tools. Once one of them returns a transformed entry, then we stop processing.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback should return None if they didn’t modify the story or a single story string.
The postformat callback allows plugins to make further modifications to entry text. It typically gets called after a preformatter by the entryparser. It can also be used to add additional properties to entries. The changes from postformat functions are saved in the cache (if the user has caching enabled). As such, this shouldn’t be used for dynamic data like comment counts.
Examples of usage:
Functions that implement this callback will get an args dict containing:
Functions that implement this callback don’t need to return anything—modifications to the entry_data dict are done in place.
The start callback allows plugins to execute startup/initialization code. Use this callback for any setup code that your plugin needs, like:
Note
cb_start is different in Pyblosxom than in blosxom.
The cb_start callback is slightly different than in blosxom in that cb_start is called for every Pyblosxom request regardless of whether it’s handled by the default blosxom handler. In general, it’s better to delay allocating resources until you absolutely know you are going to use them.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback don’t need to return anything.
The start callback allows plugins to execute teardown/cleanup code, save any data that hasn’t been saved, clean up temporary files, and otherwise return the system to a normal state.
Examples of usage:
Functions that implement this callback will get an args dict containing:
Functions that implement this callback don’t need to return anything.
Note
cb_end is different in Pyblosxom than in blosxom
The cb_end callback is called for every Pyblosxom request regardless of whether it’s handled by the default blosxom handler or not. This is slightly different than blosxom.
Gives plugins a chance to modify the list of (url, query) tuples that are about to be rendered statically. Plugins can add additional tuples, remove tuples, modify tuples, ...
Functions that implement this callback will get an args dict containing:
Functions that implement this callback can modify the filelist in-place and don’t have to return anything.
Example in which the plugin adds the search page url so that the search page gets rendered:
def cb_staticrender_filelist(args):
filelist = args["filelist"]
filelist.append(("/search", ""))
The head callback is called before a head flavour template is rendered.
cb_head is called before the variables in the entry are substituted into the template. This is the place to modify the head template based on the entry content. You can also set variables on the entry that will be used by the cb_story or cb_foot templates. You have access to all the content variables via entry.
Blosxom 2.0 calls this callback head.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback must return the input args dict whether or not they adjust anything in it.
Example in which we add the number of entries being rendered to the $blog_title variable:
1 2 3 4 5 6 7 8 9 10 | def cb_head(args):
request = args["request"]
config = request.get_configuration()
data = request.get_data()
num_entries = len(data.get("entry_list", []))
bt = config.get("blog_title", "")
config["blog_title"] = bt + ": %d entries" % num_entries
return args
|
The date_head callback is called before a date_head flavour template is rendered.
cb_date_head is called before the variables in the entry are substituted into the template. This is the place to modify the date_head template based on the entry content. You have access to all the content variables via entry.
Blosxom 2.0 calls this callback date.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback must return the input args dict whether or not they adjust anything in it.
The story callback gets called before the entry is rendered.
The template used is typically the story template, but we allow entries to override this if they have a template property. If they have the template property, then we’ll use the template of that name instead.
cb_story is called before the variables in the entry are substituted into the template. This is the place to modify the story template based on the entry content. You have access to all the content variables via entry.
Blosxom 2.0 calls this callback story.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback must return the input args dict whether or not they adjust anything in it.
Example which adds a guid variable to the entry which is available to use in the story template. The guid can be manually set by the user in the entry metadata and if it’s not there, then it defaults to the file_path value:
1 2 3 4 5 6 7 8 9 10 11 | def cb_story(args):
# grab the entry from the args dict.
entry = args["entry"]
# set the "guid" variable in the entry. it's either the "guid"
# value (if the user set one in the entry metadata) or it's
# whatever the value of "file_path" is.
entry["guid"] = entry.get("guid", entry.get("file_path"))
# the cb_story function _must_ return the args dict.
return args
|
The story_end callback is is called after the variables in the entry are substituted into the template. You have access to all the content variables via entry.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback must return the input args dict whether or not they adjust anything in it.
The foot callback is called before the variables in the entry are substituted into the foot template. This is the place to modify the foot template based on the entry content. You have access to all the content variables via entry.
Blosxom 2.0 calls this callback foot.
Functions that implement this callback will get an args dict containing:
Functions that implement this callback must return the input args dict whether or not they adjust anything in it.


Many internet ventures rely on advertising for their revenue. However, users feel discontent by the presence of ads on the websites they visit, as the data-size of ads is often comparable to that of the actual content. This has an impact not only on the loading time of webpages, but also on the internet bill of the user in some cases. In absence of a mutually-agreed procedure for opting out of advertisements, many users resort to ad-blocking browser-extensions.
In this work, we study the performance of popular ad-blockers on a large set of news websites. Moreover, we investigate the benefits of ad-blockers on user privacy as well as the mechanisms used by websites to counter them. Finally, we explore the traffic overhead due to the ad-blockers themselves.
We collected two datasets for the project.
Top150 This is a list of the top 150 news websites, as ranked by Alexa. For each of them, we have a URL that points to the website homepage, for both its desktop and mobile version (unless the latter does not exist).
GDELT A list of 30,000 URLs pointing to di erent news articles published on a single day (November 8, 2016). The list was obtained from GDELT, a project that collects news stories from all around the world over the years.
We load the webpage of each URL with a clean instance of Chrome browser (no cached content or extensions), using the Selenium Python library on a Macbook pro with 8 cores, with no other major processes running. On each load, we capture the HAR file for the load. The HAR (HTTP Archive File) file is a JSON-formatted file that captures the interactions between the browser and the website, including network requests, types and size of objects, and load times.
We load the same URL in six browser modes, all simultaneously: a vanilla mode (no ad-blocker), and one mode for each of five adblockers. The ad-blockers are AdBlock, AdblockPlus, Ghostery, uBlock and Privacy Badger - chosen as the most popular ad- blockers on the Chrome Store.
Description of the data: The data contains json HAR files for each domain/url. Depending on the dataset the size varies from a 40M (Top150) to 8G (GDELT,per setting). A sample HAR file for nytimes.com can be found here (or on the Github link below). We have 10 settings - desktop vs. mobile, 5 adblockers.
For access to the full dataset, please email Kiran, at kiran.garimella XatX aalto.fi


I'm Finnbar Keating, a Computer Science student at Warwick University. I'm interested in a lot of things, including music (playing trombone and generative music), the design of programming languages, game development (both board and video games), physical computing (and low-level programming in general) and generative systems.
I've dabbled in quite a few different tools and programming languages. You can see the different projects I've done for each of them below. There's also a network thing written in d3.js, linking tags together if they share at least one post between them.
Or if you prefer you can just look at all of them as one list.


Home
Home
Modules
Card
Deck
QualitySet
State
Classes
exports
Card
Deck
QualitySet
Global
change
check
expression


Part 1: Set up a MQTT and MongoDB Server
The commands in this section will be run on the Intel® Iot Gateway so SSH into your Intel® Iot Gateway.
If you need a reminder, look at Step 1: Login to your Intel® Iot Gateway from the Intel® Commercial IoT Workshop Intro Module.
Once you log in the Intel® Iot Gateway, start the screen
window manager.
$ screen
You can open multiple console windows, name them and switch between them using screen. There will be many times when you will want to run several processes at the same time and screen
will be very useful to launch them in separate windows. The another alternative is to simply SSH into the server multiple times. Of course, in production you will want to launch most processes at boot time using Systemd.
To create a new console type Ctrl-A C
To name the console type Ctrl-A Shift-A
To get a list of all consoles type Ctrl-A "
To get a
Create a user for your Mosquitto.
$ adduser mosquitto
Launch the MQTT Broker named mosquitto
$ mosquitto
Download the MongoDB software.
$ wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.0.6.tgz
Once downloaded, unarchive the downloaded file.
$ tar zxvf mongodb-linux-x86_64-3.0.6.tgz
Add the mongodb binaries to the /usr/bin directory
$ cp ./mongodb-linux-x86_64-3.0.6/bin/* /usr/bin/
The Intel Iot Gateway is enabled with grsecurity which by default prevents the execution of processes that are not added to a white list.
Add the MongoDB daemon (mongod
)and the Mongo Client (mongo
) to the whitelist type:
$ paxctl -Cm /usr/bin/mongod
$ paxctl -Cm /usr/bin/mongo
The directory /data/db is the default directory that MongoDB stores its data. Let's make sure that it has plenty of space. Be sure that the /dev/sda3 partition is mounted to /data/db.
$ umount /dev/sda3
$ mkdir -p /data/db
$ mount /dev/sda3 /data/db
Some of the Gateways may have mounted /dev/sda3 as /mnt/space if this is the case then remount the partition as /data/db.
Start the MongoDB daemon using the mongod
command:
$ mongod


| Name:SUNIL KUMAR | Reg No:02-11SMHC18 |
|---|---|
| Age / Sex:35 | Contact No:9740928692 |
| Marital Status:MARRIED | Date:1/11/18 |
| Occupation:IT | Dr.PNB |
| Address:KAMMANAHALLI | DIAGNOSIS- |
1.work stress
Sudden-shock
I am in low grade in confidance and in voice wise it shows (nenu anukunnadi win ayinanu antey)
Sweat in palms,forehead
Argument-I don’t want continue in argument-I will explain them wat the problem is
Energy levels down in evening at 5.30 to 6pm
No concentration in tense
Education-mistake:electronics and research,I want t become a scientist
Job sacre after msc,tried towards msc electronics side,exam fail
Compare to wife
Dominated by brother
Subject read indetail when he is interest
2.headache-10yrs
Left side more
h/o-sinusitis lt cheek pain( biting towels)
Agg-skipping breakfast and lunch,sensitive to lights,speed brakers,sounds
Dryness of outh
Weak memory-things
Debate anf fighting
Doesn’t want to trouble
Making notes what I want to bring
Job fear
2.knee jt pain-6yrs
Cant able to sitdown
Cant able to stretch my legs,after few movements feels better
Lt leg numbness
Sensitive teeth,desires sweets n child age
Appt-slightly less
Desires-roasted one,salty
Aversions-sweet
Spiritual
Rx:
1.nux vom10m +disk 3-0-3
2.rub1m 30 tab mrng b/food
3.calc sulph10m 4doses weekly 1dose
4.bryonia10m sos headache
r/a 1mnth


| HYTOOL Function Reference |
Calculate the steady state discharge for a well located between a constant head and a no flow boundaries
q = tcn_std( l1, l2, T, r0, n ) l1 = Distance to the constant head boundary l2 = Distance to the no flow head boundary T = Transmissivity r0 = radius of the well n = optional argument to increase the number of image wells in the computation of the solution. n should be infinite but for practical purposes, n=10 is usually sufficient.
The function computes both q and the drawdown map around the well by applying the principle of superposition and adding a finite number of imaginery wells. The well is positionned in (0,0) on the maps. Exemple: q=tcn_std(100,50,1e-2,0.1)
tcn_drw, tcn_dls Published output in the Help browser showdemo tcn_std
| Hytool |
© 1998-2017 Philppe Renard and Co. Terms of Use Acknowledgments


How Benzema Could Make Algeria Switch
by Kurt BuckerfieldReal Madrid striker Karim Benzema was recently told he would never represent France again, to which he reacted by saying he would be happy to play for Algeria instead. How he could make that shock switch materialise has now seemingly been revealed.
Click through the gallery above to see some other French-born players of Algerian descent.
In response to French Football Federation (FFF) president Noel Le Graet's remarks that he will never be considered for France again, Benzema took to Twitter to say he wants to represent Algeria due to his Algerian origins.
Les Verts manager Djamel Belmadi responded by claiming he is more than happy with his current attacking options, but if Benzema were to actually become available one day, his opinion could very well change.
The 31-year-old is currently in the best goalscoring form of his career, having found the back of the net 41 times for his club since the beginning of the 2018/19 campaign. Benzema, however, last played for France four years ago, following his involvement in the blackmailing of Mathieu Valbuena over a sex tape in 2015.
Choose the left midfielder for SA's Real Madrid Dream Team & win a replica shirt!
Despite his comments about potentially playing for Algeria, Benzema would not be able to make the switch at this time as he represented Les Bleus in competitive matches, with Article 18 of FIFA's ruling stating that "any player who has already participated in a match (either in full or in part) in an official competition of any category or any type of football for one association may not play in an international match for a representative team of another association," as per RMadridEngineer on Twitter.
There could, though, be a way around these regulations, with Article 18.2 stating that "if a player who has played for his association in an official game permanently loses the nationality of that country without his consent by Govt move he may request permission to play for another association whose nationality he already has/has acquired."
In order to make the nationality switch happen, Benzema would need his French citizenship taken away from him, then submit a request to FIFA with the backing and approval of the Algerian government.
According to Marca, the striker could look to use the FFF president's comments against him, which may also strengthen his case if he were to seek an official nationality change.
10 Players Who Left Real Madrid Because Of Ronaldo
Benzema made 81 appearances for France, contributing to 45 goals overall.


There is an error in your link code.
There is an error in your link code. Please get a new copy of the code from your account and replace the current code on your website.
Shareasale.com manages the relationships between advertisers and affiliates, which is why you were directed to our site. Since the link that you clicked contains an error, you were not redirected to the site.


Network virtualization¶
Singularity 3.0 introduces full integration with cni , and several new features to make network virtualization easy.
A few new options have been added to the action commands (exec
, run
,
and shell
) to facilitate these features, and the --net
option has been
updated as well. These options can only be used by root.
--dns
¶
The --dns
option allows you to specify a comma separated list of DNS servers
to add to the /etc/resolv.conf
file.
$ nslookup sylabs.io | grep Server
Server: <IP_ADDRESS>
$ sudo singularity exec --dns <IP_ADDRESS> ubuntu.sif nslookup sylabs.io | grep Server
Server: <IP_ADDRESS>
$ sudo singularity exec --dns <IP_ADDRESS> ubuntu.sif cat /etc/resolv.conf
nameserver <IP_ADDRESS>
--hostname
¶
The --hostname
option accepts a string argument to change the hostname
within the container.
$ hostname
ubuntu-bionic
$ sudo singularity exec --hostname hal-9000 my_container.sif hostname
hal-9000
--net
¶
Passing the --net
flag will cause the container to join a new network
namespace when it initiates. New in Singularity 3.0, a bridge interface will
also be set up by default.
$ hostname -I
<IP_ADDRESS>
$ sudo singularity exec --net my_container.sif hostname -I
<IP_ADDRESS>
--network
¶
The --network
option can only be invoked in combination with the --net
flag. It accepts a comma delimited string of network types. Each entry will
bring up a dedicated interface inside container.
$ hostname -I
<IP_ADDRESS> <IP_ADDRESS>
$ sudo singularity exec --net --network ptp ubuntu.sif hostname -I
<IP_ADDRESS>
$ sudo singularity exec --net --network bridge,ptp ubuntu.sif hostname -I
<IP_ADDRESS> <IP_ADDRESS>
When invoked, the --network
option searches the singularity configuration
directory (commonly /usr/local/etc/singularity/network/
) for the cni
configuration file corresponding to the requested network type(s). Several
configuration files are installed with Singularity by default corresponding to
the following network types:
bridge
ptp
ipvlan
macvlan
Administrators can also define custom network configurations and place them in the same directory for the benefit of users.
--network-args
¶
The --network-args
option provides a convenient way to specify arguments to
pass directly to the cni plugins. It must be used in conjuction with the
--net
flag.
For instance, let’s say you want to start an NGINX server on port 80 inside of the container, but you want to map it to port 8080 outside of the container:
$ sudo singularity instance start --writable-tmpfs \
--net --network-args "portmap=8080:80/tcp" docker://nginx web2
The above command will start the Docker Hub official NGINX image running in a
background instance called web2
. The NGINX instance will need to be able to
write to disk, so we’ve used the --writable-tmpfs
argument to allocate some
space in memory. The --net
flag is necessary when using the
--network-args
option, and specifying the portmap=8080:80/tcp
argument
which will map port 80 inside of the container to 8080 on the host.
Now we can start NGINX inside of the container:
$ sudo singularity exec instance://web2 nginx
And the curl
command can be used to verify that NGINX is running on the host
port 8080 as expected.
$ curl localhost:8080
<IP_ADDRESS> - - [16/Oct/2018:09:34:25 -0400] "GET / HTTP/1.1" 200 612 "-" "curl/7.58.0" "-"
<!DOCTYPE html>

<title>Welcome to nginx!</title>

Welcome to nginx!

If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.

For online documentation and support please refer to
nginx.org.

Commercial support is available at
nginx.com.

Thank you for using nginx.

For more information about cni, check the cni specification.


Before Change
def fprop(self, x, **kwargs):
// TODO: before adding dataset augmentation, we didn"t have to do this.
// Why?
with tf.device("/CPU:0"):
out = tf.map_fn(
lambda ex: tf.image.per_image_standardization(ex), x)
return out
class Dropout(Layer):
After Change
def fprop(self, x, **kwargs):
// TODO: before adding dataset augmentation, we didn"t have to do this.
// Why?
axis = [1, 2, 3]
mean = tf.reduce_mean(x, axis=axis, keepdims=True)
variance = tf.reduce_mean(
tf.square(x), axis=axis, keepdims=True) - tf.square(mean)
variance = tf.nn.relu(variance)
stddev = tf.sqrt(variance)
num_pixels = tf.reduce_prod(tf.shape(x)[1:])


-
Livestream | Sea Shepherd USA
livestream.seashepherd.org
Follow our volunteer Cove Guardian Leader Dave Hance and his team as they live stream from Sea Shepherd's Operation Infinite Patience dolphin defense ...
-
Signaling Post-Snowden Era, New iPhone Locks Out N.S.A.
www.nytimes.com
Intelligence agencies say the move, in which the new iPhone creates a unique code that scrambles information, is the first of new technologies ...
-
Take Action: Frequently Asked Questions | Ric O'Barry's Dolphin Project
dolphinproject.org
Follow us on Facebook Twitter RSS
-
Bipolar and Proud: The Incredibly True Story of Andy Behrman
archive.causes.msn.com
As early as age seven, Andy Behrman knew something was wrong. Every night he would try to sleep like a "normal" kid, but the sound of his eyelashes ...
-
5 ways Washington DC is very different than Silicon Valley
gigaom.com
Silicon Valley and Washington D.C. are on opposite coasts and often seem like opposite worlds, but learning how they differ might help bridge some ...
-
Stunning Milky Way Time-Lapse Video: “Ancients”
www.slate.com
Regular readers know I love me some time-lapse video of the sky. I stumbled across a very cool one recently, and it’s well worth the 2.5 minutes of ...
-
Southern Democratic parties band together - Byron Tau
www.politico.com
Democrats of the South, unite!The Democratic parties of the 10 Southern states are banding together on a new collaborative project — just as national ...
-
Jerry Brown's Tough-Love California Miracle
www.rollingstone.com
The 75-year-old governor rescued the Golden State from financial ruin - and is reshaping a national progressive agenda
-
Find the Streaming Music Service that Works for You with This Chart
lifehacker.com
You have a ton of options for streaming music. From Pandora to Rdio, making the choice of which one is right for you isn't as easy as it seems. ...
-
Court Tells Reporter to Testify in Case of Leaked C.I.A. Data
www.nytimes.com
A federal appeals court ruled that James Risen, an author and a reporter for The New York Times, must testify against a former government official ...
-
How the Networks Will Cover the Zimmerman Verdict
www.hollywoodreporter.com
Network and cable news television are devoting significant airtime to covering the verdict of the George Zimmerman trial. The jury was reported to be ...
-
Boulder's Golden Spike being courted by Texas and Florida
www.denverpost.com
The small but ambitious Golden Spike Co. may not have a space vehicle, manufacturing plant or large payroll yet, but both Texas and Florida are ...
-
Gun violence protest, vigil set for Aurora movie theater shooting ...
www.thedenverchannel.com
A gun violence protest and vigil are planned on the anniversary of the mass shootings at an Aurora movie theater.
-
It’s Official: Administration Admits Obamacare’s a Job-Killer
conservativepapers.com
Bloomberg News reported this evening that the Obama Administration is set to announce a one-year delay in enforcement of Obamacare’s employer ...
-
WhiteHat Security - Senior Network Administrator
hire.jobvite.com
Senior Network Administrator - WhiteHat Security has an immediate opening for a Senior Network Administrator in IT. You will spearhead managing our ...
-
Theander gets 35 years: Judge not convinced prescription drugs caused Fort ...
archive.coloradoan.com
A Fort Collins woman whose defense blamed anti-depressants for causing her to knife her ex-husband to death was given 35 years in prison after a ...
-
Debate over E15 gasoline
www.thedenverchannel.com
WASHINGTON (AP) — It's a dilemma for drivers: Do they choose a gasoline that's cheaper and cleaner even if, as opponents say, it could damage older ...
-
New Ways to Gauge What Grown-Up Means
online.wsj.com
Marriage? House? Kids? Millennials are less likely to define adulthood by these traditional milestones, citing more amorphous goals like "accepting ...
-
For Anybody Hurting: A YouTube Video Confronts Darkness
mashable.com
When Eric Lim's sister committed suicide, she left him money to make a film. He made 'The Forge' to prevent others from making the same choice.
-
Twitter’s Nicole Wong joins White House as deputy chief technology officer
www.washingtonpost.com
Wong will work on Internet privacy, technology and related issues.
-
AMA awards $11 million to transform American medical education
pub.vitrue.com
Nearly a dozen medical schools named Friday by the AMA will receive funding to implement bold innovations in medical education over the next five ...
-
Michael Hastings, 'Rolling Stone' Contributor, Dead at 33
www.rollingstone.com
The bold journalist died in a car accident in Los Angeles
-
Obamacare will share personal health info with federal, state agencies | ...
washingtonexaminer.com
A new 253-page Obamacare rule issued late Friday requires state, federal and local agencies as well as health insurers to swap the protected personal ...
-
New Technology Allows the Mind to Control Prosthetic Limbs
mashable.com
Our brains, which control our movements, may soon be able to control the movement of prosthetic limbs as well.
-
Snowden's loose lips on NSA: A millennial generation thing?
communities.washingtontimes.com
Older generations know loose lips sink ships. Can we expect that from the Millennials? Probably not.
-
Daily Must Reads, June 12, 2013 | Mediashift | PBS
www.pbs.org
1. How Google transfers data to NSA (WSJ) 2. For some, the reaction to PRISM is a shrug: Are we suffering from Big Brother fatigue? (GigaOm) 3. Why ...
-
Too High To Fail: Inside Denver's Weed Boom
www.rollingstone.com
Welcome to the city where pot nerds are growing the new American economy
-
Google's Real Secret Spy Program? Secure FTP | WIRED
www.wired.com
Google does not participate in any government program involving a lockbox or other equipment installed at its facilities to transfer data ...
-
James Holmes can wear street clothes during movie massacre trial
articles.latimes.com
CENTENNIAL, Colo. -- The judge in James E. Holmes' murder trial in the Aurora movie theater massacre ruled Tuesday that the defendant can wear street ...
-
A journalist's guide to navigating fair use of copyrighted material
www.teleread.com
Morning Roundup: A journalist's guide to navigating fair use of copyrighted material


React-datasheet
Excel-like data grid component for react
View on GitHub
Download .zip
Download .tar.gz
Demo with raw data


|
Documentation
|
Introduction
Wapache is a software that lets you to create desktop applications using web development technology. It combines a modified version of the Apache 2 HTTP server with an embedded Internet Explorer web browser. Requests to the "web server" are handled internally. Data does not travel through the networking layer, ensuring quick response and reliable operation. Wapache also lets you control various browser settings, such as window dimensions and Javascript availability, giving you a consistent runtime environment. Wapache is distributed under the Apache License 2.0. Notable Features
Status
The current version of Wapache is 2.0.2. Note: There is no Wapache v.1. Versioning begins at 2 because the software is based on Apache 2.0. |


Sun Web Application Guidelines - Version 4.1
|
| Search Guidelines | Send Feedback | Developers.sun.com |
| [ Table of Contents | 0 Revision History | 1 Introduction | 2 Visual Design | 3 Windows and Pages | 4 Mastheads | 5 Top-Level Navigation | 6 Content Area | 7 Simple Elements | 8 Complex Elements | 9 Tables | 10 Topology | 11 Contextual Help | 12 Search | 13 Wizards | 14 Alerts and Messages | 15 Progress Indicators | 16 Alarms and Status Indicators | 17 Login Page | 18 Version Page | Appendices ] |
How To Use These Guidelines - An Introduction
11.1.1 Deciding Whether to Provide Inline Help
11.1.2 Positioning Inline Help
11.1.4 Including Links in Inline Help
11.2.1 Layout and Behavior of the Help Window
<IP_ADDRESS> Anatomy of the Help Window
<IP_ADDRESS> Sizing of the Help Window
<IP_ADDRESS> Window Title Bar in the Help Window
<IP_ADDRESS> Content-Area Title Pane in the Help Window
<IP_ADDRESS> Navigation Pane in the Help Window
<IP_ADDRESS> Topic Pane in the Help Window
11.2.2 Providing Access to Help-Window Help
11.4 Choosing the Correct Type of Help
11.4.1 Providing Help for Main Windows
11.4.2 Providing Help for Pop-Up Windows
11.5.2 Creating Longer Descriptions Using the HTML longdesc Attribute
11.5.3 Tool Tips for Sun Icons, Glyphs, and Graphics
11.5.4 A Note on HTML alt and longdesc Attributes for Tree Navigation Objects
11.5.5 Visual Design Considerations for Tool Tips
11.5.6 Tool Tips for Disabled Icons
11.5.7 Tool Tips for Icons With Alarm Badges
11.6.1 Invoking and Closing Pop-Up Bubbles
11.6.2 Pop-Up Bubble Content Details
The best way to help users is to provide a well-designed, easily-understood user interface (UI), one in which users can complete most tasks without assistance. However, even in a well-designed UI, you might need to display supplementary information known as "contextual help," commonly called just "help". For example, help displayed in a pop-up window or next to some key fields might assist new users in completing a complex page of your application. Contextual help assists users immediately, without requiring that they leave the context of their work.
For additional information about writing online help, see 1.4.5 Content Page Titles and Other UI Text.
Applications can display help in the following ways:
This chapter describes these types of help, explains when each is appropriate, and provides guidelines for creating them.
The types of help that are appropriate for a particular window depend on the window's type and the type of page that the window displays. To learn about window types and page types, see Chapter 3, Windows and Pages.
If users might not understand certain UI elements on a page, you can provide "inline help". Inline help consists of instructions, explanations, or links that display directly with the page's other elements. The following example shows inline help on a page.
As shown in the preceding example, inline help can consist of:
Inline help provides brief assistance to users, both where they need it and when they need it. Often, inline help is appropriate for windows whose content might confuse most new users or infrequent users. Inline help complements an application's other types of user assistance, for example, tool tips, error messages, labels on fields, and help displayed in pop-up windows. Inline help works best when the labels of UI elements, such as fields and controls, are descriptive and precise.
Note that in the previous example there are also links in the inline help, which enable the writer to provide additional help. To learn about these links, see 11.1.4 Including Links in Inline Help.
Before adding inline help to an application, you need to determine which parts of the application, if any, need inline help. The following guidelines help you decide whether to provide inline help. They also help you provide inline help correctly.
Before completing your UI design, consult a technical writer, a UI designer, or both, for ideas on where users might need inline help. By finding out early which parts of your design need inline help, you can sometimes eliminate that need by relabeling those parts or redesigning them. Before providing inline help in a page, verify that you cannot redesign the page to eliminate the need for inline help.
For each entry field that requests text, consider providing inline help if users might not know the valid format or values for that text. In the inline help, list the valid formats, show at least one example value, or do both. For example, inline help for a password field might be: "Passwords must be at least 10 characters long".
In wizards and other pop-up windows with help in their left pane, add inline help to the right pane only if the left-pane help does not suffice. For example, left-pane help usually would not suffice if users need help about one or more input fields. Those fields would need inline help.
Test the usability and accessibility of your inline help.
If you redesign a page that has inline help, verify that the inline help remains accurate and necessary.
The position of a page's inline help enables users to determine which inline help applies to which UI element.
Place inline help near the UI elements to which it relates. Follow these guidelines:
| Scope of the Inline Help | Correct Position |
|---|---|
| An entire page of an application | The top of the page, directly below
the title. Place the inline help in that position even if the page has controls for page actions or has
jump-to links for navigating to sections of the page. However, inline help is rarely necessary
before those elements. If
the page has no title, place the inline help directly below the page's masthead.
The inline help text can extend all the way from the left to the right margin of the page. |
| A page section that is titled or otherwise visually separated | The top of that section, directly below the title or separator. |
| A single entry field | Directly below the field. |
Among the factors that affect the usability of inline help is its formatting, especially, its font face, weight, size, and color. Use the Sun Common UI Component Library (in open source, the Project Woodstock components) to obtain the correct font style for inline help (see Appendix A, Component Library Information).
In inline help, use color only to highlight links. (The components for inline help in the Component Library automatically highlight links, using color.) For accessibility and other usability concerns, avoid using:
Do not place tables or inline images in inline help.
Do not explicitly format the line length or font size of inline help. If you are using the Component Library to create your inline help, allow the components to format the help automatically.
In inline help, avoid unnecessary line breaks and other layout techniques that waste vertical space.
One good way to keep inline help brief is to include "inline-help links," which are links within inline help. Inline help can consist of:
However, depending on the type of window and page, inline-help links might not be appropriate. For example, inline-help links are rarely appropriate in wizards. Before inserting links into your inline help, read the sections of this chapter relating to the type of window and page that you are working with.
When providing inline-help links, follow these guidelines:
In your application's overview of accessibility (see Appendix D, Accessibility), inform users that links in inline help open a new window. In addition, explain that links to additional help often begin with the word "More".
In inline help, do not display instructions that consist of more than three steps. Instead, link to those instructions. For example, "To set the properties of this object, follow these instructions".Also, do not use a vertical list for instructions consisting of fewer than three steps -- just give those instructions inline.
For readability and accessibility, ensure that no two inline-help links are touching each other.
In inline help, include a link only if that link's target is available whenever your application runs. For example, in inline help for a reusable UI component, such as a file chooser, provide a link to a particular help topic only if the file containing that topic is always accessible from the user's system. Provide links to the Web only if you can be sure that users have a connection to the Internet at that time.
If you link to a help topic from inline help, insert anchors in that help topic to ensure that the appropriate section is displayed at the top of the Help window's content area.
Do not include links in left-pane help.
Provide links in inline help only to display information that is too large to display inline. Ensure that each link's label precisely describes that link's target. For example, do not use the label "Help," which is too general. Instead, use a more specific label, such as "More password requirements".
In inline help, avoid including links to display just one additional line of text. Instead, try to fit that additional text inline. Alternatively, replace the inline help with a different type of help. For example, in certain pop-up windows, you might replace inline help with left-pane help.
If a passage of inline help is too long, create a title for it, and then display the title as inline help that links to the relevant help topic. For example, if a password field had lengthy requirements, you could provide a link labeled "Password requirements" instead of listing the requirements inline.
If your inline help includes links to definitions of terms, provide those definitions in a glossary. List that glossary as a first-level heading in the table of contents for your application's online help. For an example, see the example Help window in 11.2.1 Layout and Behavior of the Help Window.
In inline help, when linking from a term to its definition, ensure that the link opens that definition at the top of the target window's text area.
If a pop-up window has both inline help and left-pane help, do not include links in the inline help. Instead, consider either of the following approaches:
If a link ends a passage of inline help and provides additional information about that passage, place a More graphic () at the beginning of the link, as shown here:
Do not place a More graphic () before links in a phrase that includes nonlinked text.
When providing a link that begins with a More graphic () ensure that the link's label is specific. Do not use the word "More" alone as a link label.
For inline-help links, make the link's tool tip as specific as possible. For example, in the preceding figure, the tool tip for the "More on alarm severities" link might be:
Shows more help about alarm severities. (Opens a New Window)
When writing inline help, follow these guidelines:
Ensure that your inline help consists of only text and text links. Ensure that it does not include buttons or other UI controls.
In inline help, never use the phrase "click here".
To provide help on an entry field, do not make the field's label a link. Instead, provide inline help below that field, placing links in the inline help if needed.
In inline help, provide only information that the rest of the UI cannot, or does not, provide. State only what is not clearly visible or otherwise obvious. For example, for labeled fields, provide inline help only to add information that the label cannot convey.
Provide page inline help only if the user's task is not obvious. Do not provide page inline help for each page of your application merely to achieve consistent appearance.
Ensure that mastheads contain no inline help, other than the Help link in main window mastheads. For more information about main window mastheads, see 4.1 Main Window Masthead.
Ensure that your application's inline help is localizable, accessible, and grammatically correct. For accessibility, follow the guidelines in Appendix D, Accessibility.
Use sentence capitalization for all inline help. For more information, see 2.5 Text Capitalization. When referencing objects on the page, button names, for example, match their capitalization.
When writing instructions, start with what the reader can do, and then describe how to do it. For example:
"To stop the print job, click Stop."
When punctuating inline help, follow these guidelines:
When providing inline help, limit its length by following these suggestions:
| Scope of the Inline Help | Recommended Length |
|---|---|
| An entire page of an application | One to three short sentences |
| A page section that is titled or otherwise visually separated | One short sentence |
| A single entry field | One short sentence or, preferably, one phrase |
In instructions, use the imperative whenever possible.
INCORRECT: You can stop the print job by clicking Stop.
CORRECT: To stop the print job, click Stop.
Use precise verbs. For example, do not use "specify" if "choose," "type," or some other verb is clearer. In addition, use the verb "select" only where it is not ambiguous. In UIs, "select" is not an exact synonym for "choose". "Select" means "to designate one or more UI objects, typically for a subsequent action". For example, a user might select several files so that they can all be moved as a set. In contrast, a user might choose a command from a menu. Choosing a menu command does not designate it for a subsequent action, so "choose" is the correct verb.
Do not abbreviate "that is" and "for example" as "i.e". and "e.g." Spell out those terms, or, better yet, omit them. If a passage of inline help consists solely of examples, listed in a series, then start the passage with the word "Examples," followed by a colon and a space character, as shown here:
Examples: AND, OR, NOT
Not all help is brief enough to display on the page where users perform their task. To display more help, applications can open the Help window, as described in the following sections.
The Help window is a pop-up window that opens and displays help when users click:
Here is an example of the Help window:
Note: In this chapter's examples of the Help window, the help topics are intended only to show the window's UI elements. The topics are not necessarily from actual Sun products.
After the Help window first opens, it stays open until a user explicitly closes it.
Users can minimize the Help window. If a user minimizes the Help window, the Help window is restored when the user either:
To understand the Help window better, you might need information on the following topics:
For information on how to provide Help-window help correctly, see 11.2.2 Providing Access to Help-Window Help.
Ensure that your application displays only one Help window. For example, in a main window, a user might click the masthead's Help link, navigate to another page of the application without closing the Help window, and then click the masthead's Help link again. The help for that new page should be displayed in the existing Help window.
The Help window has the following parts, starting from the top:
As shown in the preceding example, the Help window's navigation and
topic panes are separated by a moveable vertical divider.
The divider enables users to widen one pane while narrowing the other,
without affecting the window's overall width.
The X at the top right of the
window, and the Close button at the bottom right, both provide the same
function, to close the window.
When the Help window is initially displayed, it is 750 pixels wide and 500 pixels tall, but users can resize the window. If a user resizes the Help window, the window behaves as follows:
In the Help window, ensure that the window title bar conforms to the guidelines for pop-up windows. For more information, see Chapter 3, Windows and Pages.
In the Help window, ensure that the content-area title pane contains only the content area's title, which is "Help". In addition, ensure that the title is text, not a graphic, so that it can be translated.
The navigation pane is a tabbed pane with tabs labeled as follows, in left-to-right order:
Note:The tabs of the Help window's navigation pane differ visually from tabs described elsewhere in these Guidelines (see 5.2 Tabbed Panes Details for more information).
If the navigation pane's content extends beyond the pane, horizontal scrollbars, vertical scrollbars, or both are displayed in the pane. Text in the navigation pane does not wrap. Therefore, try to name navigational elements to avoid these scrollbars.
Contents Tab:
The Contents tab is the far-left tab of the Help window's navigation pane. By default, the Contents tab
is the pane's active tab, as shown in the preceding example.
Within the Contents tab, applications display their Table of Contents (TOC) as a collapsible navigation tree.
Each node of the tree includes a text link to a help topic. Users can display that topic
in the Help window's topic pane by clicking the link. If a user clicks a link in the TOC, the Help window
highlights that link's node in the TOC and displays the link's target (the text of a help topic) in the topic pane (the
right pane).
In the TOC, all container nodes are open by default. (Container nodes in the contents tab contain subtopics.) However, users can close each container node individually by clicking that node's navigation control.
Unlike nodes in typical navigation trees, nodes in a TOC have no graphic. Another difference between a TOC and typical navigation trees is that the background color of a TOC is white, as shown in the preceding example. For more information about container nodes, see 5.1.4 Tree.
Divide help into multiple topics. Include each major topic, with its subtopics, in its own container node.
Index Tab:
The Index tab is the middle tab of the Help window's
navigation pane, as shown in the following example:
The Index tab enables users to:
Typically, the only help topics indexed are for the application from which the Help window was opened.
The Index tab is inactive until a user clicks it, making it the active tab. Activating the Index tab or deactivating it does not affect the Help window's topic pane.
The Index tab displays an index as a navigation tree. Each node of the tree is either:
In indexes, all container nodes are open by default. However, users can close each container node individually by clicking that node's navigation control.
Unlike nodes in typical navigation trees, nodes in indexes have no graphic. Another difference between indexes and typical navigation trees is that the background color of indexes is white, as shown in the preceding example. For more information about container nodes, see 5.1.4 Tree.
Indexes have vertical and horizontal scrollbars, but only if the index is longer or wider than the navigation pane.
The index entry is highlighted when the user clicks the link, and the associated help topic is displayed.After a user clicks an index entry, thereby displaying the corresponding help text in the topic pane, that text remains displayed until the user either:
If a user switches among the tabs, the highlighted selection in the navigation pane is removed, so there is no conflict between what is selected in the tab and what is displayed in the topic pane. For example, if a user clicks an item in the index (and displays its topic) and then switches to the Table of Contents, the Table of Contents would have no highlight when initially displayed.
Maintaining an appropriate selection (with highlighting) when switching tabs is something that might be addressed in a future release of the guidelines and this component.
Search Tab:
The Search tab is the far-right tab of the Help window's navigation pane, as shown in the following example:
The Search tab enables users to type a query and then view the titles of help topics whose full text contains matches for that query. The only topics searched are those of the application from which the Help window was opened.
As shown in the preceding example, the UI elements of the Search tab are:
A horizontal rule separates the Results text area from the UI elements above it.
The Search tab is inactive until a user clicks it, making it the active tab. Activating the Search tab does not affect the Help window's topic pane (the right pane). However, if a user clicks a link in the Search tab, the corresponding help text is displayed in the topic pane, as shown in the following example:
The link that the user clicks can be either:
On the Search tab, links are the only UI controls that affect the Help window's topic pane.
The Search input field is where users type their query. The Search input field is blank until a user starts typing in it. If a user's query is too long to display in the input field, the query scrolls to the left as the user types. If the user moves the cursor back, the query scrolls to the right when the cursor reaches the left border of the input field.
The Search input field has no visible label but does have an HTML title attribute for accessibility. The value of that title attribute is "Search input field". For more information about the HTML title attribute, see the description of it on the World Wide Web Consortium's web site at:
http://www.w3.org/TR/REC-html40/struct/global.html#adef-title
The Search input field's inline help consists of a link labeled "Tips on Searching". Clicking the link opens the corresponding help text in the topic pane, as shown in the following example:
The inline help link's corresponding help text is not a "help topic" in the strict sense. It is not included in the Help window's table of contents or in the results of queries.
Directly to the right of the Search input field is a right-justified command button labeled "Search". Clicking the Search button performs the search. Users can also perform a search by pressing Return or Enter while input focus is in the Search input field.
If a user clicks the Search button while the Search input field is empty, a message is displayed directly in the Results text area, top justified. That message is "The search found no results". The same message is displayed if no help topics match the query that a user types, as shown in the following example:
If one or more help topics match the user's query, the titles of those topics are listed in the Results text area, which occupies the remaining portion of the Search tab.
Until a user performs a first query, the Results text area is blank. If the user performs a query for which there are matches:
Each title in the list is a link. Clicking a title displays the corresponding help topic in the Help window's topic pane. Except for clicking the title of a help topic or clicking a link in inline help, user actions performed in the Search tab do not affect the Help window's topic pane.
Search results remain displayed until a user performs a subsequent search. The same is true of messages displayed in the Results text area. Search results and messages remain displayed even if a user deactivates the Search tab and then reactivates it. To deactivate the Search tab, users activate the Contents tab or the Index tab.
The Results text area displays vertical and horizontal scrollbars but only when the list of titles is longer or wider than the text area.
The topic pane consists of a horizontal toolbar pane above a text area, as shown in the preceding example. The toolbar pane never scrolls; it always remains visible in the window.
The toolbar buttons are, from left to right:
These buttons are all icons.
The following table shows the tool tip for each button:
| Button Name | Tool Tip |
|---|---|
| Back | Go Back |
| Forward | Go Forward |
If the text pane's content is longer than the text pane, vertical scrollbars are displayed in the text pane as needed. If the content is wider than the text pane, text wraps to the pane's current width. If graphics extend beyond the pane, the pane displays horizontal scrollbars as needed.
The topic pane is never blank. It always displays a user's most recently chosen page until the user requests a different page and that new page is displayed. When the Help window first opens, the topic pane displays the page associated with the link that opened the Help window.
When providing access to Help-window help, follow these guidelines:
In main windows, ensure that the masthead's Help link opens
the Help window and displays information specific to the main
window, typically about its content area. For information about
the content area of windows, see Chapter 3, Windows and Pages.
When writing a help topic about a particular page of an application, keep in mind that users might not have that page displayed while reading the help topic.
In main windows with tabs or panes, ensure that the masthead's Help link is context-sensitive to the user's current tab or pane. If necessary, place anchors in your help file so that you can link directly to sections about each tab or pane.
In indexes, provide no more than three levels of entries. If possible, provide no more than two levels.
Keep index entries short, so that users need not resize the navigation pane or scroll it horizontally.
Do not include page numbers in index entries.
Use the Help window only to display help topics that get installed with your application. To display books, external web sites, or other external information, open a window other than the Help window.
When you map topic IDs to the URLs of your help set, ensure that each topic ID would remain unique even if your help set were merged with another help set. (For information about ID mapping and merged help sets, see the documentation for Sun's JavaHelpTM software.)
Some applications open pop-up windows used as dialog pages or wizards. Some of these windows are divided into left and right panes, as shown here:
In these pop-up windows, the left pane can display help about the window. Help displayed in this way is called "left-pane help". By default, the left pane, also known as the "help pane," occupies 35 percent of the entire window's width. Users can resize the entire window, causing the left and right panes to change their size while retaining their proportions relative to each other.
Provide left-pane help only in pop-up windows that display either:
In wizards where the left pane can display information about each of the steps, display help in the left pane by providing a tab labeled "Help," as shown here:
Ensure that, by default, the Steps tab is the active tab. For more information about providing left-pane help in wizards, see Chapter 13, Wizards.
If the wizard does not need help on any step, remove both tabs
from the wizard and show just the Steps in the left pane, as shown here:
If one or more steps of a wizard need help, the help tab should always be
available (even if the user might
never visit the step that needs
help because the wizard has branched). For individual steps that do not require left-pane help, the
writer should provide text, to indicate that this is not just blank
space. Most often this can be useful
information about the right side pane. In the rare case where there is
absolutely no information to provide, the text can say something like
"Click Next to proceed". or "Complete entries and continue to the next
step".
You can provide help for your application's pages in one or more of the following ways:
This section helps you choose the best way to provide help other than tool tips. For guidance on providing tool tips, see 11.5 Tool Tips.
The best way to provide help depends on factors such as whether:
All main windows have a Help link in their masthead. That link opens the Help window, as described in 11.2 Help-Window Help. Optionally, pages in main windows can include inline help.
Do not provide left-pane help in main windows.
In main windows where users likely need help, provide an inline-help link to display the same page that users can open using the Help link in the masthead. Ensure that the inline-help link's label is descriptive and includes the phrase "about this page" or a more specific phrase. For example, the link's label might be: "For instructions, read the help topic about this page".
Pages in pop-up windows can include inline help, left-pane help, or both. In pop-up windows, no page has a Help link in its masthead.
In pop-up windows, provide help only if users need it.
When providing help for a pop-up window:
Tool tips are small rectangles of text that provide a short description of a UI element or area. On the web, tool tips can be applied to elements such as icons, entry fields, and buttons.
In HTML, tool tips are created by specifying title text for the HTML title attribute.
This is how a tool tip, produced with title text, would look when the user mouses over an image:
For more information, see the description of the HTML title attribute on the World Wide Web Consortium's web site at:
http://www.w3.org/TR/REC-html40/struct/global.html#adef-title
Note: There is a difference between a tool tip, produced with the HTML title attribute, and alternative text, produced with the HTML alt attribute. Alt text is required to provide a description of every graphic. It is imperative that it be present for visually-impaired users who use screen readers. It is also useful where graphics are not rendered, for example, when users have image loading turned off. In such situations, Alt text enables users to selectively download graphics.Use the HTML alt attribute to define Alt text for all images, including decorative images. Use both the HTML alt attribute and the HTML title attribute for all interactive graphics and for graphics that users might not understand without a description. For example, any clickable icon (such as an alarm icon or a pagination arrow) should have both the HTML alt and title attributes set. In contrast, the hierarchy lines of a tree control should use only the alt attribute.
Write the HTML Alt text so that it concisely
states the function of the image.
Do not use tool tips as a substitute for other forms of help.
Provide a tool tip for each button or link that opens a new window. Ensure that the tool tip ends with this parenthetical phrase: (Opens a New Window). Use headline capitalization for the parenthetical phrase, regardless of the tool tip's length.
EXAMPLE: Print the first column of this table. (Opens a New Window)
Provide a tool tip for each icon and graphical button (even those that do not open a new window).
In tool tips that begin with a verb, use the imperative form, if possible:
USE: Print Table Row
NOT: Prints Table Row
A tool tip for a graphical element should describe that element; it should not provide other
help about an application. The HTML Alt text for images should reflect that distinction.
In most browsers, tool tips are displayed for only a few seconds. Sighted users need to read a tool tip within that brief time.
Keep the length of tool tip text as short as possible. For accessibility, ensure that no tool tip is longer than 150 characters when displayed in English.
To avoid confusion, do not use terms such as "Back," "Home," or "Forward" in tool tips. An exception is any tool tip for a control that behaves exactly the same as the browser's control labeled with that term.
The HTML longdesc attribute, part of HTML 4.01 and supported by some browsers, is intended for users who use screen readers. For elements other than text, you can use the longdesc attribute to provide a longer description than can otherwise be provided with the HTML alt attribute. However, not all screen readers recognize the longdesc attribute. Unlike Alt text, the Longdesc text is presented only when users using a screen reader explicitly request more information.
In the following image, the HTML alt attribute is "Disk Partitions". The HTML longdesc attribute refers to the file "chart.html," which reads as follows:
This is a visual indication of the partitioning of a disk. Each slice on the disk appears with a width relative to its space on the disk. Slice 2 occupies the whole disk. There is some free space between slices 1 and 3. Free space appears in white, while used space appears in a pink color.
When a short text equivalent does not adequately convey the function or role of an image, provide additional information in a file designated by the HTML longdesc attribute.
Provide the HTML longdesc attribute for an image if the image conveys information that is too long to present by way of the HTML alt attribute or the HTML title attribute.
For information about tool tips for the Sun icons, glyphs, and graphics used within the components see the Sun Common UI Component Library (in open source, the Project Woodstock components).
In tree navigation, turners use HTML Alt text and HTML Title text to indicate their expanding and collapsing behavior. Since turners convey much information about the tree state and interaction possibilities, they also use the HTML longdesc attribute to describe to screen reader users how to interact with the turners. They also use the longdesc attribute to describe the state of the tree.
Tree hierarchy lines use the HTML longdesc attribute to indicate their purely visual function. For more information about tree navigation objects, see 5.4.2 Tree Look and Feel.
Some browsers enable users to increase the font size used to display tool tips, even without requiring users to change the browser's other font-size settings. Long tool tips can become unreadable when displayed in a larger font size.
When creating text for tool tips, make it as brief as possible.
Use headline capitalization for short tool tips. Use sentence capitalization for longer tool tips. See 2.5 Text Capitalization.
Make tool tips for disabled icons indicate the disabled state.
Indicating that an icon is currently disabled is helpful to users. For example: "Go to Next Page (Unavailable)".
Icons are sometimes overlayed with a "badge". A badge is a small graphic superimposed over a corner of an icon, typically to indicate an alarm. Badged icons are often displayed in trees. For more information on badges and alarms, see <IP_ADDRESS> Alarms.
If an icon is badged with an alarm (for example, this icon: ), make its tool tip indicate both the icon's meaning and its alarmed state. Use brackets around the portion of the tool tip that indicates the alarmed state. For example:
This is how a tool tip for an icon with a critical alarm badge would appear:
In addition to <IP_ADDRESS> Direct Table Sorting, the following resources discuss tool tips and describe how to use HTML Alt text:
The Pop-Up Bubble is a user interface element that allows the end user to see context-sensitive information pertinent to a certain area of the screen. The end user hovers (places the mouse pointer) over an object (for example, a label, image, or link) for some time, and a pop-up bubble appears with additional information that is appropriate to that context. Use the pop-up bubble judiciously, however, so that the pop-up bubbles do not interfere with the user's interaction with the page.
Avoid a situation where the user is unable to move their mouse without unintentionally opening a bubble.
Limit the number of objects that will generate a bubble to 5 or fewer in a single page.
Display only one pop-up bubble at a time on a given page.
A basic pop-up bubble is comprised of the following elements:
Include a title bar and left-justified title in the pop-up bubble. The title gives the user some context about the information provided in the pop-up bubble.
If a title bar is included, the following two guidelines apply:
Include a pop-up bubble title that uses headline capitalization. See 2.5 Text Capitalization.Include a Close button on the right side of the title bar of the pop-up bubble. This control allows the user to close the pop-up bubble when it is clicked.
Strive for consistency within your application regarding whether or not a title bar and close button are included in pop-up bubbles.
Place the context-sensitive information in the body of the pop-up bubble. This information must pertain to the object that the user hovered over.
A pop-up bubble can contain help information, instructions, descriptions, details, or any other useful information that pertains to the object that the user hovered over. The information may be displayed in various formats as well. For instance, the information may be displayed as straight text, label/value pairs, may include images and links, and may even include other user interface elements.
Because of the different kinds of content that can be contained within a pop-up bubble, this user interface element lends itself to situations where field inline help is not sufficient. Some disadvantages of field inline help are that it is limited to text and links, it should be kept very concise, and it can add clutter to a page. However, field inline help does have some important advantages over the pop-up bubble in that it is always visible and does not require a user action for the user to obtain the information. For these reasons, field inline help should be considered before deciding to use the pop-up bubble.
Use field inline help unless the information content cannot be conveyed adequately inline or when using field inline help would clutter the page. In these situations, the pop-up bubble is a good option for providing the user with context-sensitive information.
When additional information is warranted, and field inline help is insufficient, make pop-up bubbles available when the user hovers over text (including labels), links, or images.
Display pop-bubbles after the user hovers over an object for 1/2 second.
Make the size of the pop-up bubble no more than half the size of the main window that it appears over. Typically, however, it will be substantially smaller than that.
Do not include scrollbars or allow scrolling in the pop-up bubble.
Position the pop-up bubble to the top right of the invoking object. If the bubble will be obscured by the edge of the browser, reposition it to a more suitable location - top left, bottom right or bottom left, as appropriate.
Below is an example of a pop-up bubble displayed just above and to the right of a link object.
Do not make pop-up bubbles available on components themselves. Make the pop-up bubble available for a component's label instead. For example, make a pop-up bubble available for a text field's label instead of making it available when the user hovers over the text field itself. This way, the availability of a pop-up bubble does not interfere with the interaction of the user with the component.
Place a pop-up bubble icon, , to the top right of labels, links, and other text to indicate that a pop-up bubble is available. When the user hovers over this icon, display the same pop-up bubble that is available for the object.
Images which have bubbles should display the pop-up bubble icon when users would not expect this additional information to be provided (expecting to only find a tool-tip when hovering).
If a pop-up bubble is available for a label that is also marked with a required field indicator (see 7.3.2 Editable Text Fields), place the pop-up-bubble icon before the required field indicator.
Continue to display the pop-up bubble as long as the user keeps the mouse pointer within the pop-up bubble or over the object that invoked the bubble.
Dismiss the pop-up bubble when any of the following occur:
Do not include large or complex user interface elements such as an add-and-remove element or table within the body of the pop-up bubble. See Chapter 8, Complex Elements and Chapter 9, Tables for more information about complex elements and tables.
Include simple user interface elements within the body of the pop-up bubble when it is appropriate. See Chapter 7, Simple Elements for more information about simple user interface elements.
Place a link beginning with "More" at the end of the pop-up bubble text if the user needs to see more information. When the "More" link is clicked open a new window that presents the additional information. Typically, clicking the "More" link will display the associated section of the online help.
Phrase the link so that it describes the information the user will get when the link is pressed. For example, use "More server information" versus simply using "More".
Place a More graphic () at the beginning of the link, as shown here:
.
Make the "More" link's tool tip as specific as possible. For example, the tool tip for a "More server information " link might be:
Shows more information about the server. (Opens a New Window)
When the "More" link is clicked, dismiss the pop-up bubble unless the material in the new window that is displayed has content that is needed in conjunction with the information in the pop-up bubble, or if is important for the user to be able to return to the original window with the pop-up bubble still displayed.
Enabling the pop-up bubble to remain displayed when a new window is invoked makes it such that upon return to the pop-up bubble, the user cannot simply move the mouse pointer outside of the bubble to close it. The user must explicitly click the Close button, click outside of the bubble, or invoke another pop-up bubble to dismiss the pop-up bubble.
Use caution when deciding to keep a pop-up bubble displayed when a new window is invoked. If all pop-up bubbles within a page or application do not behave the same way, the user may notice the inconsistency and it could be confusing.
To enable the pop-up bubble to remain displayed when a new window is invoked, set the "autoClose" attribute to: autoClose="false".
| [ Table of Contents | 0 Revision History | 1 Introduction | 2 Visual Design | 3 Windows and Pages | 4 Mastheads | 5 Top-Level Navigation | 6 Content Area | 7 Simple Elements | 8 Complex Elements | 9 Tables | 10 Topology | 11 Contextual Help | 12 Search | 13 Wizards | 14 Alerts and Messages | 15 Progress Indicators | 16 Alarms and Status Indicators | 17 Login Page | 18 Version Page | Appendices ] |
| Privacy Policy | Terms of Use | Trademarks | Copyright 2007 Sun Microsystems, Inc. |


Double API Monitor
Your API Data
Response
API 1
API 2
Number of Errors
Number of Successful Test
Average Response Time
Download Data
Download Graph
Force re-render graph
Your test will run for more


Have we missed something? Any corrections or other feedback?
We want Occupied City to be accurate as well as engaging – please let us know how we're doing!
This site is open source, which means anybody can improve or fix the code, data and sources. We'd love your contributions. Fork us on GitHub!
If you're not technical but want to suggest a change you can still submit an issue, or email<EMAIL_ADDRESS>with any suggestions.


[Website feature] isn't working.
First of all, that isn't actually a question. But, I understand that things break sometimes, so please go to the
contact page to yell at me about it. I'll see what I can do.
Why isn't [county, municipality, school district] included?
Sorry about that! I first published the site for public access on June 6th, 2017, so I'm trying to figure out how to automatically acquire all of the various millages legally
(it's a
big deal). On top of that, I'm doing this first and foremost to help out my mom and her real estate agency (which will not be named
because lawsuits!) which is in the Greater Pittsburgh Area (I've already said too much, if you don't hear from me, I'm likely ---
Why did you make this?
 She works in Real Estate, and she says that searching for millages is a pain. I figured I could make use of what I knew,
and try to learn a little bit more about web applications programming, and make things a little easier for people.
So, why did you make it the way you did?
Great question! Basically, I thought of how someone would go about finding these values themselves, and the best way to transfer it to an application (as of writing this) was to
make a series of drop-down lists with the various municipalities and school districts that a house could be in. It would be redundant to include counties as a selection,
since the municipality determines which county the house resides in.
As an aside, I really hope to get Google Maps functionality included so that you can type in the address of the home and the millages just pop right in, but I truly have no idea where to begin with that.

This is incredibly useful and I love it! Why is it free?
Plain and simple: I hate charging people for things, and all I'm really doing is looking up the publicly accessible millages and putting them in an easy-to-use interface. Anyone (yes, anyone) can take the
time to learn how to do this (it's actually a lot of fun to learn programming! Do it!), and charging for it is just rude. Maybe if any Real Estate Brokers would like to mention this site to their Agencies *cough cough*
I could actually make a little bit off of this site! But it's no big deal, I'm used to eating Ramen Noodles breakfast-lunch-dinner.
What can't you do?
Get an internship, apparently ;) (If you don't want to buy the site, you could always help me get the ball rolling in that area)
{% endblock %}


The action triggered by the action event originating from this widget.
The id of the next view or state, which is the result or destination of the transition triggered by an event.
| alpha | CGFloat |
| animationDuration | NSTimeInterval |
| animationImages | NSArray |
| animationRepeatCount | NSInteger |
| backgroundColor | UIColor |
| contentScaleFactor | CGFloat |
| hidden | BOOL |
| highlighted | BOOL |
| highlightedAnimationImages | NSArray |
| highlightedImage | UIImage |
| image | UIImage |
| opaque | BOOL |
| transform | CGAffineTransform |
The receiver?s alpha value.
The amount of time it takes to go through one cycle of the images.
An array of UIImage objects to use for an animation.
Specifies the number of times to repeat the animation.
The receiver?s background color.
The scale factor applied to the view.
A Boolean value that determines whether the receiver is hidden.
A Boolean value that determines whether the image is highlighted.
An array of UIImage objects to use for an animation when the view is highlighted.
The highlighted image displayed in the image view.
The image displayed in the image view.
A Boolean value that determines whether the receiver is opaque.
Specifies the transform applied to the receiver, relative to the center of its bounds.
| adjustViewBounds | boolean |
| alpha | float |
| background | int |
| baseline | int |
| baselineAlignBottom | boolean |
| clickable | boolean |
| contentDescription | String |
| cropToPadding | boolean |
| fadeScrollbars | boolean |
| focusable | boolean |
| focusableInTouchMode | boolean |
| hapticFeedbackEnabled | boolean |
| isScrollContainer | boolean |
| keepScreenOn | boolean |
| layoutDirection | int |
| longClickable | boolean |
| nextFocusDown | int |
| nextFocusForward | int |
| nextFocusLeft | int |
| nextFocusRight | int |
| nextFocusUp | int |
| paddingEnd | int,int,int,int |
| paddingStart | int,int,int,int |
| requiresFadingEdge | boolean |
| rotation | float |
| rotationX | float |
| rotationY | float |
| saveEnabled | boolean |
| scaleType | ImageView.ScaleType |
| scaleX | float |
| scaleY | float |
| scrollbarDefaultDelayBeforeFade | int |
| scrollbarFadeDuration | int |
| scrollbarSize | int |
| scrollbarStyle | int |
| soundEffectsEnabled | boolean |
| src | int |
| textAlignment | int |
| tint | int,PorterDuff.Mode |
| transformPivotX | float |
| transformPivotY | float |
| translationX | float |
| translationY | float |
| visibility | int |
Set this to true if you want the ImageView to adjust its bounds to preserve the aspect ratio of its drawable.?
alpha property of the view, as a value between 0 (completely transparent) and 1 (completely opaque).?
A drawable to use as the background.?
The offset of the baseline within this view.?
If true, the image view will be baseline aligned with based on its bottom edge.?
Defines whether this view reacts to click events.?
Defines text that briefly describes content of the view.?
If true, the image will be cropped to fit within its padding.?
Defines whether to fade out scrollbars when they are not in use.?
Boolean that controls whether a view can take focus.?
Boolean that controls whether a view can take focus while in touch mode.?
Boolean that controls whether a view should have haptic feedback enabled for events such as long presses.?
Set this if the view will serve as a scrolling container, meaing that it can be resized to shrink its overall window so that there will be space for an input method.?
Controls whether the view's window should keep the screen on while visible.?
Defines the direction of layout drawing.?
Defines whether this view reacts to long click events.?
Defines the next view to give focus to when the next focus is FOCUS_DOWN If the reference refers to a view that does not exist or is part of a hierarchy that is invisible, a RuntimeException will result when the reference is accessed.?
Defines the next view to give focus to when the next focus is FOCUS_FORWARD If the reference refers to a view that does not exist or is part of a hierarchy that is invisible, a RuntimeException will result when the reference is accessed.?
Defines the next view to give focus to when the next focus is FOCUS_LEFT.?
Defines the next view to give focus to when the next focus is FOCUS_RIGHT If the reference refers to a view that does not exist or is part of a hierarchy that is invisible, a RuntimeException will result when the reference is accessed.?
Defines the next view to give focus to when the next focus is FOCUS_UP If the reference refers to a view that does not exist or is part of a hierarchy that is invisible, a RuntimeException will result when the reference is accessed.?
Sets the padding, in pixels, of the end edge; see padding.?
Sets the padding, in pixels, of the start edge; see padding.?
Defines which edges should be faded on scrolling.?
rotation of the view, in degrees.?
rotation of the view around the x axis, in degrees.?
rotation of the view around the y axis, in degrees.?
If unset, no state will be saved for this view when it is being frozen.?
Controls how the image should be resized or moved to match the size of this ImageView.?
scale of the view in the x direction.?
scale of the view in the y direction.?
Defines the delay in milliseconds that a scrollbar waits before fade out.?
Defines the delay in milliseconds that a scrollbar takes to fade out.?
Sets the width of vertical scrollbars and height of horizontal scrollbars.?
Controls the scrollbar style and position.?
Boolean that controls whether a view should have sound effects enabled for events such as clicking and touching.?
Sets a drawable as the content of this ImageView.?
Alignment of the text.?
Set a tinting color for the image.?
x location of the pivot point around which the view will rotate and scale.?
y location of the pivot point around which the view will rotate and scale.?
translation in x of the view.?
translation in y of the view.?
Controls the initial visibility of the view.?


Comparison constraints are able to test whether one value is greater or less than another. Comparison constraints work on numeric values, as well as other objects that implement the IComparable interface or - beginning with NUnit 2.5 - IComparable<T>.
Beginning with NUnit 2.5, you may supply your own comparison algorithm through the Using modifier.
Tests that one value is greater than another.
GreaterThanConstraint(object expected)
Is.GreaterThan(object expected)
...Using(IComparer comparer) ...Using(IComparer<T> comparer) ...Using (Comparison<T> comparer)
Assert.That(7, Is.GreaterThan(3)); Assert.That(myOwnObject, Is.GreaterThan(theExpected).Using(myComparer));
Tests that one value is greater than or equal to another.
GreaterThanOrEqualConstraint(object expected)
Is.GreaterThanOrEqualTo(object expected) Is.AtLeast(object expected)
...Using(IComparer comparer) ...Using(IComparer<T> comparer) ...Using (Comparison<T> comparer)
Assert.That(7, Is.GreaterThanOrEqualTo(3)); Assert.That(7, Is.AtLeast(3)); Assert.That(7, Is.GreaterThanOrEqualTo(7)); Assert.That(7, Is.AtLeast(7)); Assert.That(myOwnObject, Is.GreaterThanOrEqualTo(theExpected).Using(myComparer));
Tests that one value is less than another.
LessThanConstraint(object expected)
Is.LessThan(object expected)
...Using(IComparer comparer) ...Using(IComparer<T> comparer) ...Using (Comparison<T> comparer)
Assert.That(3, Is.LessThan(7)); Assert.That(myOwnObject, Is.LessThan(theExpected).Using(myComparer));
Tests that one value is less than or equal to another.
LessThanOrEqualConstraint(object expected)
Is.LessThanOrEqualTo(object expected) Is.AtMost(object expected)
...Using(IComparer comparer) ...Using(IComparer<T> comparer) ...Using (Comparison<T> comparer)
Assert.That(3, Is.LessThanOrEqualTo(7)); Assert.That(3, Is.AtMost(7)); Assert.That(3, Is.LessThanOrEqualTo(3)); Assert.That(3, Is.AtMost(3)); Assert.That(myOwnObject, Is.LessThanOrEqualTo(theExpected).Using(myComparer));
RangeConstraint(IComparable from, IComparable to)
Is.InRange(IComparable from, IComparable to)
...Using(IComparer comparer) ...Using(IComparer<T> comparer) ...Using (Comparison<T> comparer)
int[] iarray = new int[] { 1, 2, 3 } Assert.That( 42, Is.InRange(1, 100) ); Assert.That( iarray, Is.All.InRange(1, 3) ); Assert.That(myOwnObject, Is.InRange(lowExpected, highExpected).Using(myComparer));


BEC/BPL
The cost of electricity is an important economic issue. Power rates in The Bahamas are among the highest in the Latin American/Caribbean region. Virtually every economic study has suggested that the cost of electricity is a burden on the population and an impediment to improving economic performance and the private sector. One particular challenge is that the country uses petroleum-based fuel to produce most of its electricity to the point where petroleum imports equated to 11% of The Bahamas’ gross domestic product in 2011.
- State of the Nation Report, page 46
The Bahamas Electrical Corporation (BEC) was a government corporation that was the primary electricity provider in the Bahamas. They operated power plants at 25 locations throughout the Bahamas.
In May 2015, the government announced that it would grant management of BEC to Power Secure International for a transitional fee of $900,000 and signed a 5 year service agreement in February 2016. Three weeks after the signing of that agreement, Power Secure announced that it was being purchased for $431 million by The Southern Company (who were previously the majority shareholder of Freeport Power).
The government incorporated a new company, Bahamas Power and Light (BPL), that is wholly owned by BEC in order to “allow BEC to split off its generation, transmission and distribution duties and prepare for ring-fencing the utility’s million-plus legacy debt.” And so BEC became a corporate shell. Power Secure would now be managing BPL and hired senior executives who would serve under a Bahamian board of directors. - Referenced from Bahamas Ecoforum
Leadership
BPL’s CEO is Pamela Hill who has held positions at a variety of other energy companies. “She replaces Jeff Wallace, who resigned from the post suddenly, citing ‘personal reasons’, just weeks after the deal between the government and Power Secure International - BPL’s parent company - was struck, and practically days after it was announced that Power Secure had been sold to Atlanta-based Southern Company.”
Leslie Miller was the last Executive Chairman for BEC and thus often surrounded by some controversy when things went wrong. “During his tenure as chairman, Mr. Miller was involved in a series of controversial incidents at the loss-making corporation, including public spats with BEC’s union leaders over overtime pay to employees and the revelation that he and his family-owned business owed the company more than $100,000. Union leaders repeatedly called for him to be fired during his time at the corporation.” Ref
BEC operates 29 generating plants in 25 island locations as of 2016. Ref
” Further, there are several pressing issues within the Bahamas Electric Corporation (BEC). Given the archipelagic nature of the country, BEC has a low customer to staff ratio at 93 customers per employee as opposed to 175 in Grenada, 224 in Barbados and 415 in Jamaica. Additionally, the system losses at BEC are about 15%, the highest in the region.” State of the Nation Report, page 46
The worst is both categories.
“Maintenance of generators has been problematic and service is unreliable, such that many more businesses in The Bahamas have emergency generators than their counterparts in the Caribbean. Although the government has embarked on a programme to reform the power sector, there are few energy conservation measures in place. Nonetheless, the recent appointment of a private sector firm to help overhaul BEC provides some basis for optimism.” State of the Nation Report, page 48


unbalanced: Racing for Unbalanced Methods Selection
A dataset is said to be unbalanced when the class of interest (minority class) is much rarer than normal behaviour (majority class). The cost of missing a minority class is typically much higher that missing a majority class. Most learning systems are not prepared to cope with unbalanced data and several techniques have been proposed. This package implements some of most well-known techniques and propose a racing algorithm to select adaptively the most appropriate strategy for a given unbalanced task.
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=unbalanced
to link to this page.


“WHO DARES DISTURB ME !?”, thundered a voice from the near the hearth. Frightened, you step forward,
“Are you the wizard that hails from Karoun, all powerful and knowing?”
“I DO NOT KNOW WHO I AM! DO YOU?”, comes the response.
A cat on the mantle suddenly speaks:
“A spell he cast, to bind and break
A charm that was to memory take,
Backfire it did on the wizard age old,
And now he can’t tell roof from floor,
Match the tiles which form a pair of two,
Repair the wizard is all I ask of you.”


The Forest Hiker
Easy 5-day tour
Breathtaking hike through the Canadian Banff National Park
Banff, Canada
April 2021
3 stops
25 people
The Sea Explorer
Medium-difficult 7-day tour
Exploring the jaw-dropping US east coast by foot and by boat
Oregon, US
June 2021
4 stops
15 people
The Snow Adventurer
Difficult 3-day tour
Exciting adventure in the snow with snowboarding and skiing
Aspen, USA
January 2022
2 stops
10 people
The City Wanderer
Easy 7-day tour
Living the life of Wanderlust in the US' most beatiful cities
NYC, USA
March 2021
3 stops
20 people
The Park Camper
Medium-Difficult 10-day tour
Breathing in Nature in America's most spectacular National Parks
Las Vegas, USA
August 2021
4 stops
15 people
The Sports Lover
Difficult 14-day tour
Surfing, skating, parajumping, rock climbing and more, all in one tour
California, USA
July 2021
5 stops
8 people