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)