def CreateElement(self, x, y, x2 = 0, y2 = 0):
ne = Element(x, y, x2, y2)
ne.x = x
ne.y = y
ne.x2 = x2
ne.y2 = y2
return ne
def __init__(self, agent, element_name, trigger, root, max_freq):
"""Initialises the drive element.
The log domain is set to [AgentName].DE.[element_name]
@param agent: The element's agent.
@type agent: L{SPOSH.Agent}
@param element_name: The name of the drive element.
@type element_name: string
@param trigger: The trigger of the element.
@type trigger: L{SPOSH.Trigger}
@param root: The element's root element.
@type root: L{SPOSH.Action}, L{SPOSH.Competence} or
L{SPOSH.ActionPattern}
@param max_freq: The maximum frequency at which is element is
fired. The frequency is given in milliseconds between
invocation. A negative number disables this feature.
@type max_freq: long
"""
Element.__init__(self, agent, "DE.%s" % element_name)
self._name = element_name
self._trigger = trigger
self._root, self._element = root, root
self._max_freq = max_freq
# the timestamp when it was last fired
self._last_fired = -100000l
self.debug("Created")
def test_ud(ilist):
filter = UserDefinedFilter(ilist)
from cStringIO import StringIO
from element import Element
from media import MediaFactory,GenericMedia,List
fd = StringIO('''<TrackerList>
<Tracker publisher="th-torrent">
<Url name="login" url="http://forums.btthai.com/" method="post">
<Param name="UserName" value="%(user)s"/>
<Param name="PassWord" value="%(password)s"/>
<Param name="act" value="Login"/>
<Param name="CODE" value="01"/>
<Param name="CookieDate" value="1"/>
</Url>
<Url name="catalog" url="http://forums.btthai.com/" method="get">
<Param name="act" value="bt"/>
<Param name="func" value="browse"/>
<Filter name="main"><![CDATA[<tr>\s*<td class="[^"]+" align="center"><img src="style_images/[^/]+/cat_(?P<category>[^\.]+).[^<]+" border="0" alt="[^"]+" width="\d+" height="\d+"/></td>\s*<td class="[^"]+" align="left"><a href="(?P<link>[^"]+)">(?P<title>[^<]+)</a></td>\s*<td class="[^"]+" align="right">(?P<files>\d+)</td>\s*<td class="[^"]+" align="center">[^<]+</td>\s*<td class="[^"]+" align="center" nowrap>(?P<date>[^<]+(<br/>| )[^<]*)</td>\s*<td class="[^"]+" align="center">[^<]+</td>\s*<td class="[^"]+" align="center">\d+</td>\s*<td class="[^"]+" align="right">\d+</td>\s*<td class="[^"]+" align="right">\d+</td>\s*<td class="[^"]+" align="center"><a href="[^"]+">(?P<publisher>[^<]+)</a></td>\s*</tr>]]></Filter>
<Filter name="detail"><![CDATA[<tr><td align="left" class='pformleft'>Name</td><td class='pformright'><a href="index.php\?showtopic=\d+">(?P<description>[^<]+)</a></td></tr>\s*<tr><td align="left" class='pformleft'>Info Hash</td><td class='pformright'>[^<]+</td></tr>\s*<tr><td align="left" class='pformleft'>Download</td><td class='pformright'><a href="(?P<download>[^\?]+\?act=bt&func=download&id=\d+)">[^<]+</a></td></tr>]]></Filter>
</Url>
<Url name="logout" url="http://th-torrent.mine.nu/"/>
</Tracker>
</TrackerList>''' % {'user': user,
'password': passwd})
element = Element()
element.load(fd)
factory = MediaFactory(GenericMedia,List)
tlist = factory.from_element(element)
fd.close()
loader = TrackerLoader(tlist[0],filter)
loader.fetch().to_element().save(sys.stdout)
def Initialize(credentials=None, opt_url=None):
"""Initialize the EE library.
If this hasn't been called by the time any object constructor is used,
it will be called then. If this is called a second time with a different
URL, this doesn't do an un-initialization of e.g.: the previously loaded
Algorithms, but will overwrite them and let point at alternate servers.
Args:
credentials: OAuth2 credentials.
opt_url: The base url for the EarthEngine REST API to connect to.
"""
data.initialize(credentials, (opt_url + '/api' if opt_url else None), opt_url)
# Initialize the dynamically loaded functions on the objects that want them.
ApiFunction.initialize()
Element.initialize()
Image.initialize()
Feature.initialize()
Collection.initialize()
ImageCollection.initialize()
FeatureCollection.initialize()
Filter.initialize()
Geometry.initialize()
List.initialize()
Number.initialize()
String.initialize()
Date.initialize()
Dictionary.initialize()
_InitializeGeneratedClasses()
_InitializeUnboundMethods()
def __init__(self, agent, element_name, trigger, element, max_retries):
"""Initialises the competence element.
The log domain is set to [AgentName].CE.[element_name].
@param agent: The competence element's agent.
@type agent: L{SPOSH.Agent}
@param element_name: The name of the competence element.
@type element_name: string
@param trigger: The element's trigger
@type trigger: L{SPOSH.Trigger}
@param element: The element to fire.
@type element: L{SPOSH.Action}, L{SPOSH.Competence}, or
L{SPOSH.ActionPattern}
@param max_retries: The maximum number of retires. If this is set
to a negative number, it is ignored.
@type max_retries: int
"""
Element.__init__(self, agent, "CE.%s" % element_name)
self._name = element_name
self._trigger = trigger
self._element = element
self._max_retries = max_retries
self._retries = 0
self.debug("Created")
def __init__(self,
mark_x,
mark_y,
pcb_name):
Element.__init__(self,mark_x = mark_x,mark_y = mark_y,
pcb_name = pcb_name)
num_dots = 7
dot_pitch_x = 10.16 * MM
cathode_offset_x = 7 * MM
cathode_offset_y = 3.2 * MM
class Dot:
def __init__(self,x,y,i):
d = {'thickness':1.3 * MM,
'clearance':0.1 * MM,
'mask':0.1 * MM,
'drillhole':1 * MM} # FIXME: check this!
self.anode = Pin(x = x,y = y,
number = i * 2 + 1,
**d)
self.cathode = Pin(x = x + cathode_offset_x,
y = y + cathode_offset_y,
number = i * 2 + 2,
**d)
self.dot = []
x = 0
for i in range(0,7):
self.dot.append(Dot(x,0,i))
x += dot_pitch_x
self.pins.append(self.dot[i].anode)
self.pins.append(self.dot[i].cathode)
def __init__(self, model, xc=0, yc=0, label=None):
Element.__init__(self, model, Nparam=1, Nunknowns=1, layers=range(model.aq.Naq),\
name='ConstantInside', label=label)
self.xc = np.atleast_1d(xc)
self.yc = np.atleast_1d(yc)
self.parameters = np.zeros((1,1))
self.model.add_element(self)
class Hyperlink :
_hyperlink = ''
_rel_id = ''
_url = ''
def __init__(self, text, rel_id, url, anchor=None) :
self._rel_id = rel_id
self._url = url
if anchor is None :
self._hyperlink = Element().createElement('hyperlink', attr={'rel_id' : 'rId' + rel_id})
else :
self._hyperlink = Element().createElement('hyperlink', attr={'anchor' : anchor})
run = Element().createElement('r')
rPr = Element().createElement('rPr')
style = Element().createElement('rStyle', attr={'val' : 'Hyperlink'})
rPr.append(style)
run.append(rPr)
textEl = Element().createElement('t', text=text, attr={'space' : 'preserve'})
run.append(textEl)
self._hyperlink.append(run)
def get(self) :
return self._hyperlink
def getRelation(self) :
attr = {'TargetMode' : 'External', 'Type' : HYPERLINK_SCHEMA, 'Id' : 'rId' + self._rel_id, 'Target' : self._url}
rel = Element().createElement('Relationship', prefix=None, attr=attr)
return rel
def Initialize(credentials="persistent", opt_url=None):
"""Initialize the EE library.
If this hasn't been called by the time any object constructor is used,
it will be called then. If this is called a second time with a different
URL, this doesn't do an un-initialization of e.g.: the previously loaded
Algorithms, but will overwrite them and let point at alternate servers.
Args:
credentials: OAuth2 credentials. 'persistent' (default) means use
credentials already stored in the filesystem, or raise an explanatory
exception guiding the user to create those credentials.
opt_url: The base url for the EarthEngine REST API to connect to.
"""
if credentials == "persistent":
credentials = _GetPersistentCredentials()
data.initialize(credentials, (opt_url + "/api" if opt_url else None), opt_url)
# Initialize the dynamically loaded functions on the objects that want them.
ApiFunction.initialize()
Element.initialize()
Image.initialize()
Feature.initialize()
Collection.initialize()
ImageCollection.initialize()
FeatureCollection.initialize()
Filter.initialize()
Geometry.initialize()
List.initialize()
Number.initialize()
String.initialize()
Date.initialize()
Dictionary.initialize()
Terrain.initialize()
_InitializeGeneratedClasses()
_InitializeUnboundMethods()
def __init__(self, model, xc=0, yc=0, R=1, N=0.001, layer=0, name="CircAreasink", label=None):
Element.__init__(self, model, Nparam=1, Nunknowns=0, layers=layer, name=name, label=label)
self.xc = float(xc)
self.yc = float(yc)
self.R = float(R)
self.N = float(N)
self.model.add_element(self)
def __init__(self, model, slope, angle,\
name='Uflow', label=None):
assert model.aq.ilap, 'TimML Error: Uflow can only be added to model with background confined aquifer'
self.storeinput(inspect.currentframe())
Element.__init__(self, model, Nparam=2, Nunknowns=0, layers=0,\
name=name, label=label)
self.slope = slope
self.angle = angle
self.model.add_element(self)
def insertComponentDescription(self, div):
# Description
if self.description:
description = Element('div', {
'id':self.id+'-description',
'class':self.descriptionClass
})
description.update(self.description)
div.insert(description)
return div
def insertComponentTip(self, div):
# Create the tip div if not empty
if self.tip:
tipDiv = Element('div', {
'id':self.id+'-tip',
'style':'display: none',
'class':self.tipClass,
})
tipDiv.update(self.tip)
div.insert(tipDiv)
return div
def __init__(self, content=None, parent=None):
Element.__init__(self, content, parent)
if isinstance(content, str):
self._transform = Transform()
self._computed_transform = self._transform
else:
self._transform = Transform(content.get("transform",None))
self._computed_transform = self._transform
if parent:
self._computed_transform = self._transform + self.parent.transform
def test_insert_component_tip(self):
from element import Element
c = jformer._Component()
setattr(c, 'id', 'magic')
div = Element('div', {})
div = c.insertComponentTip(div)
self.assertEqual(div.__str__(), '<div></div>')
c.tip = 'Put on your best smile'
div = c.insertComponentTip(div)
self.assertEqual(div.__str__(),
'<div><div style="display: none" id="magic-tip" class="jFormComponentTip">Put on your best smile</div></div>')
def __init__(self, model, xw=0, yw=0, Qw=100.0, rw=0.1, \
res=0.0, layers=0, name='WellBase', label=None):
Element.__init__(self, model, Nparam=1, Nunknowns=0, layers=layers,\
name=name, label=label)
self.Nparam = len(self.pylayers) # Defined here and not in Element as other elements can have multiple parameters per layers
self.xw = float(xw)
self.yw = float(yw)
self.Qw = np.atleast_1d(Qw)
self.rw = float(rw)
self.res = float(res)
self.model.add_element(self)
def test_insert_component_description(self):
from element import Element
c = jformer._Component()
setattr(c, 'id', 'magic')
div = Element('div', {})
div = c.insertComponentDescription(div)
self.assertEqual(div.__str__(), '<div></div>')
c.description = 'My description'
div = c.insertComponentDescription(div)
self.assertEqual(div.__str__(),
'<div><div id="magic-description" class="jFormComponentDescription">My description</div></div>')
def from_file(self,file):
close_flag = 0
if type(file) == type(''):
fd = open(file,'r')
close_flag = 1
else:
fd = file
e = Element()
e.load(fd)
if close_flag:
fd.close()
return self.from_element(e)
def __init__(self, model, xr=0, yr=0, hr=0.0, layer=0,\
name='ConstantBase', label=None, aq=None):
self.storeinput(inspect.currentframe())
Element.__init__(self, model, Nparam=1, Nunknowns=1, layers=layer,\
name=name, label=label)
self.Nparam = 1 # Defined here and not in Element as other elements can have multiple parameters per layers
self.Nunknowns = 0
self.xr = xr
self.yr = yr
self.hr = hr
self.aq = aq
self.model.add_element(self)
def __init__(self, model, xy, closed=False, layers=0, order=0, name='LineSinkStringBase', label=None, aq=None):
Element.__init__(self, model, Nparam=1, Nunknowns=0, layers=layers, \
name=name, label=label)
self.xy = np.atleast_2d(xy).astype('d')
if closed: self.xy = np.vstack((self.xy, self.xy[0]))
self.order = order
self.aq = aq
self.lslist = []
self.x, self.y = self.xy[:,0], self.xy[:,1]
self.Nls = len(self.x) - 1
for i in range(self.Nls):
self.lslist.append(LineSinkHoBase(model, \
x1=self.x[i], y1=self.y[i], x2=self.x[i+1], y2=self.y[i+1], \
Qls=0.0, layers=layers, order=order, label=label, addtomodel=False, aq=aq))
def __init__(self, model, x1=-1, y1=0, x2=1, y2=0, Qls=100.0, \
res=0, wh=1, layers=0, name='LineSinkBase', label=None, \
addtomodel=True):
Element.__init__(self, model, Nparam=1, Nunknowns=0, layers=layers, \
name=name, label=label)
self.Nparam = len(self.pylayers)
self.x1 = float(x1)
self.y1 = float(y1)
self.x2 = float(x2)
self.y2 = float(y2)
self.Qls = np.atleast_1d(Qls)
self.res = float(res)
self.wh = wh
self.addtomodel = addtomodel
if self.addtomodel: self.model.add_element(self)
def __init__(self, model, x1=-1, y1=0, x2=1, y2=0, \
Qls=0.0, layers=0, order=0, name='LineSinkHoBase', \
label=None, addtomodel=True, aq=None, zcinout=None):
Element.__init__(self, model, Nparam=1, Nunknowns=0, layers=layers, \
name=name, label=label)
self.x1 = float(x1)
self.y1 = float(y1)
self.x2 = float(x2)
self.y2 = float(y2)
self.Qls = np.atleast_1d(Qls)
self.order = order
self.Nparam = self.Nlayers * (self.order + 1)
self.addtomodel = addtomodel
if addtomodel: self.model.add_element(self)
self.aq = aq
self.zcinout = zcinout
def __init__(self):
"""Constructor de la clase.
Inicializa las propiedades privadas:
-parser: la cual contiene el parser expat
-buscando: propiedad que se utiliza en caso de que no se quiera leer
todo el archivo xml y solo se necesita buscar un elemento en particular
-nombre_buscar: se utiliza para almacenar el nombre del elemento a buscar
en caso que no se quiera leer todo el archivo XML sino buscar un elemento
en particular.
-encontrado: se utiliza como bandera para indicar si ya fue o no encontrado
un elemento en particular.
-elemento: propiedad en la cual se almacena una instancia de la clase element.
-vec_elementos: vector en el cual se almacenan los elementos que contiene el archivo XML.
-attrs: dicccionario en el cual se almacenan los atributos del elemento actual que se
esta leyendo.
"""
self.__parser = expat.ParserCreate()
self.__parser.StartElementHandler = self.__start_element
self.__parser.EndElementHandler = self.__end_element
self.__parser.CharacterDataHandler = self.__char_data
self.__buscando = False
self.__nombre_buscar = ""
self.__encontrado = False
self.__elemento = Element()
self.__vec_elementos = []
self.__attrs = {}
def __start_element_childs(self, name, attrs):
""" Metodo que se utiliza cuando se desea encontrar todos los hijos de un
elemento en particular.
Basicamente su funcionamiento consiste en buscar el elemento padre, una
vez encontrado almacena todos sus elementos hijos en la propiedad vec_elementos.
Paramentros:
-name: nombre del elemento padre.
-attrs: atributos del elemento padre (se utiliza solo a modo de compatibilidad con el parser expat)
"""
if name == self.__nombre_buscar:
self.__encontre_padre = True
elif self.__encontre_padre:
elem = Element()
elem.set_name(name)
elem.set_attributes(attrs)
self.__vec_elementos.append(elem)
def Reset(): """Reset the library. Useful for re-initializing to a different server.""" data.reset() ApiFunction.reset() Element.reset() Image.reset() Feature.reset() Collection.reset() ImageCollection.reset() FeatureCollection.reset() Filter.reset() Geometry.reset() Number.reset() String.reset() _ResetGeneratedClasses() global Algorithms Algorithms = _AlgorithmsContainer()
def __init__(self, driver):
Page.__init__(self, driver)
self.altom_logo = Element(self.driver, (By.XPATH, ".//*[@id='site-title']/a/img"))
self.sidebar = Element(self.driver, (By.CLASS_NAME, "sidebar"))
self.main_content = Element(self.driver, (By.ID, "mainContent"))
self.main_menu = Element(self.driver, (By.ID, "mainMenu"))
self.video = Element(self.driver, (By.ID, "presentation"))
self.phone_number = Element(self.driver, (By.CLASS_NAME, "mainPhone"))
self.blocks = Element(self.driver, (By.CLASS_NAME, "blocks"))
def __init__(self, text, rel_id, url, anchor=None) :
self._rel_id = rel_id
self._url = url
if anchor is None :
self._hyperlink = Element().createElement('hyperlink', attr={'rel_id' : 'rId' + rel_id})
else :
self._hyperlink = Element().createElement('hyperlink', attr={'anchor' : anchor})
run = Element().createElement('r')
rPr = Element().createElement('rPr')
style = Element().createElement('rStyle', attr={'val' : 'Hyperlink'})
rPr.append(style)
run.append(rPr)
textEl = Element().createElement('t', text=text, attr={'space' : 'preserve'})
run.append(textEl)
self._hyperlink.append(run)
def generateComponentDiv(self, includeLabel=True):
# Div tag contains everything about the component
componentDiv = Element('div', {
'id': self.id+'-wrapper',
'class': 'jFormComponent '+self._class})
# This causes issues with things that are dependent and should display by default
# If the component has dependencies and the display type is hidden, hide by default
# if(self.dependencyOptions !== None && isset(self.dependencyOptions['display']) && self.dependencyOptions['display'] == 'hide'):
# componentDiv.setAttribute('style', 'display: none')
#
# Style
if self.style:
componentDiv.addToAttribute('style', self.style)
# Label tag
if includeLabel:
label = self.generateComponentLabel()
componentDiv.insert(label)
return componentDiv
def CreateElement(self, x, y, x2, y2):
ne = Element(x, y, x2, y2)
ne.pattern = self
ne.x = x
ne.y = y
ne.x2 = x2
ne.y2 = y2
self.special = 'wire'
ne.name = 'wire'
d = self.GetDrawlist(self.cur_options)
return ne
def generateComponentLabel(self):
if self.label == None:
return ''
label = Element('label', {
'id':self.id+'-label',
'for':self.id,
'class':self.labelClass
})
label.update(self.label)
# Add the required star to the label
if 'required' in self.validationOptions:
labelRequiredStarSpan = Element('span',
{'class':self.labelRequiredStarClass})
labelRequiredStarSpan.update(self.requiredText)
label.insert(labelRequiredStarSpan)
return label
def InitialCreator(**args):
return Element(qname=(TEXTNS, 'initial-creator'), **args)
def IllustrationIndexSource(**args):
return Element(qname=(TEXTNS, 'illustration-index-source'), **args)
def AlphabeticalIndex(**args):
return Element(qname=(TEXTNS, 'alphabetical-index'), **args)
def IndexEntryBibliography(**args):
return Element(qname=(TEXTNS, 'index-entry-bibliography'), **args)
def IndexBody(**args):
return Element(qname=(TEXTNS, 'index-body'), **args)
def IndexEntryLinkStart(**args):
return Element(qname=(TEXTNS, 'index-entry-link-start'), **args)
def IndexTitleTemplate(**args):
return Element(qname=(TEXTNS, 'index-title-template'), **args)
def ListLevelStyleImage(**args):
return Element(qname=(TEXTNS, 'list-level-style-image'), **args)
def ListLevelStyleNumber(**args):
return Element(qname=(TEXTNS, 'list-level-style-number'), **args)
def ListItem(**args):
return Element(qname=(TEXTNS, 'list-item'), **args)
def ListLevelStyleBullet(**args):
return Element(qname=(TEXTNS, 'list-level-style-bullet'), **args)
def ListHeader(**args):
return Element(qname=(TEXTNS, 'list-header'), **args)
def List(**args):
return Element(qname=(TEXTNS, 'list'), **args)
def LinenumberingSeparator(**args):
return Element(qname=(TEXTNS, 'linenumbering-separator'), **args)
def IndexEntryPageNumber(**args):
return Element(qname=(TEXTNS, 'index-entry-page-number'), **args)
def Measure(**args):
return Element(qname=(TEXTNS, 'measure'), **args)
def A(**args):
args.setdefault('type', 'simple')
return Element(qname=(TEXTNS, 'a'), **args)
def LineBreak(**args):
return Element(qname=(TEXTNS, 'line-break'), **args)
def IndexEntryLinkEnd(**args):
return Element(qname=(TEXTNS, 'index-entry-link-end'), **args)
def IndexSourceStyles(**args):
return Element(qname=(TEXTNS, 'index-source-styles'), **args)
def IndexEntryChapter(**args):
return Element(qname=(TEXTNS, 'index-entry-chapter'), **args)
def IndexEntrySpan(**args):
return Element(qname=(TEXTNS, 'index-entry-span'), **args)
def IndexTitle(**args):
return Element(qname=(TEXTNS, 'index-title'), **args)
def Keywords(**args):
return Element(qname=(TEXTNS, 'keywords'), **args)
def ImageCount(**args):
return Element(qname=(TEXTNS, 'image-count'), **args)
def Insertion(**args):
return Element(qname=(TEXTNS, 'insertion'), **args)
def Meta(**args):
return Element(qname=(TEXTNS, 'meta'), **args)
def IndexEntryTabStop(**args):
return Element(qname=(TEXTNS, 'index-entry-tab-stop'), **args)
def LinenumberingConfiguration(**args):
return Element(qname=(TEXTNS, 'linenumbering-configuration'), **args)
def IndexEntryText(**args):
return Element(qname=(TEXTNS, 'index-entry-text'), **args)
