My name is Ayush Kumar. I am an interactive web and e-learning designer/developer and currently training in coding ninja.My passion is all about creating and elegant looking websites.Always keeping it clean and simple with that added functionality of user interaction you would like to see me. I am open to job opportunities below my matching skills.
SKILLS
Education
B.E. Degree
University Institute of Technology Burdwan,West Bengal
Computer Science
72%
Aug 2015 - Jul 2019
Certificate of Participation in UTKRISHT 2015 (Technical Fest of UIT BU), Certificate of Participation in Inter College Quiz Competition organised by Burdwan Science Centre, Because of my coordinating skills I was selected as Event Coordinator of UTKRISHT 2018(Technical Festival of UIT BU), Served as the Team of coding club "The Code Bird" where I have to arrange classes,workshop and seminar.
Intermediate Degree
Army Public School Basistha,Guwahati
77%
Jul 2013 - May 2014
Certificate of Science Olympiad, Certificate of Inter School Cricket Competition.
H.S. Degree
kendriya Vidyalaya CRPF GC Amerigog,Guwahati
76%
Aug 2011 - May 2012
Certificate of Social-Science Exhibition,Certificate of Trityia Soapan in Scout & Guide, Certificate of Regional Sports.
Portfolio
Contact
Get In touch
Emails us with any question or enquiries.We would be happy to answer your question


welcome to about me page
home
hello my name is siham khaloof . abiomedical engineer ,i have graduated from yarmouk university.


Objective: Use the navigation buttons to help the ant get to the pot of honey. You won't be able to get through those anteasters, so watch out! You have 20 seconds, beware that the anteaters don't sit still!


IEEE is the world’s largest technical professional organization dedicated to advancing technology for the benefit of humanity. IEEE and its members inspire a global community through its highly cited publications, conferences, technology standards, and professional and educational activities.
About IEEE Brainwaves
IEEE Brainwaves is the Student Branch (code: 60401) of the IEEE at Dwarkadas J. Sanghvi College of Engineering. It is duly recognized by the IEEE, USA. IEEE Brainwaves was established in 1997. Our sole motive is to spread awareness regarding upcoming development in the field of technology and to maintain interest groups which work together and take part in various competitions.


{% extends path+"/layout.html" %} {% block page %}
Use this service to send DWP a doctor’s note for your Employment and Support Allowance or Universal Credit claim.


Install via NPM.
npm install rocket-modal
Note that this module has a dependency Rocket Tools (21kb) which will automatically be installed as well.
Start by including the necessary files.
 <link href="node_modules/rocket-modal/css/modal.min.css" rel="stylesheet" type="text/css">   /* Your content goes here */
See a basic example of how to use the module.
Open New Modal
If you want to open a modal that has existing HTML, then link to the modal. Note that a predefined HTML structure is required.
Open Linked Modal

The Linked Modal Heading

 This is the modal body.

It is also possible to manually trigger a modal if you so choose. This is not recommended for targeted modals as you will be initialising each time which is redundant. In this case you probably want to parse the event to prevent odd click behaviors. For example:
Open New Modal
For a more detailed look into the available options, you can read the documentation at https://github.com/chrishumboldt/Rocket-Modal


Web Page
This is my first web page.
How exciting.
This is
- to learn HTML
- to show off
- To my friends
- To my cat
- To the little talking duck in my brain
- to better myselft
Where to find the tutorial
Here!
Now... Tables
| Row 1, cell 1 |
Row 1, cell 2 |
Row 1, cell 3 |
| Row 2, cell 1 |
Row 2, cell 2 |
Row 2, cell 3 |
| Row 3, cell 1 |
Row 3, cell 2 |
Row 3, cell 3 |
Forms!
Text area
Select


**Event Horizon** Reviewed by Jeff Walters
Man, this was one wierd movie. Similar to Conspiracy Theory in that it couldn't decide which genre it is. The first hour is your standard stock Aliens clone, which nicely created an eerie atmosphere about the ship. The last half hour? This was when the makers blew the script out the airlock and just decided - "Screw it, let's just kill everybody". From then on - forget Sci-Fi...this movie becomes 100% horror.
What really dissappointed me about this movie was that it tried to scare you in entirely the wrong way. Instead of using clever tricks or trying to build up to a scare - this movie just uses loud noises, sudden camera shifts and short quick bursts of gore.....yawn....everyone's seen it all before and knows when to expect it. The one thing that was done well was the lead up to finding out about what happened to the previous crew. There are skeletons lying around mangled and mashed, but what did this? Then finally after being painfully restored - the new crew views the video.
The acting isn't too bad at all.....considering what the actors had to work with anyway, as there is no complex or interesting dialogue to speak of. There was some very nice camerawork in certain sequences though, like when the hull near the bridge of the Event Horizon is breached and the camera pans back to follow specific objects as they bounce across the deck and are sucked out into space.
This movie could have been so much better. It had a good experienced cast who deserved more to work with. There was just nothing new here that any of us haven't seen before in Aliens or Hellraiser.
2 stars out of 5
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


phi.python_builder module
from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals from .builder import Builder from . import utils import inspect class PythonBuilder(Builder): """ Methods that start with a lowercase letter are most probably core python functions automatically as methods (e.g. `phi.builder.Builder.map` or `phi.builder.Builder.sum`). There is a third batch of methods that like `phi.builder.Builder.And`, `phi.builder.Builder.Not`, `phi.builder.Builder.Contains`, etc, that are not considered core `Builder` methods but are packaged with this class for conveniece, initially they where capitalized because they mimimic keywords (`and`, `or`, `not`, etc) and its ilegal to give them these lowercase names, however, methods like `phi.builder.Builder.Contains` that could use lowercase are left capitalized to maintain uniformity. """ # built in functions function_2_names = ["map", "filter", "reduce"] functions_2 = [ (name, f) for name, f in __builtins__.items() if name in function_2_names ] for name, f in __builtins__.items(): try: if hasattr(f, "__name__") and name[0] is not "_" and not name[0].isupper() and name not in function_2_names: PythonBuilder.Register(f, "python", alias=name) except Exception as e: print(e) for name, f in functions_2: PythonBuilder.Register2(f, "python") #custom methods @PythonBuilder.Register("python", explain=False) def Not(x): return not x @PythonBuilder.Register("python") def Contains(x, y): return y in x @PythonBuilder.Register("python") def In(x, y): return x in y @PythonBuilder.Register("python", explain=False) def And(x, y): return x and y @PythonBuilder.Register("python") def Or(x, y): return x or y @PythonBuilder.Register("python") def First(x): return next(iter(x)) @PythonBuilder.Register("python") def Last(x): return list(x)[-1] # __all__ = ["PythonBuilder"]
Module variables
var function_2_names
var functions_2
var name
Functions
def And(
x, y)
@PythonBuilder.Register("python", explain=False) def And(x, y): return x and y
def Contains(
x, y)
@PythonBuilder.Register("python") def Contains(x, y): return y in x
def First(
x)
@PythonBuilder.Register("python") def First(x): return next(iter(x))
def In(
x, y)
@PythonBuilder.Register("python") def In(x, y): return x in y
def Last(
x)
@PythonBuilder.Register("python") def Last(x): return list(x)[-1]
def Not(
x)
@PythonBuilder.Register("python", explain=False) def Not(x): return not x
def Or(
x, y)
@PythonBuilder.Register("python") def Or(x, y): return x or y
Classes
class PythonBuilder
Methods that start with a lowercase letter are most probably core python functions automatically as methods (e.g. phi.builder.Builder.map
or phi.builder.Builder.sum
). There is a third batch of methods that like phi.builder.Builder.And
, phi.builder.Builder.Not
, phi.builder.Builder.Contains
, etc, that are not considered core Builder
methods but are packaged with this class for conveniece, initially they where capitalized because they mimimic keywords (and
, or
, not
, etc) and its ilegal to give them these lowercase names, however, methods like phi.builder.Builder.Contains
that could use lowercase are left capitalized to maintain uniformity.
class PythonBuilder(Builder): """ Methods that start with a lowercase letter are most probably core python functions automatically as methods (e.g. `phi.builder.Builder.map` or `phi.builder.Builder.sum`). There is a third batch of methods that like `phi.builder.Builder.And`, `phi.builder.Builder.Not`, `phi.builder.Builder.Contains`, etc, that are not considered core `Builder` methods but are packaged with this class for conveniece, initially they where capitalized because they mimimic keywords (`and`, `or`, `not`, etc) and its ilegal to give them these lowercase names, however, methods like `phi.builder.Builder.Contains` that could use lowercase are left capitalized to maintain uniformity. """
Ancestors (in MRO)
- PythonBuilder
- phi.builder.Builder
- phi.lambdas.Lambda
- phi.dsl.Function
- phi.dsl.Node
- __builtin__.object
Class variables
var Ref
Instance variables
var Obj
var Read
var Rec
var Write
Methods
def __init__(
self, f)
def __init__(self, f): super(Lambda, self).__init__(f) self._f = f
def And(
self, *args, **kwargs)
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def Contains(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.Contains(*args, **kwargs)
It accepts the same arguments as python.Contains
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.Contains(x1, *args, **kwargs)
is equivalent to
builder.Contains(*args, **kwargs)(x1)
python.Contains
None
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def Context(
cls, *args)
Builder Core. Also available as a global function as phi.Context
.
Returns the context object of the current dsl.With
statemente.
Arguments
- *args: By design
Context
accepts any number of arguments and completely ignores them.
This is a classmethod and it doesnt return a Builder
/Lambda
by design so it can be called directly:
from phi import P, Context, Obj def read_file(z): f = Context() return f.read() lines = P.Pipe( "text.txt", P.With( open, read_file, Obj.split("\n") ) )
Here we called Context
with no arguments to get the context back, however, since you can also give this function an argument (which it will ignore) it can be passed to the DSL so we can rewrite the previous as:
from phi import P, Context, Obj lines = P.Pipe( "text.txt", P.With( open, Context, # f Obj.read() Obj.split("\n") ) )
Context
yields an exception when used outside of a With
block.
Also see
phi.builder.Builder.Obj
- dsl
@classmethod def Context(cls, *args): """ ilder Core**. Also available as a global function as `phi.Context`. rns the context object of the current `dsl.With` statemente. guments** *args**: By design `Context` accepts any number of arguments and completely ignores them. is a classmethod and it doesnt return a `Builder`/`Lambda` by design so it can be called directly: from phi import P, Context, Obj def read_file(z): f = Context() return f.read() lines = P.Pipe( "text.txt", P.With( open, read_file, Obj.split("\\n") ) ) we called `Context` with no arguments to get the context back, however, since you can also give this function an argument (which it will ignore) it can be passed to the DSL so we can rewrite the previous as: from phi import P, Context, Obj lines = P.Pipe( "text.txt", P.With( open, Context, # f Obj.read() Obj.split("\\n") ) ) text` yields an exception when used outside of a `With` block. so see** hi.builder.Builder.Obj` sl](https://cgarciae.github.io/phi/dsl.m.html) """ if dsl.CompilationContextManager.WITH_GLOBAL_CONTEXT is dsl._NO_VALUE: raise Exception("Cannot use 'Context' outside of a 'With' block") return dsl.CompilationContextManager.WITH_GLOBAL_CONTEXT
def First(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.First(*args, **kwargs)
It accepts the same arguments as python.First
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.First(x1, *args, **kwargs)
is equivalent to
builder.First(*args, **kwargs)(x1)
python.First
None
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def If(
self, *args, **kwargs)
docstring for If.
def If(self, *args, **kwargs): return self.NMake(dsl.If(*args, **kwargs))
def In(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.In(*args, **kwargs)
It accepts the same arguments as python.In
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.In(x1, *args, **kwargs)
is equivalent to
builder.In(*args, **kwargs)(x1)
python.In
None
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def Last(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.Last(*args, **kwargs)
It accepts the same arguments as python.Last
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.Last(x1, *args, **kwargs)
is equivalent to
builder.Last(*args, **kwargs)(x1)
python.Last
None
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def Make(
self, *code, **kwargs)
The Make
method takes an expression from the DSL and compiles it to a function.
Arguments
- *code: any expression from the DSL.
code
is implicitly atuple
since that is what Python gives you when you declare a Variadic Function, therefore, according to the rules of the DSL, all expressions inside ofcode
will be composed together. See Composition. - flatten = False: if
flatten
is True and the argument being returned by the compiled function is alist
it will instead return a flattened list. - _return_type = None: By default
Make
returns an object of the same class e.g.Builder
, however you can pass in a custom class that inherits fromBuilder
as the returned contianer. This is useful if the custom builder has specialized methods. - create_ref_context = True: determines if a reference manager should be created on compilation. See Compile.
- refs = True: external/default values for references passed during compilation. See Compile.
Examples
from phi import P def add1(x): return x + 1 def mul3(x): return x * 3 f = P.Make( add1, mul3 ) assert f(1) == 6
Here f
is equivalent to
def f(x): x = add1(x) x = mul3(x) return x
The previous example using lambdas to create the functions
from phi import P f = P.Make( P + 1, P * 3 ) assert f(1) == 6
Also see
def Make(self, *code, **kwargs): """ `Make` method takes an expression from the DSL and compiles it to a function. guments** *code**: any expression from the DSL.`code` is implicitly a `tuple` since that is what Python gives you when you declare a [Variadic Function](https://docs.python.org/3/tutorial/controlflow.html#arbitrary-argument-lists), therefore, according to the rules of the DSL, all expressions inside of `code` will be composed together. See [Composition](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Composition). latten = False*: if `flatten` is True and the argument being returned by the compiled function is a `list` it will instead return a flattened list. return_type = None*: By default `Make` returns an object of the same class e.g. `Builder`, however you can pass in a custom class that inherits from `Builder` as the returned contianer. This is useful if the custom builder has specialized methods. reate_ref_context = True*: determines if a reference manager should be created on compilation. See [Compile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile). efs = True*: external/default values for references passed during compilation. See [Compile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile). amples** from phi import P def add1(x): return x + 1 def mul3(x): return x * 3 f = P.Make( add1, mul3 ) assert f(1) == 6 `f` is equivalent to f(x): x = add1(x) x = mul3(x) return x previous example using [lambdas](https://cgarciae.github.io/phi/lambdas.m.html) to create the functions from phi import P f = P.Make( P + 1, P * 3 ) assert f(1) == 6 so see** sl](https://cgarciae.github.io/phi/dsl.m.html) ompile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile) ambdas](https://cgarciae.github.io/phi/lambdas.m.html) """ _return_type = kwargs.get('_return_type', None) flatten = kwargs.get('flatten', False) refs = kwargs.get('refs', {}) create_ref_context = kwargs.get('create_ref_context', True) # code = (self, code) if flatten: code = (code, lambda x: utils.flatten_list(x) if type(x) is list else x) f = dsl.Compile(code, refs, create_ref_context=create_ref_context) return self.__then__(f, _return_type=_return_type)
def NMake(
self, *args, **kwargs)
NMake
is shortcut for Make(..., create_ref_context=False)
, its full name should be NoCreateRefContextMake but its impractically long. Normally methods that compile DSL expressions like phi.builder.Builder.Make
or phi.builder.Builder.Pipe
create a reference context unless especified, these contexts encapsulate references (see read or write) and prevent them from leaking, which is good. There are times however when you consciously want a sub-Make or sub-Pipe expression to read or write references from the main Make or Pipe expression, for this you need to set create_ref_context
to False
.
Arguments
- Same arguments as
phi.builder.Builder.Make
but... - create_ref_context is hardcoded to
False
Examples
If you compile a sub expression as a function for another expression e.g.
from phi import P assert 1 == P.Pipe( 1, {'s'}, # write s == 1, outer context P.Make( P + 1, {'s'} # write s == 2, inner context ), 's' # read s == 1, outer context )
you find that references are not shared. However if you avoid the creation of a new reference context via a keyword arguments
from phi import P assert 2 == P.Pipe( 1, {'s'}, #write s == 1, same context P.Make( P + 1, {'s'}, #write s == 2, same context create_ref_context=False ), 's' # read s == 2, same context )
you can achieve what you want. Yet writting create_ref_context=False
is a little cumbersome, so to make things nicer we just use a shortcut by appending an N
at the beggining of the NMake
method
from phi import P assert 2 == P.Pipe( 1, {'s'}, #write s == 1, same context P.NMake( P + 1, {'s'} #write s == 2, same context ), 's' # read s == 2, same context )
Also see
def NMake(self, *args, **kwargs): """ ke` is shortcut for `Make(..., create_ref_context=False)`, its full name should be *NoCreateRefContextMake* but its impractically long. Normally methods that [compile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile) DSL expressions like `phi.builder.Builder.Make` or `phi.builder.Builder.Pipe` create a reference context unless especified, these contexts encapsulate references (see [read](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Read) or [write](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Write)) and prevent them from leaking, which is good. There are times however when you consciously want a sub-Make or sub-Pipe expression to read or write references from the main Make or Pipe expression, for this you need to set `create_ref_context` to `False`. guments** me arguments as `phi.builder.Builder.Make` but... create_ref_context** is hardcoded to `False` amples** ou compile a sub expression as a function for another expression e.g. from phi import P assert 1 == P.Pipe( 1, {'s'}, # write s == 1, outer context P.Make( P + 1, {'s'} # write s == 2, inner context ), 's' # read s == 1, outer context ) find that references are not shared. However if you avoid the creation of a new reference context via a keyword arguments from phi import P assert 2 == P.Pipe( 1, {'s'}, #write s == 1, same context P.Make( P + 1, {'s'}, #write s == 2, same context create_ref_context=False ), 's' # read s == 2, same context ) can achieve what you want. Yet writting `create_ref_context=False` is a little cumbersome, so to make things nicer we just use a shortcut by appending an `N` at the beggining of the `NMake` method from phi import P assert 2 == P.Pipe( 1, {'s'}, #write s == 1, same context P.NMake( P + 1, {'s'} #write s == 2, same context ), 's' # read s == 2, same context ) so see** hi.builder.Builder.Make` hi.builder.Builder.NPipe` hi.builder.Builder.NRun` sl](https://cgarciae.github.io/phi/dsl.m.html) ompile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile) """ kwargs['create_ref_context'] = False return self.Make(*args, **kwargs)
def NPipe(
self, x, *code, **kwargs)
NPipe
is shortcut for Pipe(..., create_ref_context=False)
, its full name should be NoCreateRefContextPipe but its impractically long. Normally methods that compile DSL expressions like phi.builder.Builder.Make
or phi.builder.Builder.Pipe
create a reference context unless especified, these contexts encapsulate references (see read or write) and prevent them from leaking, which is good. There are times however when you consciously want a sub-Make or sub-Pipe expression to read or write references from the main Make or Pipe expression, for this you need to set create_ref_context
to False
.
Arguments
- Same arguments as
phi.builder.Builder.Pipe
but... - create_ref_context is hardcoded to
False
Examples
If you compile a sub expression as a function for another expression e.g.
from phi import P assert 1 == P.Pipe( 1, {'s'}, # write s == 1, outer context lambda x: P.Pipe( x, P + 1, {'s'} # write s == 2, inner context ), 's' # read s == 1, outer context )
you find that references are not shared. However if you avoid the creation of a new reference context via a keyword arguments
from phi import P assert 2 == P.Pipe( 1, {'s'}, #write s == 1, same context lambda x: P.Pipe( x, P + 1, {'s'}, #write s == 2, same context create_ref_context=False ), 's' # read s == 2, same context )
you can achieve what you want. Yet writting create_ref_context=False
is a little cumbersome, so to make things nicer we just use a shortcut by appending an N
at the beggining of the NPipe
method
from phi import P assert 2 == P.Pipe( 1, {'s'}, #write s == 1, same context lambda x: P.NPipe( x, P + 1, {'s'} #write s == 2, same context ), 's' # read s == 2, same context )
Also see
def NPipe(self, x, *code, **kwargs): """ pe` is shortcut for `Pipe(..., create_ref_context=False)`, its full name should be *NoCreateRefContextPipe* but its impractically long. Normally methods that [compile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile) DSL expressions like `phi.builder.Builder.Make` or `phi.builder.Builder.Pipe` create a reference context unless especified, these contexts encapsulate references (see [read](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Read) or [write](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Write)) and prevent them from leaking, which is good. There are times however when you consciously want a sub-Make or sub-Pipe expression to read or write references from the main Make or Pipe expression, for this you need to set `create_ref_context` to `False`. guments** me arguments as `phi.builder.Builder.Pipe` but... create_ref_context** is hardcoded to `False` amples** ou compile a sub expression as a function for another expression e.g. from phi import P assert 1 == P.Pipe( 1, {'s'}, # write s == 1, outer context lambda x: P.Pipe( x, P + 1, {'s'} # write s == 2, inner context ), 's' # read s == 1, outer context ) find that references are not shared. However if you avoid the creation of a new reference context via a keyword arguments from phi import P assert 2 == P.Pipe( 1, {'s'}, #write s == 1, same context lambda x: P.Pipe( x, P + 1, {'s'}, #write s == 2, same context create_ref_context=False ), 's' # read s == 2, same context ) can achieve what you want. Yet writting `create_ref_context=False` is a little cumbersome, so to make things nicer we just use a shortcut by appending an `N` at the beggining of the `NPipe` method from phi import P assert 2 == P.Pipe( 1, {'s'}, #write s == 1, same context lambda x: P.NPipe( x, P + 1, {'s'} #write s == 2, same context ), 's' # read s == 2, same context ) so see** hi.builder.Builder.Pipe` hi.builder.Builder.NMake` hi.builder.Builder.NRun` sl](https://cgarciae.github.io/phi/dsl.m.html) ompile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile) """ return self.NMake(*code, **kwargs)(x)
def NRun(
self, *code, **kwargs)
NRun
is shortcut for Run(..., create_ref_context=False)
, its full name should be NoCreateRefContextRun but its impractically long.
Also see
def NRun(self, *code, **kwargs): """ n` is shortcut for `Run(..., create_ref_context=False)`, its full name should be *NoCreateRefContextRun* but its impractically long. so see** hi.builder.Builder.Run` hi.builder.Builder.NMake` hi.builder.Builder.NPipe` sl](https://cgarciae.github.io/phi/dsl.m.html) ompile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile) """ return self.NPipe(None, *code, **kwargs)
def Not(
self, *args, **kwargs)
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def Or(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.Or(*args, **kwargs)
It accepts the same arguments as python.Or
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.Or(x1, *args, **kwargs)
is equivalent to
builder.Or(*args, **kwargs)(x1)
python.Or
None
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def Pipe(
self, x, *code, **kwargs)
Pipe
is method that takes an input argument plus an expression from the DSL, it compiles the expression and applies the resulting function to the input. Its highly inspired by Elixir's |> (pipe) operator.
Arguments
- x: any input object
- *code: any expression from the DSL.
code
is implicitly atuple
since that is what Python gives you when you declare a Variadic Function, therefore, according to the rules of the DSL, all expressions inside ofcode
will be composed together. See Composition. - **kwargs:
Pipe
forwards allkwargs
tophi.builder.Builder.Make
, visit its documentation for more info.
Examples
from phi import P def add1(x): return x + 1 def mul3(x): return x * 3 x = P.Pipe( 1, #input add1, #1 + 1 == 2 mul3 #2 * 3 == 6 ) assert x == 6
The previous using lambdas to create the functions
from phi import P x = P.Pipe( 1, #input P + 1, #1 + 1 == 2 P * 3 #2 * 3 == 6 ) assert x == 6
Also see
def Pipe(self, x, *code, **kwargs): """ e` is method that takes an input argument plus an expression from the DSL, it compiles the expression and applies the resulting function to the input. Its highly inspired by Elixir's [|> (pipe)](https://hexdocs.pm/elixir/Kernel.html#%7C%3E/2) operator. guments** x**: any input object *code**: any expression from the DSL.`code` is implicitly a `tuple` since that is what Python gives you when you declare a [Variadic Function](https://docs.python.org/3/tutorial/controlflow.html#arbitrary-argument-lists), therefore, according to the rules of the DSL, all expressions inside of `code` will be composed together. See [Composition](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Composition). **kwargs**: `Pipe` forwards all `kwargs` to `phi.builder.Builder.Make`, visit its documentation for more info. amples** from phi import P def add1(x): return x + 1 def mul3(x): return x * 3 x = P.Pipe( 1, #input add1, #1 + 1 == 2 mul3 #2 * 3 == 6 ) assert x == 6 previous using [lambdas](https://cgarciae.github.io/phi/lambdas.m.html) to create the functions from phi import P x = P.Pipe( 1, #input P + 1, #1 + 1 == 2 P * 3 #2 * 3 == 6 ) assert x == 6 so see** hi.builder.Builder.Make` hi.builder.Builder.Run` sl](https://cgarciae.github.io/phi/dsl.m.html) ompile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile) ambdas](https://cgarciae.github.io/phi/lambdas.m.html) """ return self.Make(*code, **kwargs)(x)
def Register(
cls, *args, **kwargs)
@classmethod def Register(cls, *args, **kwargs): return cls.RegisterAt(1, *args, **kwargs)
def Register0(
cls, *args, **kwargs)
@classmethod def Register0(cls, *args, **kwargs): return cls.RegisterAt(0, *args, **kwargs)
def Register2(
cls, *args, **kwargs)
@classmethod def Register2(cls, *args, **kwargs): return cls.RegisterAt(2, *args, **kwargs)
def Register3(
cls, *args, **kwargs)
@classmethod def Register3(cls, *args, **kwargs): return cls.RegisterAt(3, *args, **kwargs)
def Register4(
cls, *args, **kwargs)
@classmethod def Register4(cls, *args, **kwargs): return cls.RegisterAt(4, *args, **kwargs)
def Register5(
cls, *args, **kwargs)
@classmethod def Register5(cls, *args, **kwargs): return cls.RegisterAt(5, *args, **kwargs)
def RegisterAt(
cls, *args, **kwargs)
@classmethod def RegisterAt(cls, *args, **kwargs): try: n, fn, library_path = args cls._RegisterAt(n, fn, library_path, **kwargs) except: def register_decorator(fn): n, library_path = args cls._RegisterAt(n, fn, library_path, **kwargs) return fn return register_decorator
def RegisterMethod(
cls, *args, **kwargs)
@classmethod def RegisterMethod(cls, *args, **kwargs): try: fn, library_path = args cls._RegisterMethod(fn, library_path, **kwargs) except: def register_decorator(fn): library_path, = args cls._RegisterMethod(fn, library_path, **kwargs) return fn return register_decorator
def Run(
self, *code, **kwargs)
Run(*code, **kwargs)
is equivalent to Pipe(None, *code, **kwargs)
, that is, it compiles the code and applies in a None
value.
Arguments
- Same as
phi.builder.Builder.Make
.
Examples
You might create code that totally ignores its input argument e.g.
from phi import P result = P.Pipe( None, dict( x = ( Val(10), P + 1 ), y = ( Val(5), P * 5 ) ) ) assert result.x == 9 assert result.y == 25
Here the Val
statemente drops the None
and introduces its own constants. Given this its more suitable to use Run
from phi import P result = P.Run( dict( x = ( Val(10), P + 1 ), y = ( Val(5), P * 5 ) ) ) assert result.x == 9 assert result.y == 25
Also see
def Run(self, *code, **kwargs): """ (*code, **kwargs)` is equivalent to `Pipe(None, *code, **kwargs)`, that is, it compiles the code and applies in a `None` value. guments** me as `phi.builder.Builder.Make`. amples** might create code that totally ignores its input argument e.g. from phi import P result = P.Pipe( None, dict( x = ( Val(10), P + 1 ), y = ( Val(5), P * 5 ) ) ) assert result.x == 9 assert result.y == 25 the `Val` statemente drops the `None` and introduces its own constants. Given this its more suitable to use `Run` from phi import P result = P.Run( dict( x = ( Val(10), P + 1 ), y = ( Val(5), P * 5 ) ) ) assert result.x == 9 assert result.y == 25 so see** hi.builder.Builder.Make` hi.builder.Builder.Pipe` sl](https://cgarciae.github.io/phi/dsl.m.html) ompile](https://cgarciae.github.io/phi/dsl.m.html#phi.dsl.Compile) """ return self.Pipe(None, *code, **kwargs)
def Then(
self, expr, *args, **kwargs)
def Then(self, expr, *args, **kwargs): """ """ return self.ThenAt(1, expr, *args, **kwargs)
def Then0(
self, expr, *args, **kwargs)
def Then0(self, expr, *args, **kwargs): """ """ return self.ThenAt(0, expr, *args, **kwargs)
def Then1(
self, expr, *args, **kwargs)
def Then(self, expr, *args, **kwargs): """ """ return self.ThenAt(1, expr, *args, **kwargs)
def Then2(
self, expr, arg1, *args, **kwargs)
def Then2(self, expr, arg1, *args, **kwargs): """ """ args = (arg1,) + args return self.ThenAt(2, expr, *args, **kwargs)
def Then3(
self, expr, arg1, arg2, *args, **kwargs)
def Then3(self, expr, arg1, arg2, *args, **kwargs): """ """ args = (arg1, arg2) + args return self.ThenAt(3, expr, *args, **kwargs)
def Then4(
self, expr, arg1, arg2, arg3, *args, **kwargs)
def Then4(self, expr, arg1, arg2, arg3, *args, **kwargs): """ """ args = (arg1, arg2, arg3) + args return self.ThenAt(4, expr, *args, **kwargs)
def Then5(
self, expr, arg1, arg2, arg3, arg4, *args, **kwargs)
def Then5(self, expr, arg1, arg2, arg3, arg4, *args, **kwargs): """ """ args = (arg1, arg2, arg3, arg4) + args return self.ThenAt(5, expr, *args, **kwargs)
def ThenAt(
self, n, expr, *args, **kwargs)
def ThenAt(self, n, expr, *args, **kwargs): _return_type = None n -= 1 if '_return_type' in kwargs: _return_type = kwargs['_return_type'] del kwargs['_return_type'] def _lambda(x): x = self(x) new_args = args[0:n] + (x,) + args[n:] if n >= 0 else args return expr(*new_args, **kwargs) return self.__unit__(_lambda, _return_type=_return_type)
def Val(
self, x)
def Val(self, x): """ """ return self.__then__(lambda z: x)
def With(
self, *args, **kwargs)
With
def With(context_manager, *body):
Arguments
- context_manager: a context manager object or valid expression from the DSL that returns a context manager.
- *body: any valid expression of the DSL to be evaluated inside the context.
*body
is interpreted as a tuple so all expression contained are composed.
As with normal python programs you sometimes might want to create a context for a block of code. You normally give a context manager to the with statemente, in Phi you use P.With
or phi.With
Context
Python's with
statemente returns a context object through as
keyword, in the DSL this object can be obtained using the P.Context
method or the phi.Context
function.
Examples
from phi import P, Obj, Context, With, Pipe text = Pipe( "text.txt", With( open, Context, Obj.read() ) )
The previous is equivalent to
with open("text.txt") as f: text = f.read()
def With(self, *args, **kwargs): return self.NMake(dsl.With(*args, **kwargs))
def abs(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.abs(*args, **kwargs)
It accepts the same arguments as python.abs
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.abs(x1, *args, **kwargs)
is equivalent to
builder.abs(*args, **kwargs)(x1)
python.abs
abs(number) -> number
Return the absolute value of the argument.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def all(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.all(*args, **kwargs)
It accepts the same arguments as python.all
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.all(x1, *args, **kwargs)
is equivalent to
builder.all(*args, **kwargs)(x1)
python.all
all(iterable) -> bool
Return True if bool(x) is True for all values x in the iterable. If the iterable is empty, return True.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def any(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.any(*args, **kwargs)
It accepts the same arguments as python.any
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.any(x1, *args, **kwargs)
is equivalent to
builder.any(*args, **kwargs)(x1)
python.any
any(iterable) -> bool
Return True if bool(x) is True for any x in the iterable. If the iterable is empty, return False.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def apply(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.apply(*args, **kwargs)
It accepts the same arguments as python.apply
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.apply(x1, *args, **kwargs)
is equivalent to
builder.apply(*args, **kwargs)(x1)
python.apply
apply(object[, args[, kwargs]]) -> value
Call a callable object with positional arguments taken from the tuple args, and keyword arguments taken from the optional dictionary kwargs. Note that classes are callable, as are instances with a call() method.
Deprecated since release 2.3. Instead, use the extended call syntax: function(args, *keywords).
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def basestring(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.basestring(*args, **kwargs)
It accepts the same arguments as python.basestring
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.basestring(x1, *args, **kwargs)
is equivalent to
builder.basestring(*args, **kwargs)(x1)
python.basestring
Type basestring cannot be instantiated; it is the base for str and unicode.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def bin(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.bin(*args, **kwargs)
It accepts the same arguments as python.bin
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.bin(x1, *args, **kwargs)
is equivalent to
builder.bin(*args, **kwargs)(x1)
python.bin
bin(number) -> string
Return the binary representation of an integer or long integer.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def bool(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.bool(*args, **kwargs)
It accepts the same arguments as python.bool
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.bool(x1, *args, **kwargs)
is equivalent to
builder.bool(*args, **kwargs)(x1)
python.bool
bool(x) -> bool
Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def buffer(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.buffer(*args, **kwargs)
It accepts the same arguments as python.buffer
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.buffer(x1, *args, **kwargs)
is equivalent to
builder.buffer(*args, **kwargs)(x1)
python.buffer
buffer(object [, offset[, size]])
Create a new buffer object which references the given object. The buffer will reference a slice of the target object from the start of the object (or at the specified offset). The slice will extend to the end of the target object (or with the specified size).
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def bytearray(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.bytearray(*args, **kwargs)
It accepts the same arguments as python.bytearray
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.bytearray(x1, *args, **kwargs)
is equivalent to
builder.bytearray(*args, **kwargs)(x1)
python.bytearray
bytearray(iterable_of_ints) -> bytearray.
bytearray(string, encoding[, errors]) -> bytearray. bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray. bytearray(memory_view) -> bytearray.
Construct a mutable bytearray object from: - an iterable yielding integers in range(256) - a text string encoded using the specified encoding - a bytes or a bytearray object - any object implementing the buffer API.
bytearray(int) -> bytearray.
Construct a zero-initialized bytearray of the given length.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def bytes(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.bytes(*args, **kwargs)
It accepts the same arguments as python.bytes
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.bytes(x1, *args, **kwargs)
is equivalent to
builder.bytes(*args, **kwargs)(x1)
python.bytes
str(object='') -> string
Return a nice string representation of the object. If the argument is a string, the return value is the same object.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def callable(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.callable(*args, **kwargs)
It accepts the same arguments as python.callable
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.callable(x1, *args, **kwargs)
is equivalent to
builder.callable(*args, **kwargs)(x1)
python.callable
callable(object) -> bool
Return whether the object is callable (i.e., some kind of function). Note that classes are callable, as are instances with a call() method.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def chr(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.chr(*args, **kwargs)
It accepts the same arguments as python.chr
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.chr(x1, *args, **kwargs)
is equivalent to
builder.chr(*args, **kwargs)(x1)
python.chr
chr(i) -> character
Return a string of one character with ordinal i; 0 <= i < 256.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def classmethod(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.classmethod(*args, **kwargs)
It accepts the same arguments as python.classmethod
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.classmethod(x1, *args, **kwargs)
is equivalent to
builder.classmethod(*args, **kwargs)(x1)
python.classmethod
classmethod(function) -> method
Convert a function to be a class method.
A class method receives the class as implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom:
class C: def f(cls, arg1, arg2, ...): ... f = classmethod(f)
It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument.
Class methods are different than C++ or Java static methods. If you want those, see the staticmethod builtin.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def cmp(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.cmp(*args, **kwargs)
It accepts the same arguments as python.cmp
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.cmp(x1, *args, **kwargs)
is equivalent to
builder.cmp(*args, **kwargs)(x1)
python.cmp
cmp(x, y) -> integer
Return negative if x
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def coerce(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.coerce(*args, **kwargs)
It accepts the same arguments as python.coerce
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.coerce(x1, *args, **kwargs)
is equivalent to
builder.coerce(*args, **kwargs)(x1)
python.coerce
coerce(x, y) -> (x1, y1)
Return a tuple consisting of the two numeric arguments converted to a common type, using the same rules as used by arithmetic operations. If coercion is not possible, raise TypeError.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def compile(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.compile(*args, **kwargs)
It accepts the same arguments as python.compile
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.compile(x1, *args, **kwargs)
is equivalent to
builder.compile(*args, **kwargs)(x1)
python.compile
compile(source, filename, mode[, flags[, dont_inherit]]) -> code object
Compile the source string (a Python module, statement or expression) into a code object that can be executed by the exec statement or eval(). The filename will be used for run-time error messages. The mode must be 'exec' to compile a module, 'single' to compile a single (interactive) statement, or 'eval' to compile an expression. The flags argument, if present, controls which future statements influence the compilation of the code. The dont_inherit argument, if non-zero, stops the compilation inheriting the effects of any future statements in effect in the code calling compile; if absent or zero these statements do influence the compilation, in addition to any features explicitly specified.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def complex(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.complex(*args, **kwargs)
It accepts the same arguments as python.complex
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.complex(x1, *args, **kwargs)
is equivalent to
builder.complex(*args, **kwargs)(x1)
python.complex
complex(real[, imag]) -> complex number
Create a complex number from a real part and an optional imaginary part. This is equivalent to (real + imag*1j) where imag defaults to 0.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def delattr(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.delattr(*args, **kwargs)
It accepts the same arguments as python.delattr
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.delattr(x1, *args, **kwargs)
is equivalent to
builder.delattr(*args, **kwargs)(x1)
python.delattr
delattr(object, name)
Delete a named attribute on an object; delattr(x, 'y') is equivalent to ``del x.y''.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def dict(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.dict(*args, **kwargs)
It accepts the same arguments as python.dict
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.dict(x1, *args, **kwargs)
is equivalent to
builder.dict(*args, **kwargs)(x1)
python.dict
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def dir(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.dir(*args, **kwargs)
It accepts the same arguments as python.dir
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.dir(x1, *args, **kwargs)
is equivalent to
builder.dir(*args, **kwargs)(x1)
python.dir
dir([object]) -> list of strings
If called without an argument, return the names in the current scope. Else, return an alphabetized list of names comprising (some of) the attributes of the given object, and of attributes reachable from it. If the object supplies a method named dir, it will be used; otherwise the default dir() logic is used and returns: for a module object: the module's attributes. for a class object: its attributes, and recursively the attributes of its bases. for any other object: its attributes, its class's attributes, and recursively the attributes of its class's base classes.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def divmod(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.divmod(*args, **kwargs)
It accepts the same arguments as python.divmod
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.divmod(x1, *args, **kwargs)
is equivalent to
builder.divmod(*args, **kwargs)(x1)
python.divmod
divmod(x, y) -> (quotient, remainder)
Return the tuple (x//y, x%y). Invariant: div*y + mod == x.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def enumerate(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.enumerate(*args, **kwargs)
It accepts the same arguments as python.enumerate
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.enumerate(x1, *args, **kwargs)
is equivalent to
builder.enumerate(*args, **kwargs)(x1)
python.enumerate
enumerate(iterable[, start]) -> iterator for index, value of iterable
Return an enumerate object. iterable must be another object that supports iteration. The enumerate object yields pairs containing a count (from start, which defaults to zero) and a value yielded by the iterable argument. enumerate is useful for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def eval(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.eval(*args, **kwargs)
It accepts the same arguments as python.eval
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.eval(x1, *args, **kwargs)
is equivalent to
builder.eval(*args, **kwargs)(x1)
python.eval
eval(source[, globals[, locals]]) -> value
Evaluate the source in the context of globals and locals. The source may be a string representing a Python expression or a code object as returned by compile(). The globals must be a dictionary and locals can be any mapping, defaulting to the current globals and locals. If only globals is given, locals defaults to it.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def execfile(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.execfile(*args, **kwargs)
It accepts the same arguments as python.execfile
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.execfile(x1, *args, **kwargs)
is equivalent to
builder.execfile(*args, **kwargs)(x1)
python.execfile
execfile(filename[, globals[, locals]])
Read and execute a Python script from a file. The globals and locals are dictionaries, defaulting to the current globals and locals. If only globals is given, locals defaults to it.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def file(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.file(*args, **kwargs)
It accepts the same arguments as python.file
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.file(x1, *args, **kwargs)
is equivalent to
builder.file(*args, **kwargs)(x1)
python.file
file(name[, mode[, buffering]]) -> file object
Open a file. The mode can be 'r', 'w' or 'a' for reading (default), writing or appending. The file will be created if it doesn't exist when opened for writing or appending; it will be truncated when opened for writing. Add a 'b' to the mode for binary files. Add a '+' to the mode to allow simultaneous reading and writing. If the buffering argument is given, 0 means unbuffered, 1 means line buffered, and larger numbers specify the buffer size. The preferred way to open a file is with the builtin open() function. Add a 'U' to mode to open the file for input with universal newline support. Any line ending in the input file will be seen as a '\n' in Python. Also, a file so opened gains the attribute 'newlines'; the value for this attribute is one of None (no newline read yet), '\r', '\n', '\r\n' or a tuple containing all the newline types seen.
'U' cannot be combined with 'w' or '+' mode.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def filter(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.filter(*args, **kwargs)
It accepts the same arguments as python.filter
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.filter(x1, x2, *args, **kwargs)
is equivalent to
builder.filter(x1, *args, **kwargs)(x2)
python.filter
filter(function or None, sequence) -> list, tuple, or string
Return those items of sequence for which function(item) is true. If function is None, return the items that are true. If sequence is a tuple or string, return the same type, else return a list.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def float(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.float(*args, **kwargs)
It accepts the same arguments as python.float
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.float(x1, *args, **kwargs)
is equivalent to
builder.float(*args, **kwargs)(x1)
python.float
float(x) -> floating point number
Convert a string or number to a floating point number, if possible.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def format(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.format(*args, **kwargs)
It accepts the same arguments as python.format
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.format(x1, *args, **kwargs)
is equivalent to
builder.format(*args, **kwargs)(x1)
python.format
format(value[, format_spec]) -> string
Returns value.format(format_spec) format_spec defaults to ""
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def frozenset(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.frozenset(*args, **kwargs)
It accepts the same arguments as python.frozenset
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.frozenset(x1, *args, **kwargs)
is equivalent to
builder.frozenset(*args, **kwargs)(x1)
python.frozenset
frozenset() -> empty frozenset object
frozenset(iterable) -> frozenset object
Build an immutable unordered collection of unique elements.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def getattr(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.getattr(*args, **kwargs)
It accepts the same arguments as python.getattr
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.getattr(x1, *args, **kwargs)
is equivalent to
builder.getattr(*args, **kwargs)(x1)
python.getattr
getattr(object, name[, default]) -> value
Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn't exist; without it, an exception is raised in that case.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def globals(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.globals(*args, **kwargs)
It accepts the same arguments as python.globals
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.globals(x1, *args, **kwargs)
is equivalent to
builder.globals(*args, **kwargs)(x1)
python.globals
globals() -> dictionary
Return the dictionary containing the current scope's global variables.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def hasattr(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.hasattr(*args, **kwargs)
It accepts the same arguments as python.hasattr
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.hasattr(x1, *args, **kwargs)
is equivalent to
builder.hasattr(*args, **kwargs)(x1)
python.hasattr
hasattr(object, name) -> bool
Return whether the object has an attribute with the given name. (This is done by calling getattr(object, name) and catching exceptions.)
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def hash(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.hash(*args, **kwargs)
It accepts the same arguments as python.hash
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.hash(x1, *args, **kwargs)
is equivalent to
builder.hash(*args, **kwargs)(x1)
python.hash
hash(object) -> integer
Return a hash value for the object. Two objects with the same value have the same hash value. The reverse is not necessarily true, but likely.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def hex(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.hex(*args, **kwargs)
It accepts the same arguments as python.hex
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.hex(x1, *args, **kwargs)
is equivalent to
builder.hex(*args, **kwargs)(x1)
python.hex
hex(number) -> string
Return the hexadecimal representation of an integer or long integer.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def id(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.id(*args, **kwargs)
It accepts the same arguments as python.id
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.id(x1, *args, **kwargs)
is equivalent to
builder.id(*args, **kwargs)(x1)
python.id
id(object) -> integer
Return the identity of an object. This is guaranteed to be unique among simultaneously existing objects. (Hint: it's the object's memory address.)
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def input(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.input(*args, **kwargs)
It accepts the same arguments as python.input
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.input(x1, *args, **kwargs)
is equivalent to
builder.input(*args, **kwargs)(x1)
python.input
input([prompt]) -> value
Equivalent to eval(raw_input(prompt)).
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def int(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.int(*args, **kwargs)
It accepts the same arguments as python.int
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.int(x1, *args, **kwargs)
is equivalent to
builder.int(*args, **kwargs)(x1)
python.int
int(x=0) -> int or long
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments are given. If x is floating point, the conversion truncates towards zero. If x is outside the integer range, the function returns a long instead.
If x is not a number or if base is given, then x must be a string or Unicode object representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.
int('0b100', base=0) 4
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def intern(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.intern(*args, **kwargs)
It accepts the same arguments as python.intern
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.intern(x1, *args, **kwargs)
is equivalent to
builder.intern(*args, **kwargs)(x1)
python.intern
intern(string) -> string
``Intern'' the given string. This enters the string in the (global) table of interned strings whose purpose is to speed up dictionary lookups. Return the string itself or the previously interned string object with the same value.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def isinstance(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.isinstance(*args, **kwargs)
It accepts the same arguments as python.isinstance
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.isinstance(x1, *args, **kwargs)
is equivalent to
builder.isinstance(*args, **kwargs)(x1)
python.isinstance
isinstance(object, class-or-type-or-tuple) -> bool
Return whether an object is an instance of a class or of a subclass thereof. With a type as second argument, return whether that is the object's type. The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for isinstance(x, A) or isinstance(x, B) or ... (etc.).
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def issubclass(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.issubclass(*args, **kwargs)
It accepts the same arguments as python.issubclass
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.issubclass(x1, *args, **kwargs)
is equivalent to
builder.issubclass(*args, **kwargs)(x1)
python.issubclass
issubclass(C, B) -> bool
Return whether class C is a subclass (i.e., a derived class) of class B. When using a tuple as the second argument issubclass(X, (A, B, ...)), is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def iter(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.iter(*args, **kwargs)
It accepts the same arguments as python.iter
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.iter(x1, *args, **kwargs)
is equivalent to
builder.iter(*args, **kwargs)(x1)
python.iter
iter(collection) -> iterator
iter(callable, sentinel) -> iterator
Get an iterator from an object. In the first form, the argument must supply its own iterator, or be a sequence. In the second form, the callable is called until it returns the sentinel.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def len(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.len(*args, **kwargs)
It accepts the same arguments as python.len
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.len(x1, *args, **kwargs)
is equivalent to
builder.len(*args, **kwargs)(x1)
python.len
len(object) -> integer
Return the number of items of a sequence or collection.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def list(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.list(*args, **kwargs)
It accepts the same arguments as python.list
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.list(x1, *args, **kwargs)
is equivalent to
builder.list(*args, **kwargs)(x1)
python.list
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def locals(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.locals(*args, **kwargs)
It accepts the same arguments as python.locals
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.locals(x1, *args, **kwargs)
is equivalent to
builder.locals(*args, **kwargs)(x1)
python.locals
locals() -> dictionary
Update and return a dictionary containing the current scope's local variables.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def long(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.long(*args, **kwargs)
It accepts the same arguments as python.long
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.long(x1, *args, **kwargs)
is equivalent to
builder.long(*args, **kwargs)(x1)
python.long
long(x=0) -> long
long(x, base=10) -> long
Convert a number or string to a long integer, or return 0L if no arguments are given. If x is floating point, the conversion truncates towards zero.
If x is not a number or if base is given, then x must be a string or Unicode object representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.
int('0b100', base=0) 4L
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def map(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.map(*args, **kwargs)
It accepts the same arguments as python.map
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.map(x1, x2, *args, **kwargs)
is equivalent to
builder.map(x1, *args, **kwargs)(x2)
python.map
map(function, sequence[, sequence, ...]) -> list
Return a list of the results of applying the function to the items of the argument sequence(s). If more than one sequence is given, the function is called with an argument list consisting of the corresponding item of each sequence, substituting None for missing values when not all sequences have the same length. If the function is None, return a list of the items of the sequence (or a list of tuples if more than one sequence).
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def max(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.max(*args, **kwargs)
It accepts the same arguments as python.max
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.max(x1, *args, **kwargs)
is equivalent to
builder.max(*args, **kwargs)(x1)
python.max
max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value
With a single iterable argument, return its largest item. With two or more arguments, return the largest argument.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def memoryview(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.memoryview(*args, **kwargs)
It accepts the same arguments as python.memoryview
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.memoryview(x1, *args, **kwargs)
is equivalent to
builder.memoryview(*args, **kwargs)(x1)
python.memoryview
memoryview(object)
Create a new memoryview object which references the given object.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def min(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.min(*args, **kwargs)
It accepts the same arguments as python.min
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.min(x1, *args, **kwargs)
is equivalent to
builder.min(*args, **kwargs)(x1)
python.min
min(iterable[, key=func]) -> value
min(a, b, c, ...[, key=func]) -> value
With a single iterable argument, return its smallest item. With two or more arguments, return the smallest argument.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def next(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.next(*args, **kwargs)
It accepts the same arguments as python.next
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.next(x1, *args, **kwargs)
is equivalent to
builder.next(*args, **kwargs)(x1)
python.next
next(iterator[, default])
Return the next item from the iterator. If default is given and the iterator is exhausted, it is returned instead of raising StopIteration.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def object(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.object(*args, **kwargs)
It accepts the same arguments as python.object
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.object(x1, *args, **kwargs)
is equivalent to
builder.object(*args, **kwargs)(x1)
python.object
The most base type
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def oct(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.oct(*args, **kwargs)
It accepts the same arguments as python.oct
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.oct(x1, *args, **kwargs)
is equivalent to
builder.oct(*args, **kwargs)(x1)
python.oct
oct(number) -> string
Return the octal representation of an integer or long integer.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def open(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.open(*args, **kwargs)
It accepts the same arguments as python.open
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.open(x1, *args, **kwargs)
is equivalent to
builder.open(*args, **kwargs)(x1)
python.open
open(name[, mode[, buffering]]) -> file object
Open a file using the file() type, returns a file object. This is the preferred way to open a file. See file.doc for further information.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def ord(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.ord(*args, **kwargs)
It accepts the same arguments as python.ord
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.ord(x1, *args, **kwargs)
is equivalent to
builder.ord(*args, **kwargs)(x1)
python.ord
ord(c) -> integer
Return the integer ordinal of a one-character string.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def pow(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.pow(*args, **kwargs)
It accepts the same arguments as python.pow
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.pow(x1, *args, **kwargs)
is equivalent to
builder.pow(*args, **kwargs)(x1)
python.pow
pow(x, y[, z]) -> number
With two arguments, equivalent to xy. With three arguments, equivalent to (xy) % z, but may be more efficient (e.g. for longs).
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def print(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.print(*args, **kwargs)
It accepts the same arguments as python.print
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.print(x1, *args, **kwargs)
is equivalent to
builder.print(*args, **kwargs)(x1)
python.print
print(value, ..., sep=' ', end='\n', file=sys.stdout)
Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def property(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.property(*args, **kwargs)
It accepts the same arguments as python.property
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.property(x1, *args, **kwargs)
is equivalent to
builder.property(*args, **kwargs)(x1)
python.property
property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise fset is a function for setting, and fdel a function for del'ing, an attribute. Typical use is to define a managed attribute x:
class C(object): def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.")
Decorators make defining new properties or modifying existing ones easy:
class C(object): @property def x(self): "I am the 'x' property." return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def range(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.range(*args, **kwargs)
It accepts the same arguments as python.range
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.range(x1, *args, **kwargs)
is equivalent to
builder.range(*args, **kwargs)(x1)
python.range
range(stop) -> list of integers
range(start, stop[, step]) -> list of integers
Return a list containing an arithmetic progression of integers. range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0. When step is given, it specifies the increment (or decrement). For example, range(4) returns [0, 1, 2, 3]. The end point is omitted! These are exactly the valid indices for a list of 4 elements.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def raw_input(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.raw_input(*args, **kwargs)
It accepts the same arguments as python.raw_input
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.raw_input(x1, *args, **kwargs)
is equivalent to
builder.raw_input(*args, **kwargs)(x1)
python.raw_input
raw_input([prompt]) -> string
Read a string from standard input. The trailing newline is stripped. If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError. On Unix, GNU readline is used if enabled. The prompt string, if given, is printed without a trailing newline before reading.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def reduce(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.reduce(*args, **kwargs)
It accepts the same arguments as python.reduce
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.reduce(x1, x2, *args, **kwargs)
is equivalent to
builder.reduce(x1, *args, **kwargs)(x2)
python.reduce
reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequence to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). If initial is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def reload(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.reload(*args, **kwargs)
It accepts the same arguments as python.reload
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.reload(x1, *args, **kwargs)
is equivalent to
builder.reload(*args, **kwargs)(x1)
python.reload
reload(module) -> module
Reload the module. The module must have been successfully imported before.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def repr(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.repr(*args, **kwargs)
It accepts the same arguments as python.repr
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.repr(x1, *args, **kwargs)
is equivalent to
builder.repr(*args, **kwargs)(x1)
python.repr
repr(object) -> string
Return the canonical string representation of the object. For most object types, eval(repr(object)) == object.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def reversed(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.reversed(*args, **kwargs)
It accepts the same arguments as python.reversed
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.reversed(x1, *args, **kwargs)
is equivalent to
builder.reversed(*args, **kwargs)(x1)
python.reversed
reversed(sequence) -> reverse iterator over values of the sequence
Return a reverse iterator
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def round(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.round(*args, **kwargs)
It accepts the same arguments as python.round
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.round(x1, *args, **kwargs)
is equivalent to
builder.round(*args, **kwargs)(x1)
python.round
round(number[, ndigits]) -> floating point number
Round a number to a given precision in decimal digits (default 0 digits). This always returns a floating point number. Precision may be negative.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def set(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.set(*args, **kwargs)
It accepts the same arguments as python.set
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.set(x1, *args, **kwargs)
is equivalent to
builder.set(*args, **kwargs)(x1)
python.set
set() -> new empty set object
set(iterable) -> new set object
Build an unordered collection of unique elements.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def setattr(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.setattr(*args, **kwargs)
It accepts the same arguments as python.setattr
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.setattr(x1, *args, **kwargs)
is equivalent to
builder.setattr(*args, **kwargs)(x1)
python.setattr
setattr(object, name, value)
Set a named attribute on an object; setattr(x, 'y', v) is equivalent to ``x.y = v''.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def slice(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.slice(*args, **kwargs)
It accepts the same arguments as python.slice
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.slice(x1, *args, **kwargs)
is equivalent to
builder.slice(*args, **kwargs)(x1)
python.slice
slice(stop)
slice(start, stop[, step])
Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def sorted(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.sorted(*args, **kwargs)
It accepts the same arguments as python.sorted
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.sorted(x1, *args, **kwargs)
is equivalent to
builder.sorted(*args, **kwargs)(x1)
python.sorted
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def staticmethod(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.staticmethod(*args, **kwargs)
It accepts the same arguments as python.staticmethod
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.staticmethod(x1, *args, **kwargs)
is equivalent to
builder.staticmethod(*args, **kwargs)(x1)
python.staticmethod
staticmethod(function) -> method
Convert a function to be a static method.
A static method does not receive an implicit first argument. To declare a static method, use this idiom:
class C: def f(arg1, arg2, ...): ... f = staticmethod(f)
It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). The instance is ignored except for its class.
Static methods in Python are similar to those found in Java or C++. For a more advanced concept, see the classmethod builtin.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def str(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.str(*args, **kwargs)
It accepts the same arguments as python.str
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.str(x1, *args, **kwargs)
is equivalent to
builder.str(*args, **kwargs)(x1)
python.str
str(object='') -> string
Return a nice string representation of the object. If the argument is a string, the return value is the same object.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def sum(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.sum(*args, **kwargs)
It accepts the same arguments as python.sum
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.sum(x1, *args, **kwargs)
is equivalent to
builder.sum(*args, **kwargs)(x1)
python.sum
sum(sequence[, start]) -> value
Return the sum of a sequence of numbers (NOT strings) plus the value of parameter 'start' (which defaults to 0). When the sequence is empty, return start.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def super(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.super(*args, **kwargs)
It accepts the same arguments as python.super
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.super(x1, *args, **kwargs)
is equivalent to
builder.super(*args, **kwargs)(x1)
python.super
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type) -> unbound super object super(type, type2) -> bound super object; requires issubclass(type2, type) Typical use to call a cooperative superclass method: class C(B): def meth(self, arg): super(C, self).meth(arg)
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def tuple(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.tuple(*args, **kwargs)
It accepts the same arguments as python.tuple
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.tuple(x1, *args, **kwargs)
is equivalent to
builder.tuple(*args, **kwargs)(x1)
python.tuple
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items
If the argument is a tuple, the return value is the same object.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def type(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.type(*args, **kwargs)
It accepts the same arguments as python.type
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.type(x1, *args, **kwargs)
is equivalent to
builder.type(*args, **kwargs)(x1)
python.type
type(object) -> the object's type
type(name, bases, dict) -> a new type
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def unichr(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.unichr(*args, **kwargs)
It accepts the same arguments as python.unichr
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.unichr(x1, *args, **kwargs)
is equivalent to
builder.unichr(*args, **kwargs)(x1)
python.unichr
unichr(i) -> Unicode character
Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def unicode(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.unicode(*args, **kwargs)
It accepts the same arguments as python.unicode
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.unicode(x1, *args, **kwargs)
is equivalent to
builder.unicode(*args, **kwargs)(x1)
python.unicode
unicode(object='') -> unicode object
unicode(string[, encoding[, errors]]) -> unicode object
Create a new Unicode object from the given encoded string. encoding defaults to the current default string encoding. errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def vars(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.vars(*args, **kwargs)
It accepts the same arguments as python.vars
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.vars(x1, *args, **kwargs)
is equivalent to
builder.vars(*args, **kwargs)(x1)
python.vars
vars([object]) -> dictionary
Without arguments, equivalent to locals(). With an argument, equivalent to object.dict.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def xrange(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.xrange(*args, **kwargs)
It accepts the same arguments as python.xrange
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.xrange(x1, *args, **kwargs)
is equivalent to
builder.xrange(*args, **kwargs)(x1)
python.xrange
xrange(stop) -> xrange object
xrange(start, stop[, step]) -> xrange object
Like range(), but instead of returning a list, returns an object that generates the numbers in the range on demand. For looping, this is slightly faster than range() and more memory efficient.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)
def zip(
self, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
builder.zip(*args, **kwargs)
It accepts the same arguments as python.zip
.
However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that
python.zip(x1, *args, **kwargs)
is equivalent to
builder.zip(*args, **kwargs)(x1)
python.zip
zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
Return a list of tuples, where each tuple contains the i-th element from each of the argument sequences. The returned list is truncated in length to the length of the shortest argument sequence.
@functools.wraps(fn) def method(self, *args, **kwargs): kwargs['_return_type'] = _return_type return self.ThenAt(n, fn, *args, **kwargs)


Multipage Tour Example
Here's how to take your tour across pages.
var tour = {
id: "hello-hopscotch",
steps: [
{
title: "Multipage Example",
content: "We're going to the next page now...",
target: "title",
placement: "bottom",
multipage: true,
onNext: function() {
window.location = "multipage2.html"
}
},
{
title: "My content",
content: "Here is where I put my content.",
target: document.querySelector("#content p"),
placement: "bottom"
}
]
};
So what exactly is going on here? First, you'll notice that we added the multipage
option to the first step in our tour. This tells Hopscotch that the following step (step 2) is going to be on a different page, so that the it doesn't try to advance the tour when the user clicks the Next button.
In the onNext
callback for step 1, we change the window.location
to the URL of the second page. This lets us actually change pages without leaving the context of the Hopscotch tour.


--- layout: post title: Concert Roundup tags: - Music status: publish type: post published: true meta: _edit_last: "1" ---
The greatest shows are often put on by those bands that most of your friends have never heard of playing in small dives. Jason Webley started busking on the streets of Seattle with his distinctive brand of accordion music. He now tours venues around the world on his own and as part of his Monsters of Accordion tour, which showcases a number of other talented accordion musicians. He recently headlined a show with Sxip Shirey of the gypsy-folk-punk band Luminescent Orchestrii at the Bottom of the Hill in San Francisco.
A few weeks later and across town at the Hemlock Tavern, Schaffer the Darklord put on his own show. At the back end of a long, narrow room at the back of an otherwise average bar, a small group of fans gathered to listen to a curious flavor of live nerdcore rap performances. In this intimate setting, the New York-based Schaffer covered a range of topics including clones, social networking and zombies.


Sleek.Js is an MVC Framework implemented on Node.JS, built-in with base dependency on handlebars.js, express.js, mongoose. Sleek.Js architecture follows common format of MVC which makes it easy to handle and build better sites.
Using Sleek.Js we can make powerful websites in Nodejs platform. Sleek.Js gives better performance, flexibility and easy maintenance.
For documentation and other details. GOTO Sleek.JS
Cubet Techno Labs. Pvt. Ltd. owns and maintains Sleek.Js code and posts frequent updates. If you have any queries please feel free to contact us at<EMAIL_ADDRESS>This version of sleek.js support plug & play modules. To see it in action, go to modules directory & uncomment routings inside override.js & routes.js


|
QuantLib: a free/open-source library for quantitative finance
Fully annotated sources - version 1.30
|
Variables | |
| const Real | beta_min = 0.01 |
| const Real | beta_max = 0.99 |
| const Real | expiryTime_max = 30.0 |
| const Real | sigmaI_min = 0.05 |
| const Real | sigmaI_max = 1.00 |
| const Real | nu_min = 0.01 |
| const Real | nu_max = 0.80 |
| const Real | rho_min = -0.99 |
| const Real | rho_max = 0.99 |
| const Real | phiByTau_cutoff = 124.587 |
| const Real | nsim = 2500000.0 |
| const Real | tiny_prob = 1E-5 |
| const Real | strike_min = 1E-6 |
| const Real | i_accuracy = 1E-7 |
| const Size | i_max_iterations = 10000 |
| const Real | forward_accuracy = 1E-6 |
| const Real | forward_search_step = 0.0010 |
| const Real | density_lower_bound = 1E-50 |
| const Real | density_threshold = 1E-100 |
| const Real beta_min = 0.01 |
Definition at line 64 of file noarbsabr.hpp.
| const Real beta_max = 0.99 |
Definition at line 65 of file noarbsabr.hpp.
| const Real expiryTime_max = 30.0 |
Definition at line 66 of file noarbsabr.hpp.
| const Real sigmaI_min = 0.05 |
Definition at line 67 of file noarbsabr.hpp.
| const Real sigmaI_max = 1.00 |
Definition at line 68 of file noarbsabr.hpp.
| const Real nu_min = 0.01 |
Definition at line 69 of file noarbsabr.hpp.
| const Real nu_max = 0.80 |
Definition at line 70 of file noarbsabr.hpp.
| const Real rho_min = -0.99 |
Definition at line 71 of file noarbsabr.hpp.
| const Real rho_max = 0.99 |
Definition at line 72 of file noarbsabr.hpp.
| const Real phiByTau_cutoff = 124.587 |
Definition at line 76 of file noarbsabr.hpp.
| const Real nsim = 2500000.0 |
Definition at line 79 of file noarbsabr.hpp.
| const Real tiny_prob = 1E-5 |
Definition at line 82 of file noarbsabr.hpp.
| const Real strike_min = 1E-6 |
Definition at line 84 of file noarbsabr.hpp.
| const Real i_accuracy = 1E-7 |
Definition at line 87 of file noarbsabr.hpp.
| const Size i_max_iterations = 10000 |
Definition at line 88 of file noarbsabr.hpp.
| const Real forward_accuracy = 1E-6 |
Definition at line 91 of file noarbsabr.hpp.
| const Real forward_search_step = 0.0010 |
Definition at line 94 of file noarbsabr.hpp.
| const Real density_lower_bound = 1E-50 |
Definition at line 96 of file noarbsabr.hpp.
| const Real density_threshold = 1E-100 |
Definition at line 98 of file noarbsabr.hpp.