Source code for pymodbus.events
'''
Modbus Remote Events
------------------------------------------------------------
An event byte returned by the Get Communications Event Log function
can be any one of four types. The type is defined by bit 7
(the high-order bit) in each byte. It may be further defined by bit 6.
'''
from pymodbus.exceptions import NotImplementedException
from pymodbus.exceptions import ParameterException
from pymodbus.utilities import pack_bitstring, unpack_bitstring
[docs]class ModbusEvent(object):
[docs] def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
raise NotImplementedException()
[docs] def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
raise NotImplementedException()
[docs]class RemoteReceiveEvent(ModbusEvent):
''' Remote device MODBUS Receive Event
The remote device stores this type of event byte when a query message
is received. It is stored before the remote device processes the message.
This event is defined by bit 7 set to logic '1'. The other bits will be
set to a logic '1' if the corresponding condition is TRUE. The bit layout
is::
Bit Contents
----------------------------------
0 Not Used
2 Not Used
3 Not Used
4 Character Overrun
5 Currently in Listen Only Mode
6 Broadcast Receive
7 1
'''
[docs] def __init__(self, **kwargs):
''' Initialize a new event instance
'''
self.overrun = kwargs.get('overrun', False)
self.listen = kwargs.get('listen', False)
self.broadcast = kwargs.get('broadcast', False)
[docs] def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
bits = [False] * 3
bits += [self.overrun, self.listen, self.broadcast, True]
packet = pack_bitstring(bits)
return packet
[docs] def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
bits = unpack_bitstring(event)
self.overrun = bits[4]
self.listen = bits[5]
self.broadcast = bits[6]
[docs]class RemoteSendEvent(ModbusEvent):
''' Remote device MODBUS Send Event
The remote device stores this type of event byte when it finishes
processing a request message. It is stored if the remote device
returned a normal or exception response, or no response.
This event is defined by bit 7 set to a logic '0', with bit 6 set to a '1'.
The other bits will be set to a logic '1' if the corresponding
condition is TRUE. The bit layout is::
Bit Contents
-----------------------------------------------------------
0 Read Exception Sent (Exception Codes 1-3)
1 Slave Abort Exception Sent (Exception Code 4)
2 Slave Busy Exception Sent (Exception Codes 5-6)
3 Slave Program NAK Exception Sent (Exception Code 7)
4 Write Timeout Error Occurred
5 Currently in Listen Only Mode
6 1
7 0
'''
[docs] def __init__(self, **kwargs):
''' Initialize a new event instance
'''
self.read = kwargs.get('read', False)
self.slave_abort = kwargs.get('slave_abort', False)
self.slave_busy = kwargs.get('slave_busy', False)
self.slave_nak = kwargs.get('slave_nak', False)
self.write_timeout = kwargs.get('write_timeout', False)
self.listen = kwargs.get('listen', False)
[docs] def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
bits = [self.read, self.slave_abort, self.slave_busy,
self.slave_nak, self.write_timeout, self.listen]
bits += [True, False]
packet = pack_bitstring(bits)
return packet
[docs] def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
# todo fix the start byte count
bits = unpack_bitstring(event)
self.read = bits[0]
self.slave_abort = bits[1]
self.slave_busy = bits[2]
self.slave_nak = bits[3]
self.write_timeout = bits[4]
self.listen = bits[5]
[docs]class EnteredListenModeEvent(ModbusEvent):
''' Remote device Entered Listen Only Mode
The remote device stores this type of event byte when it enters
the Listen Only Mode. The event is defined by a content of 04 hex.
'''
value = 0x04
__encoded = b'\x04'
[docs] def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
return self.__encoded
[docs] def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
if event != self.__encoded:
raise ParameterException('Invalid decoded value')
[docs]class CommunicationRestartEvent(ModbusEvent):
''' Remote device Initiated Communication Restart
The remote device stores this type of event byte when its communications
port is restarted. The remote device can be restarted by the Diagnostics
function (code 08), with sub-function Restart Communications Option
(code 00 01).
That function also places the remote device into a 'Continue on Error'
or 'Stop on Error' mode. If the remote device is placed into 'Continue on
Error' mode, the event byte is added to the existing event log. If the
remote device is placed into 'Stop on Error' mode, the byte is added to
the log and the rest of the log is cleared to zeros.
The event is defined by a content of zero.
'''
value = 0x00
__encoded = b'\x00'
[docs] def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
return self.__encoded
[docs] def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
if event != self.__encoded:
raise ParameterException('Invalid decoded value')


Staples Team Supervisor/Software Engineering Graduate of @flatiron-school
Published Mar 29, 2020
I recently found myself developing a Node.js CLI program that I wanted to test installing and using it locally. This post is going to look at a few ways you can go about doing that.
The name of the program I was developing and the one being used in examples and screenshots is called corona-cli, it’s CLI that displays the number of cases for countries around the world as well as the states. It’s a forked repo from Ahmad Awais’s Corona-CLI that just adds a interactive CLI menu, a filter for specific states and some other aesthetics. Because I just did this as a side project to keep an eye on the ongoing pandemic and the fact that corona-cli is already published as a NPM package I only intended on using it for my personal systems. But if you want to check out the code that I added to it you can see it here.
NPM comes with a very handy command to create a symlink to any local packages so that you test them out in the global context of your system and is the easiest way.
All you need to do is run npm link
from within the package folder which will create a symlink in the global folder {prefix}/lib/node_modules/<package_name>
to the current folder’s package. The {prefix}
could be slightly different for each configuration, mine was $HOME/.nvm/versions/v12.16.1/
because I use NVM but to see the diffent possible locations check out the NPM Docs. The link command will also link any files bins in the package to {prefix}/bin/{name}
. Also worth noting is the <package_name>
will be taken from the name set in the package.json
file so make sure you have that set before running the command.
After changing into the package directory corona-cli
in this case for my CLI program and running npm link
you should see a output similar to this, obviously your file paths with vary but this should give you general idea of what it looks like when the command is successful.
As you can see it created two bin files, one called corona
and the other corona-cli
that both link back to the current packages index.js
file. This is because the package.json
for the current folder has two entries that look like this.
"bin": {
"corona": "index.js",
"corona-cli": "index.js"
},
This gives me the ability to run corona
or corona-cli
from anywhere in the terminal to start up the CLI program.
If you wanted to then use your newly installed package within another project you can simply run the link command again from inside the projects folder, specifying the name of the package.
So for this example after changing into the new project directory I could run npm link corona-cli
and it will create a new symbolic link from the globally-installed packge to the node_modules
folder.
To uninstall the package you would just remove it like any other global package with the uninstall
command or any of it’s aliases like remove
, rm
, r
, un
or unlink
.
Although I really liked the streamlined way npm link
worked I came across a few other ways that you can do the same thing essentially and are worth noting a few differences.
You can just run npm -g install /absolute/path/to/package/corona-cli
and that will install it globally or from within a project folder npm install /absolute/path/to/package/corona-cli
will modify the projects package.json
to include the package as a dependency. This may or may not be what you want depending on if you actually intend on publishing it or just keeping it local on your system.
The big difference between using this method and the link command is that npm link
will not alter the package.json
file in the current directory and it will not run any of the pre-install or post-install hooks that you can set with npm-scripts if your not familiar with them you should briefly look them over to just to get an idea of what options you can set in your package.json file.
You can also pack everything up in a installable tarball by running the pack command inside the root folder of the package you want to pack up. It will generate a .tgz
file that contains all everything you need to install the package just by running npm pack
which will produce a file called <package_name>-<version>.tgz
.
You can then install the package by running npm -g install <package_name>-<version>.tgz
.
You can see all the specifics of what npm link
does and more by checking out the NPM Docs but the main overview of the differences between the three ways we looked at for using your own node modules on your local system for testing and usage are
npm install /absolute/path/folder
will run the preinstall/postinstall hooks, but npm link will not.npm link
uses the global NPM space, npm install /absolute/path/folder
does not. npm link creates a symlink to the package in the global space, and then when you call npm link from another project directory, it creates a symlink not directly to the package, but rather to the global symlink. This is an important differences if you are using different global node.jsnpm install /absolute/path/folder
will alter package.json, npm link does not.


Enable publication date filtering
Published after:
Published before:
Please ensure both values are set.
Content filters allow you to choose whether explicit content is simplified and shown to you.
Do not show images in the extension when content is blocked
Do not show warnings about source reliability


This is a third blog post about Reactive Programming in Scala. The first two blog posts, Reactive Programming: Try versus Future resp. Reactive Programming: Notification versus Observable, covered reactive programs resulting in one value resp. many values. This blog post covers schedulers and workers. They are used to transform iterables to observables. As mentioned in Reactive Programming: Notification versus Observable, the transformation from iterables to observables is not as trivial as it looks: at any moment subscribed observers should be able to unsubscribe.
Remark:
The types that are used in this blog post exist in the
Scala Adaptor for RxJava library.
We refer to this library as the RxScala library.
In contrast with the previous two blog posts, this blog post deals with only one function: iterable2observable
.
Moreover, the Observable
companion object of the RxScala library already has a from
method, having an iterable parameter,
that is equivalent to iterable2observable
.
Dedicating a separate blog post on the definition of iterable2observable
is done for didactical reasons only.
A first attempt: the iterable2observable01
function
In the
Reactive Programming: Notification versus Observable blog post
we defined a function mkObservable
with the following signature
def mkObservable[Z](sz2u: Subscriber[Z] => Unit): Observable[Z]
The function mkObservable
can be used to define an observable by defining what it pushes to subscribed observers.
Using mkObservable
we can naturally define a function iterable2observable01
def iterable2observable01[Z](iz: Iterable[Z]): Observable[Z] =
mkObservable[Z] { sz =>
iz.foreach { z => sz.onNext(z) }
sz.onCompleted()
}
describe a computation observable01
using iterable2observable01
,
and use the computation observable01
as follows
def main(args: Array[String]) {
lazy val observable01 = iterable2observable01((1 to 10).toList)
val subscription01 = subscribe(observable01)
subscription01.unsubscribe()
println()
}
resulting in<PHONE_NUMBER>0completed
being printed.
It looks as if unsubscribe
does not really work.
A second attempt: the iterable2observable02
function
Maybe we should run the code
iz.foreach { z => sz.onNext(z) } ; sz.onCompleted()
in a separate thread, so that we can unscubscribe from the main thread.
Using schedulers, and workers that can be created using them,
we can naturally define a function iterable2observable02
that schedules the code above to run after a delay of duration delay
def iterable2observable02[Z]
(iz: Iterable[Z], delay: Duration)
(implicit scheduler: Scheduler): Observable[Z] = {
val iterator = iz.iterator
mkObservable[Z] { sz =>
scheduler.createWorker.schedule({ _ =>
iz.foreach { z => sz.onNext(z) }
sz.onCompleted()
}, delay)
}
}
describe a computation observable02
using iterable2observable02
,
and use the computation observable02
as follows
def main(args: Array[String]) {
implicit val scheduler = NewThreadScheduler()
lazy val observable02 = iterable2observable02((1 to 10).toList, 1 second)
val subscription02 = subscribe(observable02)
subscription02.unsubscribe()
Thread.sleep(990)
println()
}
resulting in nothing being printed at all,
or as follows
def main(args: Array[String]) {
implicit val scheduler = NewThreadScheduler()
lazy val observable02 = iterable2observable02((1 to 10).toList, 1 second)
val subscription02 = subscribe(observable02)
subscription02.unsubscribe()
Thread.sleep(1010)
println()
}
resulting in<PHONE_NUMBER>0completed
being printed.
Ok, we have some period of time during which we can unsubscribe, but, once the observable starts pushing we cannot unsubscribe any more.
It looks as if unsubscribe
still does not work.
A final attempt: the iterable2observable
function
The first idea behind the iterable2observable
function is to replace the iterative code
iz.foreach { z => sz.onNext(z) } ; sz.onCompleted()
where iz
is an iterable, or, equivalently, the iterative code
while(iz.hasNext) { sz.onNext(iz.next()) } ; sz.onCompleted()
where iz
is an iterator, by code
if(iz.hasNext) sz.onNext(iz.next()) else sz.onCompleted()
where iz
is an iterator, and, somehow, do the iteration steps ourselves.
The second idea behind the iterable2observable
function is to not only
have a delay of a certain duration before the first iteration step, but to also
have a period of a certain duration between consecutive iteration steps.
The third idea behind the iterable2observable
function is to work with a
multi assignment subscription that is updated during every iteration step.
The iterativeSchedule
method below uses those three ideas
implicit class WorkerOps(worker: Worker) {
def iterativeSchedule
(delay: Duration, period: Duration)
(action: Unit => Unit): Subscription = {
val multipleAssignmentSubscription = MultipleAssignmentSubscription();
lazy val recursiveAction: Unit => Unit = _ => {
var count: Long = 0
if(!multipleAssignmentSubscription.isUnsubscribed) {
action(())
count = count + 1
multipleAssignmentSubscription.subscription =
worker.schedule(recursiveAction, delay + count * period)
}
}
multipleAssignmentSubscription.subscription =
worker.schedule(recursiveAction, delay)
multipleAssignmentSubscription
}
}
We used a var count
as a counter. You may argue: how ugly!
Well, in a way, using a var
as an internal implementation detail is not ugly at all.
Erik Meijer (the brain behind the Rx extensions of .NET, upon which RxJava
and RxScala are based) calls himself “both a functional thinker and an imperative hacker”.
We can now naturally define a function iterable2observable
that schedules the code
if(iz.hasNext) sz.onNext(iz.next()) else sz.onCompleted()
to run for the first time after a delay of a duration delay
,
and to also continue running after delays of duration delay + count * period
private def iterator2observable[Z]
(iz: Iterator[Z], delay: Duration, period: Duration)
(implicit scheduler: Scheduler): Observable[Z] =
mkObservable[Z] { sz =>
scheduler.createWorker.iterativeSchedule(delay, period) { _ =>
if(iz.hasNext) sz.onNext(iz.next())
else sz.onCompleted()
}
}
def iterable2observable[Z]
(iz: Iterable[Z], delay: Duration, period: Duration)
(implicit scheduler: Scheduler): Observable[Z] =
iterator2observable(iz.iterator, delay, period)
We can now describe a computation observable
using iterable2observable
,
and use the computation observable
as follows
def main(args: Array[String]) {
implicit val scheduler = NewThreadScheduler()
lazy val observable = iterable2observable((1 to 10).toList, 0 second, 1 second)
val subscription = subscribe(observable)
Thread.sleep(4500)
subscription.unsubscribe()
println()
}
resulting in 12345
being printed.
Infinite Observables
The code below also works with infinite iterables like the nats
iterable below
def nats: Iterable[Int] = new Iterable[Int] {
var i = 0
def iterator: Iterator[Int] = new Iterator[Int] {
def hasNext: Boolean = true
def next(): Int = {
i = i + 1
i
}
}
}
We can now describe a computation natsObservable
using iterable2observable
and use the computation natsObservable
as follows
def main(args: Array[String]) {
implicit val scheduler = NewThreadScheduler()
lazy val natsObservable = iterable2observable(nats, 0 second, 1 second)
val natsSubscription = subscribe(natsObservable)
Thread.sleep(4500)
natsSubscription.unsubscribe()
println()
}
resulting in 12345
being printed


Next: Removed Types, Previous: Removed Language Features, Up: Removed Language Features
For this standard, some features from the language described in Common Lisp: The Language have been removed, and others have been deprecated (and will most likely not appear in future Common Lisp standards). Which features were removed and which were deprecated was decided on a case-by-case basis by the X3J13 committee.
Conforming implementations that wish to retain any removed features for compatibility must assure that such compatibility does not interfere with the correct function of conforming programs. For example, symbols corresponding to the names of removed functions may not appear in the the COMMON-LISP package. (Note, however, that this specification has been devised in such a way that there can be a package named LISP which can contain such symbols.)
Conforming implementations must implement all deprecated features. For a list of deprecated features, see Deprecated Language Features.


xf:submission should dispatch xforms-binding-exception if @instance does not resolve to an instance
-
Press the button labelled 'Test'.
-
If the result field contains the text 'TEST PASSED', the test has passed. Otherwise, the test has failed.
FALSE
TEST FAILED
Test
Result:
Ready:


Here to help
Hi there! We have just launched our new website, so please bear with us if you're experiencing any problems.
If you have any questions, the quickest way to contact us is on live chat (At the bottom right of your screen).
Not a fan of live chat? Drop us an email us at<EMAIL_ADDRESS>or by using the form on this page.
We aim to reply to all customer service enquiries within 1 working day. Need an answer now? Tap the Live Chat button at the bottom right of your screen.


QuantConnect makes backtesting available for free and charges a small monthly fee to cover live algorithm trading. This offsets our costs and aligns our interests with yours - our client. We also work with brokerages to make your live trading free.


ARTICLE 1. GENERAL PROVISIONS
[§425E-101] Short title. This chapter may be cited as the "Uniform Limited Partnership Act". [L 2003, c 210, pt of §1]


Active ingredient (in each tablet)
Famotidine USP, 10 mg/20 mg
Uses
- relieves heartburn associated with acid indigestion and sour stomach
- prevents heartburn associated with acid indigestion and sour stomach brought on by eating or drinking certain food and beverages
Warnings
Allergy alert: Do not use if you are allergic to famotidine or other acid reducers
Do not use
- if you have trouble or pain swallowing food, vomiting with blood, or bloody or black stools. These may be signs of a serious condition. See your doctor.
- if you have kidney disease, except under the advice and supervision of a doctor (for Famotidine 20 mg)
- with other acid reducers
Ask a doctor before use if you have
- had heartburn over 3 months. This may be a sign of a more serious condition.
- heartburn with lightheadedness, sweating, or dizziness
- chest pain or shoulder pain with shortness of breath; sweating; pain spreading to arms, neck or shoulders; or lightheadedness
- frequent chest pain
- frequent wheezing, particularly with heartburn
- unexplained weight loss
- nausea or vomiting
- stomach pain
Stop use and ask a doctor if
- your heartburn continues or worsens
- you need to take this product for more than 14 days
If pregnant or breast-feeding,
ask a health professional before use.
Keep out of reach of children.
In case of overdose, get medical help or contact a Poison Control Center right away.
Directions
- For Famotidine 10 mg:
- adults and children 12 years and over:
- to relieve symptoms, swallow 1 tablet with a glass of water. Do not chew.
- to prevent symptoms, swallow 1 tablet with a glass of water at any time from 15 to 60 minutes before eating food or drinking beverages that cause heartburn
- do not use more than 2 tablets in 24 hours
- children under 12 years: ask a doctor
- For Famotidine 20 mg:
- adults and children 12 years and over:
- to relieve symptoms, swallow 1 tablet with a glass of water. Do not chew.
- to prevent symptoms, swallow 1 tablet with a glass of water at any time from 10 to 60 minutes before eating food or drinking beverages that cause heartburn
- do not use more than 2 tablets in 24 hours
- children under 12 years: ask a doctor
Other information
- read the directions and warnings before use
- keep the carton. It contains important information.
- store at 20°-25°C (68°-77°F) [See USP controlled Room Temperature]
- protect from moisture and light
Inactive ingredients
colloidal silicon dioxide, hypromellose, magnesium stearate, microcrystalline cellulose, polyethylene glycol, pregelatinized starch, synthetic red iron oxide (only in 10 mg), talc and titanium dioxide
Questions or comments?
Call 1-888-375-3784
Tips for Managing Heartburn
- Do not lie flat or bend over after eating
- Do not wear tight-fitting clothing around the stomach
- Do not eat before bedtime
- Raise the head of your bed
- Avoid heartburn-causing foods such as rich, spicy, fatty or fried foods, chocolate, caffeine, alcohol and certain fruits and vegetables
- Eat slowly and avoid big meals
- If overweight, lose weight
- Quit smoking
Famotidine 10 mg
Container Label
Container Carton Label
Famotidine 20 mg
Container Label
Container Carton Label


cell cells antiviral model immune constitutive viral time virus infection induced PaKiT bat file series infections lines Supplementary values parameter field mean immunity infectious cells, data fit rate transmission â€"figure Figure (Figure dynamics epidemic fixed models within-host RoNi/. rates spatial susceptible estimated expression interferon rVSV-MARV trials {border-style initial rVSV-EBOV px;} viruses â€" #ffffff;} Vero bats culture line proportion supplement high rate, tissue acquisition assumptions experiments fitting following space theoretical using vitro IFN-Î± Research cellular fits invasion limit absent best constitutively higher infected mortality pathogen MOIÂ derived fitted stochastic âˆ’ Hoechst control host immunity, rapid response used IFN [â€"] equilibrium estimates indicates rVSV-G unique (A) (Zhou (Ï�) Foundation analysis defenses described empirical extent image live persistent produced shown state virus-induced Î², (B) [.â€".] assuming available conditions duration endemic expressing listed model. number parameters phenotypes population processes px; rVSV-EBOV, recombinant responses status supplements type zoonotic {font-family (Supplementary (Table (i.e. Conceptualization, Institute LINK National Parameter RNA University [â€".] assays assumptions, basic bifurcations case combination curves font-size highly hosts images including infection, recovered spread trial uninfectious virulent work Bats Cell Data Pavlovich Results Statistical allowed based bifurcation birth cDNA cat combinations corresponding demonstrated developed double; effects epidemics generated grant hour http://dx.doi.org/./National incubated known likely long-term modeling order plaque previously processed processing proportions range raw reported reservoirs resulting role stain stomatitis support supported threshold vesicular Â°C Îµ, Ï�, > (Howat Biesold Branch Cells Finally, Health Hopf Indiana Infectious Institutes Methodology.  AIC Arnold Best Brook Brook. Cara Department Ebola Fellowship FigShare Hoechst-stained IFN-Î±, IFN-Î² Induced MOI=. MatCont Materials Miller PaKiT, Panel Raw Resources, States[], Supervision, Table ThermoFisher Vero, Wong Xie aegyptiacus) african alecto alecto) appear at: bats. binary bold confidence confirmed consistent courier; culture. cultures cycles cytokine, different download eGFP elucidate em; emergence enhanced entirely equation especially estimation evolution excepting extinctionÂ filoviruses, fruit functional general glycoprotein green http://dx.doi.org/./Singapore human images. immune-mediated infections, influenza invasion, lab lines. literature local localized mechanistic methods model, monolayer monolayers offered original output pathogens pathology patterns persistence promote pt;} qPCR rVSV-G, rapidly receptor reduced replication represent reservoir results run standard study such, suggest systems total undertook verified wells Âµl â€").


JASON'S LYRIC A Film Review Copyright Dragan Antulov 2001
Originality is probably the most important characteristic of any filmmaker that aspires for greatness. Without it the films rely on formulas and cliches and start looking indistinguishable from each other. That happens even with the titles characterised by certain level of social and political consciousness, and the good example might be given by 1990s films that chronicled life of black youths in urban America and often looked too similar to John Singleton's BOYZ N THE HOOD. In his 1994 debut JASON'S LYRIC director Doug McHenry tries somewhat different approach.
The plot of this movie is set in Houston's black neighbourhood and tells the story of two brothers. The older Jason (played by Allen Payne) is intelligent, and responsible hard- working young man who rejects promotion from his television repair shop only in order to be close and take care of his mother Gloria (played by Suzzanne Douglass). The other person Jason takes care of is his younger brother Joshua (played by Bookeem Woodbine), whose life revolves around petty crime and substance abuse. Jason's life begins to change after he meets beautiful girl Lyric (played by Jada Pinkett) and starts romantic relationship with her. This opens new horizons for Jason and he begins to think about moving out of the ghetto and starting a new life. But the concern for his brother and memories of tragic childhood incident involving his drunken father Maddog (played by Forest Whitaker) is going to stop him until it is too late.
The most important thing about JASON'S LYRIC is the script by Bobby Smith Jr., which almost turns romance into major plot element. This is quite an interesting approach, especially for the often misogynist black ghetto sub-genre. Unfortunately, the idea to have romantic black ghetto film is compromised from the start, as soon as the character of Lyric becomes related to the all-too-familiar world of gangs, violence and local drug lords and the story ends in rather predictable way for this kind of movies. Another idea - to give some biblical overtones to the script via Cain vs. Abel story - is also compromised with the heavy-handed approach. However, the film is saved with excellent acting (especially great Forest Whitaker in small but significant role) and good direction. All in all, JASON'S LYRIC represents failed yet refreshing experiment that nevertheless can be seen as a decent film of its own.
RATING: 6/10 (++)
Written on July 8th 2001
Dragan Antulov a.k.a. Drax Fido: 2:381/100 E-mail<EMAIL_ADDRESS>E-mail<EMAIL_ADDRESS>Filmske recenzije na hrvatskom/Movie Reviews in Croatian http://film.purger.com Movie Reviews by Drax http://www.purger.com/users/drax/reviews.htm Movie Reviews on IMDb http://us.imdb.com/ReviewsBy?Dragan+Antulov
========== X-RAMR-ID: 28696 X-RT-AuthorID: 1307 X-RT-TitleID: 1055335 X-RT-RatingText: 6/10
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


IDE
The IDE is a Windows application which provides a
friendly GUI interface to the Prolog system. From within the IDE you can:
- Edit source files
- Compile files
- Link programs
- Create and manage projects
- Debug programs
- Execute programs
- Enter a standard ?- Prolog listener
Note the final point. This means that there is nothing you can do with
the command-line tools that you cannot do in the IDE environment. .
Interface
After the IDE has been invoked you are presented
with a screen divided into four main areas:
- Running along the top of the screen is the menu bar. Many of the commands
will already be familiar to experienced Windows users.
- Below the menu bar is the tool bar which gives you access to the most
commonly used commands and functions by clicking on the corresponding icon.
- Running along the bottom of the screen is the status bar which indicates
what the highlighted menu option does.
- The bulk of the middle of the screen is empty. Depending on which option
is chosen, the area will fill with windows. It is within these windows
that most of the interchange between you and the IDE takes place.
Each open Prolog source file is displayed in its own window. Windows
can be moved, resized and reduced to an icon. If there is a project currently
open, then it also appears in a window.
The listener is also in its own window. The current release allows only
one listener window to be active at one time. The debugger runs in a separate
window, but it can only be turned on when the listener is active.
The listener/debugger sessions can be logged to a file, saved or printed
for later review.
Using menu commands, source files can be compiled into object (.plm)
files. Both source and object files can be consulted into the listener.
Also using menu commands, you can link multiple .plm files into a load module,
which can also be run in a window.
Unicode and ASCII
The editor in the IDE will accept either
Unicode or ASCII files, and save a file in the same format it was originally
read in. New files can be saved as either ASCII or Unicode.
To view Unicode characters it is necessary to set the IDE font
to a Unicode font. Lucida Console has a large number of Unicode characters.
Gulim is a font included on the NT 4.0 distribution disks that has Japanese
characters in it.
File Menu
New
File
Opens a new, blank edit window.
New Project
Creates a new project and displays the project
dialog box.
Open File
Opens an existing Prolog source file (.pro).
Open Project
Opens an existing project.
Close
Closes the current edit window.
Close All
Closes all open edit windows.
Save
Saves the source file or project associated with the current window.
Save As
Saves the source file or project associated with the current window
in a new file.
Save All
Saves all open source files and the current project (if one is open).
Unlock
Prompts for information required to activate the software.
Print
Prints the contents of the current edit, listener or debugger window.
Print Preview
Displays how the contents of the current window will appear when printed.
Print Setup
Select a printer and set parameters for printing.
Recent File List
A list of the Prolog source files most recently opened.
Recent Project List
A list of the projects most recently opened.
Exit
Exits the IDE.
Edit Menu
Undo
Reverses the last editing change made.
Cut
Deletes the currently highlighted text and saves it on the clipboard.
Copy
Makes a copy of the currently highlighted text on the clipboard.
Paste
Inserts the contents of the clipboard at the cursor.
Delete
Deletes the currently highlighted text.
Select All
Selects (highlights) all the text.
Find
Finds the first occurance of a string in the current window.
Find Next
Finds the next occurance of a string in the current window.
Replace
Finds and replaces text in the current window.
View Menu
Tool Bar
Toggles the display of the tool bar at the top of the main IDE window.
Status Bar
Toggles the display of the status bar at the bottom of the main IDE
window.
Set Font
Sets the font name and size to be used for edit, listener and debugger
window text.
Listener Menu
Start
Opens the listener into a window and emits the ?- prompt.
End
Closes the listener.
Consult
Consults a Prolog source file (.pro) or loads
a Prolog object file (.plm) into the listener.
Reconsult
Consults a Prolog source file into the listener, replacing any current
definitions for the predicates.
Debug On
Opens the debugger into a window.
Debug Off
Closes the debugger.
Build Menu
Compile
Compiles a Prolog source file (.pro).
Link
Links one or more Prolog object files (.plm)
into a Prolog load module (.xpl).
Build
Compiles all modified files and links all files and libraries in a
project into a Prolog load module.
Run
Loads a Prolog load module and calls the main/0 predicate in a new
window.
Window Menu
Cascade
Rearrange all open windows (including the listener, debugger and current
project, if any) in a cascading fashion from the upper left to the lower
right.
Tile Horizontally
Arranges the windows in a horizontal fashion.
Tile Vertically
Arranges the windows in a vertical fashion.
Close All
Closes all windows.
Open Window List
A list of all currently open windows.
Help
Index
Displays the top-level index to all the Amzi! help files in a web browser.
About Amzi!
Displays version information for the installed software.
Change Browser
Changes the web browser program to use for displaying help.
Copyright ©1987-2011 Amzi! inc. All Rights Reserved.
Amzi! is a registered trademark and Logic Server is a trademark
of Amzi! inc.


Wilson Owino is well renowened proficient programmer/developer come designer based in Nairobi Kenya but attached international.Started plying his trades mid 2018,having gone through a serious intensive,radicalised comprhensive programming bootcamp in one of the best school in Kenya,Moringa school.He has an intensified passion and devotion for this hobby,he made a carrer out of it.He has a way to priorities his clients and always giving them best service the best service they need.


Star Wars Episode X
The Rise of Mari SkyWalker
These are difficult times!
The galaxy has heard a mysterious broadcast, a threat of REVENGE in the sinister voice of the late EMPEROR PALPATINE.
GENERAL MARI SKYWALKER dispatches secret agents to gather intelligence.
She is the last hope of the Jedi's Order...


Last year money was to be set aside in reserves to cover the net amount needed
to resolve these issues with Transco, BUG , LILCO and Enron. The total
dollars
required was approximately $4.25 million. An amount of $3.55 million needed
for
the Transco historical imbalance resolution. The remaining balance was needed
for the BUG and LILCO accounting issues that Keyspan brought to our attention
last year.
Bob Hall has $3.5 million reserved in his area for the Transco historical
imbalance.
The remaining $50,000 for Transco and approximately $700,000 of additional
funds
for the accounting issues were to be reserved last year under "The Office of
the
Chairman". Sally Beck and Janet Dietrich arranged for this additional money
to
be reserved at the "Chairman" level since the additional funds were needed to
correct an old accounting problem that should not hit the East Desk P&L.
Also, the
arrangement was that the reserve would be maintained until the settlement
payments
were made by Enron.
As with most stories, there is some good news and some bad news. First, the
bad news.
After a great deal of investigation, it appears that there currently is no
reserve at the
"Office of the Chairman" for these additional funds. Now, the good news.
Georgeanne
will take the necessary steps to make sure there is money available so that
we can
quickly resolve these issues with Keyspan and Transco.
If you have questions, please give me a call.
Ruth
x31667
***********
EDRM Enron Email Data Set has been produced in EML, PST and NSF format by ZL Technologies, Inc. This Data Set is licensed under a Creative Commons Attribution 3.0 United States License <http://creativecommons.org/licenses/by/3.0/us/> . To provide attribution, please cite to "ZL Technologies, Inc. (http://www.zlti.com)."
***********
California


Fecha_Creacion: 2017-11-18T11:46:22.933Z
Dimension: Dimension C-137
Id_Locacion: 18
Nombre: Mr. Goldenfold's dream
Residentes: ['https://rickandmortyapi.com/api/character/63', 'https://rickandmortyapi.com/api/character/80', 'https://rickandmortyapi.com/api/character/221', 'https://rickandmortyapi.com/api/character/246', 'https://rickandmortyapi.com/api/character/304', 'https://rickandmortyapi.com/api/character/305', 'https://rickandmortyapi.com/api/character/306', 'https://rickandmortyapi.com/api/character/396']
Tipo: Dream
URL: https://rickandmortyapi.com/api/location/18


Welcome! This is the documentation for GrapeFruit 0.1a3, last updated July 15, 2015.
See the Index for a list of the topics.
The Color class¶
-
class
grapefruit.
Color
¶
The grapefruit module contains only the Color
class, which exposes all
the functionnalities. It can be used to store a color value and manipulate it,
or convert it to another color system.
If you are only interested in converting you colors from one system to another,
you can store them using regular tuples instead of Color
instances.
You can then use the class static methods to perform the conversions.
Color
stores both the RGB and HSL representation of the color.
This makes possible to keep the hue intact when the color is a pure white
due to its lightness.
However, certain operations work only with the RGB values, and might then
lose the hue.
All the operations assume that you provide values in the specified ranges, no checks are made whatsoever. If you provide a value outside of the specified ranges, you’ll get some strange results...
The class instances are immutable, all the methods return a new instance
of the Color
class, and all the properties are read-only.
Note
Some operations may provide results a bit outside the specified ranges, the results are not capped. This is due to certain color systems having a widers gamut than others.
Class content¶
- Class Constants
- Conversion functions
Color.RgbToHsl()
Color.HslToRgb()
Color.RgbToHsv()
Color.HsvToRgb()
Color.RgbToYiq()
Color.YiqToRgb()
Color.RgbToYuv()
Color.YuvToRgb()
Color.RgbToXyz()
Color.XyzToRgb()
Color.XyzToLab()
Color.LabToXyz()
Color.CmykToCmy()
Color.CmyToCmyk()
Color.RgbToCmy()
Color.CmyToRgb()
Color.RgbToHtml()
Color.HtmlToRgb()
Color.RgbToPil()
Color.PilToRgb()
Color.RgbToWebSafe()
Color.RgbToGreyscale()
Color.RgbToRyb()
Color.RybToRgb()
- Instantiation functions
- Properties
- Manipulation methods
- Generation methods
- Blending methods
Example usage¶
To create an instance of the grapefruit.Color from RGB values:
>>> import grapefruit >>> r, g, b = 1, 0.5, 0 >>> col = grapefruit.Color.NewFromRgb(r, g, b)To get the values of the color in another colorspace:
>>> h, s, v = col.hsv >>> l, a, b = col.labTo get the complementary of a color:
>>> compl = col.ComplementaryColor() >>> print compl.hsl (210.0, 1.0, 0.5)To directly convert RGB values to their HSL equivalent:
>>> h, s, l = Color.RgbToHsl(r, g, b)
Class Constants¶
-
Color.
WHITE_REFERENCE
¶
The reference white points of the CIE standards illuminants, calculated from the chromaticity coordinates found at: http://en.wikipedia.org/wiki/Standard_illuminant
A dictionary mapping the name of the CIE standard illuminants to their reference white points. The white points are required for the XYZ <-> L*a*b conversions.
The key names are build using the following pattern: <observer>_<illuminant>
The possible values for <observer>
are:
Value Observer std CIE 1931 2° Standard Observer sup CIE 1964 10° Supplementary Observer
The possible values for <illuminant>
are the name of the standard illuminants:
Value CCT Illuminant A 2856 K Incandescent tungsten B 4874 K Direct sunlight at noon (obsolete) C 6774 K North sky daylight (obsolete) D50 5003 K ICC Profile PCS. Horizon light. D55 5503 K Compromise between incandescent and daylight D65 6504 K Noon daylight (TV & sRGB colorspace) D75 7504 K North sky day light E ~5455 K Equal energy radiator (not a black body) F1 6430 K Daylight Fluorescent F2 4230 K Cool White Fluorescent F3 3450 K White Fluorescent F4 2940 K Warm White Fluorescent F5 6350 K Daylight Fluorescent F6 4150 K Lite White Fluorescent F7 6500 K Broadband fluorescent, D65 simulator F8 5000 K Broadband fluorescent, D50 simulator F9 4150 K Broadband fluorescent, Cool White Deluxe F10 5000 K Narrowband fluorescent, Philips TL85, Ultralume 50 F11 4000 K Narrowband fluorescent, Philips TL84, Ultralume 40 F12 3000 K Narrowband fluorescent, Philips TL83, Ultralume 30
-
Color.
NAMED_COLOR
¶
The names and RGB values of the X11 colors supported by popular browsers, with the gray/grey spelling issues, fixed so that both work (e.g light*grey* and light*gray*).
Note: For Gray, Green, Maroon and Purple, the HTML/CSS values are used instead of the X11 ones (see X11/CSS clashes)
Reference: CSS3 Color module
Conversion functions¶
The conversion functions are static methods of the Color
class that
let you convert a color stored as the list of its components rather than
as a Color
instance.
-
static
Color.
RgbToHsl
(r, g, b)¶ Convert the color from RGB coordinates to HSL.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- The color as an (h, s, l) tuple in the range: h[0...360], s[0...1], l[0...1]
>>> Color.RgbToHsl(1, 0.5, 0) (30.0, 1.0, 0.5)
-
static
Color.
HslToRgb
(h, s, l)¶ Convert the color from HSL coordinates to RGB.
- Parameters:
h: The Hue component value [0...1] s: The Saturation component value [0...1] l: The Lightness component value [0...1] - Returns:
- The color as an (r, g, b) tuple in the range: r[0...1], g[0...1], b[0...1]
>>> Color.HslToRgb(30.0, 1.0, 0.5) (1.0, 0.5, 0.0)
-
static
Color.
RgbToHsv
(r, g, b)¶ Convert the color from RGB coordinates to HSV.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- The color as an (h, s, v) tuple in the range: h[0...360], s[0...1], v[0...1]
>>> Color.RgbToHsv(1, 0.5, 0) (30.0, 1.0, 1.0)
-
static
Color.
HsvToRgb
(h, s, v)¶ Convert the color from RGB coordinates to HSV.
- Parameters:
h: The Hus component value [0...1] s: The Saturation component value [0...1] v: The Value component [0...1] - Returns:
- The color as an (r, g, b) tuple in the range: r[0...1], g[0...1], b[0...1]
>>> Color.HslToRgb(30.0, 1.0, 0.5) (1.0, 0.5, 0.0)
-
static
Color.
RgbToYiq
(r, g, b)¶ Convert the color from RGB to YIQ.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- The color as an (y, i, q) tuple in the range: y[0...1], i[0...1], q[0...1]
>>> '(%g, %g, %g)' % Color.RgbToYiq(1, 0.5, 0) '(0.592263, 0.458874, -0.0499818)'
-
static
Color.
YiqToRgb
(y, i, q)¶ Convert the color from YIQ coordinates to RGB.
- Parameters:
y: Tte Y component value [0...1] i: The I component value [0...1] q: The Q component value [0...1] - Returns:
- The color as an (r, g, b) tuple in the range: r[0...1], g[0...1], b[0...1]
>>> '(%g, %g, %g)' % Color.YiqToRgb(0.592263, 0.458874, -0.0499818) '(1, 0.5, 5.442e-07)'
-
static
Color.
RgbToYuv
(r, g, b)¶ Convert the color from RGB coordinates to YUV.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- The color as an (y, u, v) tuple in the range: y[0...1], u[-0.436...0.436], v[-0.615...0.615]
>>> '(%g, %g, %g)' % Color.RgbToYuv(1, 0.5, 0) '(0.5925, -0.29156, 0.357505)'
-
static
Color.
YuvToRgb
(y, u, v)¶ Convert the color from YUV coordinates to RGB.
- Parameters:
y: The Y component value [0...1] u: The U component value [-0.436...0.436] v: The V component value [-0.615...0.615] - Returns:
- The color as an (r, g, b) tuple in the range: r[0...1], g[0...1], b[0...1]
>>> '(%g, %g, %g)' % Color.YuvToRgb(0.5925, -0.2916, 0.3575) '(0.999989, 0.500015, -6.3276e-05)'
-
static
Color.
RgbToXyz
(r, g, b)¶ Convert the color from sRGB to CIE XYZ.
The methods assumes that the RGB coordinates are given in the sRGB colorspace (D65).
Note
Compensation for the sRGB gamma correction is applied before converting.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- The color as an (x, y, z) tuple in the range: x[0...1], y[0...1], z[0...1]
>>> '(%g, %g, %g)' % Color.RgbToXyz(1, 0.5, 0) '(0.488941, 0.365682, 0.0448137)'
-
static
Color.
XyzToRgb
(x, y, z)¶ Convert the color from CIE XYZ coordinates to sRGB.
Note
Compensation for sRGB gamma correction is applied before converting.
- Parameters:
x: The X component value [0...1] y: The Y component value [0...1] z: The Z component value [0...1] - Returns:
- The color as an (r, g, b) tuple in the range: r[0...1], g[0...1], b[0...1]
>>> '(%g, %g, %g)' % Color.XyzToRgb(0.488941, 0.365682, 0.0448137) '(1, 0.5, 6.81883e-08)'
-
static
Color.
XyzToLab
(x, y, z, wref=(0.95043, 1.0, 1.0889))¶ Convert the color from CIE XYZ to CIE L*a*b*.
- Parameters:
x: The X component value [0...1] y: The Y component value [0...1] z: The Z component value [0...1] wref: The whitepoint reference, default is 2° D65. - Returns:
- The color as an (L, a, b) tuple in the range: L[0...100], a[-1...1], b[-1...1]
>>> '(%g, %g, %g)' % Color.XyzToLab(0.488941, 0.365682, 0.0448137) '(66.9518, 0.43084, 0.739692)'
>>> '(%g, %g, %g)' % Color.XyzToLab(0.488941, 0.365682, 0.0448137, Color.WHITE_REFERENCE['std_D50']) '(66.9518, 0.411663, 0.67282)'
-
static
Color.
LabToXyz
(l, a, b, wref=(0.95043, 1.0, 1.0889))¶ Convert the color from CIE L*a*b* to CIE 1931 XYZ.
- Parameters:
l: The L component [0...100] a: The a component [-1...1] b: The a component [-1...1] wref: The whitepoint reference, default is 2° D65. - Returns:
- The color as an (x, y, z) tuple in the range: x[0...q], y[0...1], z[0...1]
>>> '(%g, %g, %g)' % Color.LabToXyz(66.9518, 0.43084, 0.739692) '(0.488941, 0.365682, 0.0448137)'
>>> '(%g, %g, %g)' % Color.LabToXyz(66.9518, 0.411663, 0.67282, Color.WHITE_REFERENCE['std_D50']) '(0.488941, 0.365682, 0.0448138)'
-
static
Color.
CmykToCmy
(c, m, y, k)¶ Convert the color from CMYK coordinates to CMY.
- Parameters:
c: The Cyan component value [0...1] m: The Magenta component value [0...1] y: The Yellow component value [0...1] k: The Black component value [0...1] - Returns:
- The color as an (c, m, y) tuple in the range: c[0...1], m[0...1], y[0...1]
>>> '(%g, %g, %g)' % Color.CmykToCmy(1, 0.32, 0, 0.5) '(1, 0.66, 0.5)'
-
static
Color.
CmyToCmyk
(c, m, y)¶ Convert the color from CMY coordinates to CMYK.
- Parameters:
c: The Cyan component value [0...1] m: The Magenta component value [0...1] y: The Yellow component value [0...1] - Returns:
- The color as an (c, m, y, k) tuple in the range: c[0...1], m[0...1], y[0...1], k[0...1]
>>> '(%g, %g, %g, %g)' % Color.CmyToCmyk(1, 0.66, 0.5) '(1, 0.32, 0, 0.5)'
-
static
Color.
RgbToCmy
(r, g, b)¶ Convert the color from RGB coordinates to CMY.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- The color as an (c, m, y) tuple in the range: c[0...1], m[0...1], y[0...1]
>>> Color.RgbToCmy(1, 0.5, 0) (0, 0.5, 1)
-
static
Color.
CmyToRgb
(c, m, y)¶ Convert the color from CMY coordinates to RGB.
- Parameters:
c: The Cyan component value [0...1] m: The Magenta component value [0...1] y: The Yellow component value [0...1] - Returns:
- The color as an (r, g, b) tuple in the range: r[0...1], g[0...1], b[0...1]
>>> Color.CmyToRgb(0, 0.5, 1) (1, 0.5, 0)
-
static
Color.
RgbToHtml
(r, g, b)¶ Convert the color from (r, g, b) to #RRGGBB.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- A CSS string representation of this color (#RRGGBB).
>>> Color.RgbToHtml(1, 0.5, 0) '#ff8000'
-
static
Color.
HtmlToRgb
(html)¶ Convert the HTML color to (r, g, b).
- Parameters:
html: the HTML definition of the color (#RRGGBB or #RGB or a color name). - Returns:
- The color as an (r, g, b) tuple in the range: r[0...1], g[0...1], b[0...1]
- Throws:
ValueError: If html is neither a known color name or a hexadecimal RGB representation.
>>> '(%g, %g, %g)' % Color.HtmlToRgb('#ff8000') '(1, 0.501961, 0)' >>> '(%g, %g, %g)' % Color.HtmlToRgb('ff8000') '(1, 0.501961, 0)' >>> '(%g, %g, %g)' % Color.HtmlToRgb('#f60') '(1, 0.4, 0)' >>> '(%g, %g, %g)' % Color.HtmlToRgb('f60') '(1, 0.4, 0)' >>> '(%g, %g, %g)' % Color.HtmlToRgb('lemonchiffon') '(1, 0.980392, 0.803922)'
-
static
Color.
RgbToPil
(r, g, b)¶ Convert the color from RGB to a PIL-compatible integer.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- A PIL compatible integer (0xBBGGRR).
>>> '0x%06x' % Color.RgbToPil(1, 0.5, 0) '0x0080ff'
-
static
Color.
PilToRgb
(pil)¶ Convert the color from a PIL-compatible integer to RGB.
- Parameters:
- pil: a PIL compatible color representation (0xBBGGRR)
- Returns:
- The color as an (r, g, b) tuple in the range: the range: r: [0...1] g: [0...1] b: [0...1]
>>> '(%g, %g, %g)' % Color.PilToRgb(0x0080ff) '(1, 0.501961, 0)'
-
static
Color.
RgbToWebSafe
(r, g, b, alt=False)¶ Convert the color from RGB to ‘web safe’ RGB
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] alt: If True, use the alternative color instead of the nearest one. Can be used for dithering. - Returns:
- The color as an (r, g, b) tuple in the range: the range: r[0...1], g[0...1], b[0...1]
>>> '(%g, %g, %g)' % Color.RgbToWebSafe(1, 0.55, 0.0) '(1, 0.6, 0)'
-
static
Color.
RgbToGreyscale
(r, g, b)¶ Convert the color from RGB to its greyscale equivalent
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] - Returns:
- The color as an (r, g, b) tuple in the range: the range: r[0...1], g[0...1], b[0...1]
>>> '(%g, %g, %g)' % Color.RgbToGreyscale(1, 0.8, 0) '(0.6, 0.6, 0.6)'
-
static
Color.
RgbToRyb
(hue)¶ Maps a hue on the RGB color wheel to Itten’s RYB wheel.
- Parameters:
hue: The hue on the RGB color wheel [0...360] - Returns:
- An approximation of the corresponding hue on Itten’s RYB wheel.
>>> Color.RgbToRyb(15) 26.0
-
static
Color.
RybToRgb
(hue)¶ Maps a hue on Itten’s RYB color wheel to the standard RGB wheel.
- Parameters:
hue: The hue on Itten’s RYB color wheel [0...360] - Returns:
- An approximation of the corresponding hue on the standard RGB wheel.
>>> Color.RybToRgb(15) 8.0
Instantiation functions¶
The instantiation functions let you create a new instance of the Color
class from the color components using the color system of your choice.
-
static
Color.
NewFromRgb
(r, g, b, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed RGB values.
- Parameters:
r: The Red component value [0...1] g: The Green component value [0...1] b: The Blue component value [0...1] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromRgb(1.0, 0.5, 0.0) (1.0, 0.5, 0.0, 1.0) >>> Color.NewFromRgb(1.0, 0.5, 0.0, 0.5) (1.0, 0.5, 0.0, 0.5)
-
static
Color.
NewFromHsl
(h, s, l, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed HSL values.
- Parameters:
h: The Hue component value [0...1] s: The Saturation component value [0...1] l: The Lightness component value [0...1] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 1, 0.5) (1.0, 0.5, 0.0, 1.0) >>> Color.NewFromHsl(30, 1, 0.5, 0.5) (1.0, 0.5, 0.0, 0.5)
-
static
Color.
NewFromHsv
(h, s, v, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed HSV values.
- Parameters:
h: The Hus component value [0...1] s: The Saturation component value [0...1] v: The Value component [0...1] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsv(30, 1, 1) (1.0, 0.5, 0.0, 1.0) >>> Color.NewFromHsv(30, 1, 1, 0.5) (1.0, 0.5, 0.0, 0.5)
-
static
Color.
NewFromYiq
(y, i, q, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed YIQ values.
- Parameters:
y: The Y component value [0...1] i: The I component value [0...1] q: The Q component value [0...1] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> str(Color.NewFromYiq(0.5922, 0.45885,-0.05)) '(0.999902, 0.499955, -6.6905e-05, 1)' >>> str(Color.NewFromYiq(0.5922, 0.45885,-0.05, 0.5)) '(0.999902, 0.499955, -6.6905e-05, 0.5)'
-
static
Color.
NewFromYuv
(y, u, v, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed YUV values.
- Parameters:
y: The Y component value [0...1] u: The U component value [-0.436...0.436] v: The V component value [-0.615...0.615] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> str(Color.NewFromYuv(0.5925, -0.2916, 0.3575)) '(0.999989, 0.500015, -6.3276e-05, 1)' >>> str(Color.NewFromYuv(0.5925, -0.2916, 0.3575, 0.5)) '(0.999989, 0.500015, -6.3276e-05, 0.5)'
-
static
Color.
NewFromXyz
(x, y, z, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed CIE-XYZ values.
- Parameters:
x: The Red component value [0...1] y: The Green component value [0...1] z: The Blue component value [0...1] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> str(Color.NewFromXyz(0.488941, 0.365682, 0.0448137)) '(1, 0.5, 6.81883e-08, 1)' >>> str(Color.NewFromXyz(0.488941, 0.365682, 0.0448137, 0.5)) '(1, 0.5, 6.81883e-08, 0.5)'
-
static
Color.
NewFromLab
(l, a, b, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed CIE-LAB values.
- Parameters:
l: The L component [0...100] a: The a component [-1...1] b: The a component [-1...1] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> str(Color.NewFromLab(66.9518, 0.43084, 0.739692)) '(1, 0.5, 1.09491e-08, 1)' >>> str(Color.NewFromLab(66.9518, 0.43084, 0.739692, wref=Color.WHITE_REFERENCE['std_D50'])) '(1.01238, 0.492011, -0.14311, 1)' >>> str(Color.NewFromLab(66.9518, 0.43084, 0.739692, 0.5)) '(1, 0.5, 1.09491e-08, 0.5)' >>> str(Color.NewFromLab(66.9518, 0.43084, 0.739692, 0.5, Color.WHITE_REFERENCE['std_D50'])) '(1.01238, 0.492011, -0.14311, 0.5)'
-
static
Color.
NewFromCmy
(c, m, y, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed CMY values.
- Parameters:
c: The Cyan component value [0...1] m: The Magenta component value [0...1] y: The Yellow component value [0...1] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromCmy(0, 0.5, 1) (1, 0.5, 0, 1.0) >>> Color.NewFromCmy(0, 0.5, 1, 0.5) (1, 0.5, 0, 0.5)
-
static
Color.
NewFromCmyk
(c, m, y, k, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed CMYK values.
- Parameters:
c: The Cyan component value [0...1] m: The Magenta component value [0...1] y: The Yellow component value [0...1] k: The Black component value [0...1] alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> str(Color.NewFromCmyk(1, 0.32, 0, 0.5)) '(0, 0.34, 0.5, 1)' >>> str(Color.NewFromCmyk(1, 0.32, 0, 0.5, 0.5)) '(0, 0.34, 0.5, 0.5)'
-
static
Color.
NewFromHtml
(html, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed HTML color definition.
- Parameters:
html: The HTML definition of the color (#RRGGBB or #RGB or a color name). alpha: The color transparency [0...1], default is opaque. wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> str(Color.NewFromHtml('#ff8000')) '(1, 0.501961, 0, 1)' >>> str(Color.NewFromHtml('ff8000')) '(1, 0.501961, 0, 1)' >>> str(Color.NewFromHtml('#f60')) '(1, 0.4, 0, 1)' >>> str(Color.NewFromHtml('f60')) '(1, 0.4, 0, 1)' >>> str(Color.NewFromHtml('lemonchiffon')) '(1, 0.980392, 0.803922, 1)' >>> str(Color.NewFromHtml('#ff8000', 0.5)) '(1, 0.501961, 0, 0.5)'
-
static
Color.
NewFromPil
(pil, alpha=1.0, wref=(0.95043, 1.0, 1.0889))¶ Create a new instance based on the specifed PIL color.
- Parameters:
pil: A PIL compatible color representation (0xBBGGRR) alpha: The color transparency [0...1], default is opaque wref: The whitepoint reference, default is 2° D65. - Returns:
- A grapefruit.Color instance.
>>> str(Color.NewFromPil(0x0080ff)) '(1, 0.501961, 0, 1)' >>> str(Color.NewFromPil(0x0080ff, 0.5)) '(1, 0.501961, 0, 0.5)'
Properties¶
The properties get the value of the instance in the specified color model.
The properties returning calculated values unless marked otherwise.
Note
All the properties are read-only. You need to make a copy of the instance to modify the color value.
-
Color.
alpha
¶ The transparency of this color. 0.0 is transparent and 1.0 is fully opaque.
This value is not calculated, the stored value is returned directly.
-
Color.
whiteRef
¶ the white reference point of this color.
This value is not calculated, the stored value is returned directly.
-
Color.
rgb
¶ The RGB values of this Color.
This value is not calculated, the stored value is returned directly.
-
Color.
hue
¶ The hue of this color.
This value is not calculated, the stored value is returned directly.
-
Color.
hsl
¶ The HSL values of this Color.
This value is not calculated, the stored value is returned directly.
-
Color.
hsv
¶ The HSV values of this Color.
-
Color.
yiq
¶ The YIQ values of this Color.
-
Color.
yuv
¶ The YUV values of this Color.
-
Color.
xyz
¶ The CIE-XYZ values of this Color.
-
Color.
lab
¶ The CIE-LAB values of this Color.
-
Color.
cmy
¶ The CMY values of this Color.
-
Color.
cmyk
¶ The CMYK values of this Color.
-
Color.
html
¶ This Color as an HTML color definition.
-
Color.
pil
¶ This Color as a PIL compatible value.
-
Color.
webSafe
¶ The web safe color nearest to this one (RGB).
-
Color.
greyscale
¶
Manipulation methods¶
The manipulations methods let you create a new color by changing an existing color properties.
Note
The methods do not modify the current Color instance. They create a new instance or a tuple of new instances with the specified modifications.
-
Color.
ColorWithAlpha
(alpha)¶ Create a new instance based on this one with a new alpha value.
- Parameters:
alpha: The transparency of the new color [0...1]. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromRgb(1.0, 0.5, 0.0, 1.0).ColorWithAlpha(0.5) (1.0, 0.5, 0.0, 0.5)
-
Color.
ColorWithWhiteRef
(wref, labAsRef=False)¶ Create a new instance based on this one with a new white reference.
- Parameters:
wref: The whitepoint reference. labAsRef: If True, the L*a*b* values of the current instance are used as reference for the new color; otherwise, the RGB values are used as reference. - Returns:
- A grapefruit.Color instance.
>>> c = Color.NewFromRgb(1.0, 0.5, 0.0, 1.0, Color.WHITE_REFERENCE['std_D65'])
>>> c2 = c.ColorWithWhiteRef(Color.WHITE_REFERENCE['sup_D50']) >>> c2.rgb (1.0, 0.5, 0.0) >>> '(%g, %g, %g)' % c2.whiteRef '(0.96721, 1, 0.81428)'
>>> c2 = c.ColorWithWhiteRef(Color.WHITE_REFERENCE['sup_D50'], labAsRef=True) >>> '(%g, %g, %g)' % c2.rgb '(1.01463, 0.490339, -0.148131)' >>> '(%g, %g, %g)' % c2.whiteRef '(0.96721, 1, 0.81428)' >>> '(%g, %g, %g)' % c.lab '(66.9518, 0.43084, 0.739692)' >>> '(%g, %g, %g)' % c2.lab '(66.9518, 0.43084, 0.739693)'
-
Color.
ColorWithHue
(hue)¶ Create a new instance based on this one with a new hue.
- Parameters:
hue: The hue of the new color [0...360]. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 1, 0.5).ColorWithHue(60) (1.0, 1.0, 0.0, 1.0) >>> Color.NewFromHsl(30, 1, 0.5).ColorWithHue(60).hsl (60, 1, 0.5)
-
Color.
ColorWithSaturation
(saturation)¶ Create a new instance based on this one with a new saturation value.
Note
The saturation is defined for the HSL mode.
- Parameters:
saturation: The saturation of the new color [0...1]. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 1, 0.5).ColorWithSaturation(0.5) (0.75, 0.5, 0.25, 1.0) >>> Color.NewFromHsl(30, 1, 0.5).ColorWithSaturation(0.5).hsl (30, 0.5, 0.5)
-
Color.
ColorWithLightness
(lightness)¶ Create a new instance based on this one with a new lightness value.
- Parameters:
lightness: The lightness of the new color [0...1]. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 1, 0.5).ColorWithLightness(0.25) (0.5, 0.25, 0.0, 1.0) >>> Color.NewFromHsl(30, 1, 0.5).ColorWithLightness(0.25).hsl (30, 1, 0.25)
-
Color.
DarkerColor
(level)¶ Create a new instance based on this one but darker.
- Parameters:
level: The amount by which the color should be darkened to produce the new one [0...1]. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 1, 0.5).DarkerColor(0.25) (0.5, 0.25, 0.0, 1.0) >>> Color.NewFromHsl(30, 1, 0.5).DarkerColor(0.25).hsl (30, 1, 0.25)
-
Color.
LighterColor
(level)¶ Create a new instance based on this one but lighter.
- Parameters:
level: The amount by which the color should be lightened to produce the new one [0...1]. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 1, 0.5).LighterColor(0.25) (1.0, 0.75, 0.5, 1.0) >>> Color.NewFromHsl(30, 1, 0.5).LighterColor(0.25).hsl (30, 1, 0.75)
-
Color.
Saturate
(level)¶ Create a new instance based on this one but more saturated.
- Parameters:
level: The amount by which the color should be saturated to produce the new one [0...1]. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 0.5, 0.5).Saturate(0.25) (0.875, 0.5, 0.125, 1.0) >>> Color.NewFromHsl(30, 0.5, 0.5).Saturate(0.25).hsl (30, 0.75, 0.5)
-
Color.
Desaturate
(level)¶ Create a new instance based on this one but less saturated.
- Parameters:
level: The amount by which the color should be desaturated to produce the new one [0...1]. - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 0.5, 0.5).Desaturate(0.25) (0.625, 0.5, 0.375, 1.0) >>> Color.NewFromHsl(30, 0.5, 0.5).Desaturate(0.25).hsl (30, 0.25, 0.5)
-
Color.
WebSafeDither
()¶ Return the two websafe colors nearest to this one.
- Returns:
- A tuple of two grapefruit.Color instances which are the two web safe colors closest this one.
>>> c = Color.NewFromRgb(1.0, 0.45, 0.0) >>> c1, c2 = c.WebSafeDither() >>> str(c1) '(1, 0.4, 0, 1)' >>> str(c2) '(1, 0.6, 0, 1)'
Generation methods¶
The generation methods let you create a color scheme by using a color as the start point.
All the method, appart from Gradient and MonochromeScheme, have a ‘mode’ parameter that let you choose which color wheel should be used to generate the scheme.
- The following modes are available:
ryb: The RYB color wheel, or artistic color wheel. While scientifically incorrect, it generally produces better schemes than RGB. rgb: The standard RGB color wheel.
-
Color.
Gradient
(target, steps=100)¶ Create a list with the gradient colors between this and the other color.
- Parameters:
target: The grapefruit.Color at the other end of the gradient. steps: The number of gradients steps to create. - Returns:
- A list of grapefruit.Color instances.
>>> c1 = Color.NewFromRgb(1.0, 0.0, 0.0, alpha=1) >>> c2 = Color.NewFromRgb(0.0, 1.0, 0.0, alpha=0) >>> c1.Gradient(c2, 3) [(0.75, 0.25, 0.0, 0.75), (0.5, 0.5, 0.0, 0.5), (0.25, 0.75, 0.0, 0.25)]
-
Color.
ComplementaryColor
(mode='ryb')¶ Create a new instance which is the complementary color of this one.
- Parameters:
mode: Select which color wheel to use for the generation (ryb/rgb). - Returns:
- A grapefruit.Color instance.
>>> Color.NewFromHsl(30, 1, 0.5).ComplementaryColor(mode='rgb') (0.0, 0.5, 1.0, 1.0) >>> Color.NewFromHsl(30, 1, 0.5).ComplementaryColor(mode='rgb').hsl (210, 1, 0.5)
-
Color.
MonochromeScheme
()¶ Return 4 colors in the same hue with varying saturation/lightness.
- Returns:
- A tuple of 4 grapefruit.Color in the same hue as this one, with varying saturation/lightness.
>>> c = Color.NewFromHsl(30, 0.5, 0.5) >>> ['(%g, %g, %g)' % clr.hsl for clr in c.MonochromeScheme()] ['(30, 0.2, 0.8)', '(30, 0.5, 0.3)', '(30, 0.2, 0.6)', '(30, 0.5, 0.8)']
-
Color.
TriadicScheme
(angle=120, mode='ryb')¶ Return two colors forming a triad or a split complementary with this one.
- Parameters:
angle: The angle between the hues of the created colors. The default value makes a triad. mode: Select which color wheel to use for the generation (ryb/rgb). - Returns:
- A tuple of two grapefruit.Color forming a color triad with this one or a split complementary.
>>> c1 = Color.NewFromHsl(30, 1, 0.5)
>>> c2, c3 = c1.TriadicScheme(mode='rgb') >>> c2.hsl (150.0, 1, 0.5) >>> c3.hsl (270.0, 1, 0.5)
>>> c2, c3 = c1.TriadicScheme(angle=40, mode='rgb') >>> c2.hsl (190.0, 1, 0.5) >>> c3.hsl (230.0, 1, 0.5)
-
Color.
TetradicScheme
(angle=30, mode='ryb')¶ Return three colors froming a tetrad with this one.
- Parameters:
angle: The angle to substract from the adjacent colors hues [-90...90]. You can use an angle of zero to generate a square tetrad. mode: Select which color wheel to use for the generation (ryb/rgb). - Returns:
- A tuple of three grapefruit.Color forming a color tetrad with this one.
>>> col = Color.NewFromHsl(30, 1, 0.5) >>> [c.hsl for c in col.TetradicScheme(mode='rgb', angle=30)] [(90, 1, 0.5), (210, 1, 0.5), (270, 1, 0.5)]
-
Color.
AnalogousScheme
(angle=30, mode='ryb')¶ Return two colors analogous to this one.
- Args:
angle: The angle between the hues of the created colors and this one. mode: Select which color wheel to use for the generation (ryb/rgb). - Returns:
- A tuple of grapefruit.Colors analogous to this one.
>>> c1 = Color.NewFromHsl(30, 1, 0.5)
>>> c2, c3 = c1.AnalogousScheme(angle=60, mode='rgb') >>> c2.hsl (330, 1, 0.5) >>> c3.hsl (90, 1, 0.5)
>>> c2, c3 = c1.AnalogousScheme(angle=10, mode='rgb') >>> c2.hsl (20, 1, 0.5) >>> c3.hsl (40, 1, 0.5)
Blending methods¶
-
Color.
AlphaBlend
(other)¶ Alpha-blend this color on the other one.
- Args:
other: The grapefruit.Color to alpha-blend with this one. - Returns:
- A grapefruit.Color instance which is the result of alpha-blending this color on the other one.
>>> c1 = Color.NewFromRgb(1, 0.5, 0, 0.2) >>> c2 = Color.NewFromRgb(1, 1, 1, 0.8) >>> c3 = c1.AlphaBlend(c2) >>> str(c3) '(1, 0.875, 0.75, 0.84)'
-
Color.
Blend
(other, percent=0.5)¶ Blend this color with the other one.
- Args:
other: the grapefruit.Color to blend with this one. - Returns:
- A grapefruit.Color instance which is the result of blending this color on the other one.
>>> c1 = Color.NewFromRgb(1, 0.5, 0, 0.2) >>> c2 = Color.NewFromRgb(1, 1, 1, 0.6) >>> c3 = c1.Blend(c2) >>> str(c3) '(1, 0.75, 0.5, 0.4)'


Cluster URL to connect to (e.g. mesos://host:port, spark://host:port, local[4]).
A name for your job, to display on the cluster web UI
The SPARK_HOME directory on the slave nodes
Collection of JARs to send to the cluster. These can be paths on the local file system or HDFS, HTTP, HTTPS, or FTP URLs.
Environment variables to set on worker nodes
Cluster URL to connect to (e.g. mesos://host:port, spark://host:port, local[4]).
A name for your job, to display on the cluster web UI
The SPARK_HOME directory on the slave nodes
Collection of JARs to send to the cluster. These can be paths on the local file system or HDFS, HTTP, HTTPS, or FTP URLs.
Cluster URL to connect to (e.g. mesos://host:port, spark://host:port, local[4]).
A name for your job, to display on the cluster web UI
The SPARK_HOME directory on the slave nodes
Cluster URL to connect to (e.g. mesos://host:port, spark://host:port, local[4]).
A name for your job, to display on the cluster web UI
Create an Accumulator variable of a given type, which tasks can "add" values
to using the +=
method.
Create an Accumulator variable of a given type, which tasks can "add" values
to using the +=
method. Only the master can access the accumulator's value
.
Broadcast a read-only variable to the cluster, returning a spark.Broadcast object for reading it in distributed functions.
Broadcast a read-only variable to the cluster, returning a spark.Broadcast object for reading it in distributed functions. The variable will be sent to each cluster only once.
Create an Accumulator double variable, which tasks can "add" values
to using the +=
method.
Create an Accumulator double variable, which tasks can "add" values
to using the +=
method. Only the master can access the accumulator's value
.
Get Spark's home location from either a value set through the constructor, or the spark.
Get Spark's home location from either a value set through the constructor, or the spark.home Java property, or the SPARK_HOME environment variable (in that order of preference). If neither of these is set, return None.

Get an RDD for a Hadoop-readable dataset from a Hadooop JobConf giving its InputFormat and any other necessary info (e.g. file name for a filesystem-based dataset, table name for HyperTable, etc).
Get an RDD for a Hadoop-readable dataset from a Hadooop JobConf giving its InputFormat and any other necessary info (e.
Get an RDD for a Hadoop-readable dataset from a Hadooop JobConf giving its InputFormat and any other necessary info (e.g. file name for a filesystem-based dataset, table name for HyperTable, etc).
Create an Accumulator integer variable, which tasks can "add" values
to using the +=
method.
Create an Accumulator integer variable, which tasks can "add" values
to using the +=
method. Only the master can access the accumulator's value
.
Get an RDD for a given Hadoop file with an arbitrary new API InputFormat and extra configuration options to pass to the input format.
Get an RDD for a given Hadoop file with an arbitrary new API InputFormat and extra configuration options to pass to the input format.
Load an RDD saved as a SequenceFile containing serialized objects, with NullWritable keys and BytesWritable values that contain a serialized partition.
Load an RDD saved as a SequenceFile containing serialized objects, with NullWritable keys and BytesWritable values that contain a serialized partition. This is still an experimental storage format and may not be supported exactly as is in future Spark releases. It will also be pretty slow if you use the default serializer (Java serialization), though the nice thing about it is that there's very little effort required to save arbitrary objects.
Load an RDD saved as a SequenceFile containing serialized objects, with NullWritable keys and BytesWritable values that contain a serialized partition.
Load an RDD saved as a SequenceFile containing serialized objects, with NullWritable keys and BytesWritable values that contain a serialized partition. This is still an experimental storage format and may not be supported exactly as is in future Spark releases. It will also be pretty slow if you use the default serializer (Java serialization), though the nice thing about it is that there's very little effort required to save arbitrary objects.
Distribute a local Scala collection to form an RDD.
Distribute a local Scala collection to form an RDD.
Distribute a local Scala collection to form an RDD.
Distribute a local Scala collection to form an RDD.
Distribute a local Scala collection to form an RDD.
Distribute a local Scala collection to form an RDD.
Get an RDD for a Hadoop SequenceFile.
Get an RDD for a Hadoop SequenceFile with given key and value types.

Read a text file from HDFS, a local file system (available on all nodes), or any Hadoop-supported file system URI, and return it as an RDD of Strings.
Read a text file from HDFS, a local file system (available on all nodes), or any Hadoop-supported file system URI, and return it as an RDD of Strings.
Build the union of two or more RDDs.
Build the union of two or more RDDs.
Build the union of two or more RDDs.
Build the union of two or more RDDs.
Build the union of two or more RDDs.
Build the union of two or more RDDs.
A Java-friendly version of SparkContext that returns JavaRDDs and works with Java collections instead of Scala ones.


PETER PAN Reviewed by David N. Butterworth Copyright 1989 David N. Butterworth/The Summer Pennsylvanian
Every year around this time, or during the Christmas season, the Walt Disney studios unleashes one of its treasures on the general public. The motivations behind this, no doubt, are to introduce an animated classic to today's younger audience, an audience very different from that when the film was originally released.
Last year, audiences were treated to THE LADY AND THE TRAMP. This year, it's the turn of PETER PAN, a somewhat cruder film than that canine love story, but one which manages to mix enough elements to keep the young in years -- as well as the young of spirit -- happily entertained even after they leave they theater.
Based on James M. Barrie's beloved novel, PETER PAN is a familiar coming-of-age tale to most people, made all the more so by the recent rebroadcast of the 1960s television special starring Mary Martin. This animated version is probably the only time Peter Pan has actually been "played" by a boy.
Even though the film is under 90 minutes long, it does tend to get a little draggy towards to the end. This is due in part to the fact that, about two thirds of the way through, the film peaks, only to peak again not long afterwards. Captain Hook battles Peter Pan (and that infernal ticking crocodile) and it wouldn't be giving anything away to say that the good guy triumphs. They could have ended the film right there. Instead, Hook makes off with Wendy which sets up the second climax. It's confusing for the younger set and repetitious for the older ones.
One cannot easily think about PETER PAN and not the songs which accompany it. For example "I Won't Grow Up" and "Never Smile at a Crocodile." In this animated version, the former is never heard and the latter only appears in an instrumental form backing the toothy protagonist's occasional appearances.
It's hard not to notice the backgrounds in the film. These, such as the pirate ship, Skull Rock and scenes of London, are exquisitely detailed. The characters themselves seem somewhat flat in comparison, often lacking in detail. They register emotion more by a widening of the eyes than any kind of body language.
But the film really takes off when it shows us glimpses of these children's world from an airborne point of view. The scene where the children fly over to London, following the second star on the right, is quite breathtaking, much like those IMAX films about flight they show at the National Air and Space Museum in Washington.
And shots of Never-Never Land, also from the air, are quite magical. One, of Captain Hook and first mate Smee in a boat with captive Indian Tiger Lilly, is so beautifully animated that the water looks real. Disney has always been able to convincingly bring water to life in all his movies -- remember the storm in BAMBI or the subterranean sequences in PINOCCHIO?
If you can ignore some of the film's minor flaws, you should have a ripe old time at the movies. Thirty-six years after it was made, PETER PAN still makes for a wonderfully colorful entertainment.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


auth
nix.track-api-client.nixTrackApiClient
Auth related endpoints
Password reset related endpoints
logs into a user.
minimum of password, and either phone or email fields
User object


This user is a {{age}} year old {{gender}} and {{status}}. They work as an {{job}}. They reside in {{location}}. Date Added: {{createdAt}}
Please activate a user(s) to view their Scenerios.


{% load webcamp %} {{ talk.starts_at|date:"l, Y-m-d @ H:i" }} > Skill level: {{ talk.skill_level|skill_level }} > Duration: {{ talk.duration }} min


Same HTML, new name on spdsht based on month number
Old method, change HTML ea mo.:
Date changes ea mo
New method, change HTML via JavaScript: