---------------------------------------------------------------------- Copyright (c) 2014, SRI International Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ----------------------------------------------------------------------
PythonCyc is a Python interface package to Pathway Tools, version 18.5 or above. PythonCyc has been tested with Python 2.6 and IPython on Mac OS X, Linux and Microsoft Windows. Since PythonCyc is based on the programming language Python, you must use a Python interpreter to use PythonCyc. In the following we assume that you have installed Python (we recommend version 2.6 or above, but it most likely work with any 2.x version). For the latest news about PythonCyc, please consult the PythonCyc web page.
We assume that you have downloaded PythonCyc from PythonCyc at GitHub. This may be done by using git cloning or by downloading the zip file of PythonCyc from GitHub. If downloading the zip file, you will need to unpack it using the unzip command in some directory of your choice.
The next step is to make PythonCyc accessible from your running Python interpreter. To do so, install PythonCyc according to one of the following platforms.
Open a terminal window and change your directory to the location where you unpacked or cloned the PythonCyc package. You must have the file setup.py, and the subdirectory pythoncyc, in that directory. Assuming that 'shell>' is the prompt of your current Unix shell, execute the following command:
shell> sudo python setup.py install
This may prompt you for your login password because sudo requires authorization to modify some system directories. This command copies several files from the pythoncyc subdirectory to other locations on your computer where Python is installed, byte-compiles these files and may do other operations depending on the Python installation you have. No error messages should be reported. In case of errors, make sure you have installed Python and that it is working.
To test your PythonCyc installation, please consult the Section Getting Started in this document.
On a Microsoft Windows platform, starts a command prompt window using the start/Accessories menu, then change the directory to the location where you unpacked or cloned the PythonCyc package. You must have the file setup.py, and the subdirectory pythoncyc, in that directory . Then, at the command prompt, execute the following command:
python setup.py install
This command copies several files from the pythoncyc subdirectory to other locations on your computer where Python is installed, byte-compiles these files and may do other operations depending on the Python installation you have. No error messages should be reported. In case of errors, make sure you have installed Python and that it is working. To test your PythonCyc installation, please consult the Section Getting Started in this document.
Pathway Tools (version 18.5 and up) must be running on some computer started with at least the command line option '-python' or '-python-local-only', which starts the Python server in Pathway Tools. If '-python' is specified, connections made to Pathway Tools could come from a remote computer, whereas for '-python-local-only', no remote computer can connect to the Python server. The option '-python-local-only' is for added cybersecurity because with that option no remote computer can access your locally running Pathway Tools via the Python server. PythonCyc communicates to this running Pathway Tools server via a socket on port 5008 (default setup). It is also recommended to start Pathway Tools with the command line option '-lisp', so that the connection can be monitored and debugged, if need be. In summary, we recommend to start Pathway Tools using the following options
./pathway-tools -lisp -pythonor for added cybersecurity with the options
./pathway-tools -lisp -python-local-only
To run PythonCyc remotely from Pathway Tools, please read the Section Remotely Accessing Pathway Tools to setup PythonCyc to remotely access Pathway Tools. In the following, we assume that Pathway Tools is running on the same computer as Python and that it has the MetaCyc database.
Start a Python interpreter on the same computer as Pathway Tools. You should get a prompt such as >>>, then enter the following
>>> import pythoncyc
This command imports the PythonCyc module to access its classes, functions and methods. If any error messages is given when this command make sure PythonCyc has been installed according to the Installation instructions. Then enter the command
>>> meta = pythoncyc.select_organism('meta')
This command sends a request to Pathway Tools to create a PGDB object associated with the database MetaCyc, which is specified using the 'meta' organism identifier (i.e., orgid). That PGDB object is assigned to the variable meta. (If you get an error message, it could be that Pathway Tools was not started as given above.)
Print out the Python meta variable
>>> print meta <PGDB meta, currently has 0 PFrames>
This means that meta is bound to a PGDB object, its orgid is meta and it has currently no PFrames attached to it. Indeed, currently we only created a PGDB object that has no data frames in it. The following sections will show how to retrieve data frames from Pathway Tools to PythonCyc via this variable meta.
If you want to have a list of all PGDBs, and their orgids, accessible from your running Pathway Tools, evaluate pythoncyc.all_orgids().
Please, consult the source file __init__.py for other fundamental methods available from the pythoncyc module.
Also, more advanced technical documentation is provided for each method and functions by consulting the PythonCyc modules config.py, PGDB.py, PToolsFrame.py and PTools.py. As usual, the Python help command can provide documentation about the modules, classes and methods: for example, help(pythoncyc) prints the documentation for the module pythoncyc; or the command help(meta), once variable meta is bound to a PGDB object, prints all the methods available, and their documentation, for a PGDB object.
Using that variable meta, it is now possible to request data from the MetaCyc database. For example, the following statement retrieves compound TRP (i.e., L-tryptophan). 'TRP' is the frame id of compound L-tryptophan, which we can also specify in lower case letters:
>>> meta.trp
Evaluating meta.trp, if done for the first time, triggers a call to Pathway Tools to retrieve the frame data (or simply frame) of compound TRP: the slots (also called attributes) and their data of the Pathway Tools frame representing compound TRP are sent to PythonCyc to create a PFrame object to represent the compound TRP. PythonCyc also prints that frame content which is represented as a Python dictionary: the slots of the frame are the keys of the dictionary and the value of the slots are the values of the dictionary.
Note: in Pathway Tools, the slots are used to access the data of a frame (i.e., object). In Python, an object has attributes. The meaning of these two terms, that is, slots and attributes, are very similar. A slot of a frame in Pathway Tools becomes an attribute of a PFrame object in PythonCyc. We will use the term slots when referring to a frame in Pathway Tools and attributes when referring to the same slots in PythonCyc.
Printing out meta now shows that we have one PFrame attached to meta:
>>> print meta <PGDB meta, currently has 1 PFrames>
Indeed, this PFrame for TRP was also bound to the PGDB meta such that it became an attribute of meta. That is, executing meta.trp again would not retrieve the data from Pathway Tools, but directly use the PFrame already created for it and now stored as an attribute for meta. All created PFrames based on a PGDB object are attached to that object and no two PFrames can have the same frame id for that PGDB object.
In Pathway Tools, the frame id is in upper case, that is, 'TRP'. The conversion from lower case to upper case is handled automatically by PythonCyc. PFrame, in PythonCyc, is the class of objects to represent frame objects from Pathway Tools. More details about PFrames is given below and in the Section PFrame Objects. In particular, note that PFrames are read only, that is, their attributes cannot be modified.
From a PGDB object, a PFrame can be accessed using the frame id either by using the attribute or indexing syntax of Python. For example, the following would retrieve reaction with frame id RXN-9000
>>> rxn9000 = meta['RXN-9000']
or by using the attribute syntax
>>> rxn9000 = meta.rxn_9000
Both forms access the same attribute. Note that the frame id 'RXN-9000' has a dash in its name but an attribute in Python cannot have a dash. To provide access to such frame ids, using the attribute syntax of Python, dashes are converted to underscores. Mixed cases (i.e., upper or lower case letters) can be used for both syntax (attributes and indexing) because an automatic conversion is done by PythonCyc. There are cases where only the second form, the indexing syntax, can be used. For example, for a slot name starting with a digit, or a character that is not a letter or an underscore, the indexing syntax with a string must be used. This is due to the syntax of attribute names in Python which can only have letters, digits and underscores, and cannot start with a digit. For example, the slot name 'N+1-NAME' can only be accessed using the index syntax because it has the character '+' which cannot be used in a Python identifier.
In PythonCyc, frame ids are stored as strings prefixed and suffixed by '|'. In general, these vertical bars identify symbols in PythonCyc which exists as Lisp symbols in Pathway Tools. When symbols are return from Pathway Tools, the vertical bars are inserted. For example, we can see the frame id of meta.trp by printing it:
>>> print meta.trp.frameid |TRP|
The syntax '|...|' is used to indicate that this string represents a symbol and can be interpreted by Pathway Tools as a frame id. In Lisp, the programming language used to implement Pathway Tools, the double vertical bars signifies that this is a symbol that must be read exactly as given without any transformation (e.g., no case conversion on letters).
Advanced technical note: all PFrames created using a PGDB object are included in a Python dictionary bound to an attribute, of that PGDB object, called 'frames'. The keys of that dictionary are the frame ids of the PFrames converted to valid Python identifiers. The __getattr__ and __getitem__ methods of the PGDB class were written in such a way that such an expression as 'meta.trp' searches in the dictionary for a PFrame with frame id 'TRP'.
Once you have access to a frame, the frame ids stored in that frame can be used to create more PFrames. For example, the trp object has an attribute called appears_in_right_side_of which has a list of reaction frame ids as a value. The reaction frame ids refer to all reactions that has TRP on its right-hand side. The reactions can be retrieved in the following way:
>>> rxns_trp_right = [meta[fid] for fid in meta.trp.appears_in_right_side_of]
The variable rxns_trp_right is bound to a list of PFrames representing the reactions. Each PFrame becomes also attributes to meta based on the frame ids.
The basic mechanism of attribute access and indexing on a PGDB object just shown is enough to retrieve all frames from a PGDB assuming that frame ids are known and PFrames are implicitly (i.e., automatically) created. The next section shows how to retrieve large number of frames based on classes of objects, which indirectly provides the frame ids of large number of frames.
Another implicit operations done by PythonCyc is the retrieval of classes of objects from Pathway Tools. There are many classes of objects, such as Reactions, Proteins, Compounds, Genes, Pathways, and more. For example, retrieving the class of all reactions of PGDB meta, from Pathway Tools, can be done by
>>> reactions = meta.reactions
which assign to variable reactions a PFrame representing the class of reactions from PGDB meta. Printing out this variable gives
>>> reactions <PFrame class |Reactions| currently with 13081 instances (meta)>
As can be seen, reactions is a PFrame and it is a class which has the name |Reactions| in Pathway Tools and it has 13,081 instances, that is, 13,081 reactions, all from the PGDB meta (i.e., MetaCyc). The number of instances may differ for you because MetaCyc is periodically modified. Remember that the vertical bars in a name means that it is a symbol, and here it is more specifically a frame id.
This PFrame reactions has an attribute instances assigned with the list of all reactions of the MetaCyc PGDB. Each such reaction is also a PFrame, although these PFrames have currently no other data than the frame id of each reaction. It is a lazy transfer of the frames where only the frame ids were requested from Pathway Tools. This approach is useful because in some cases not all data from all reactions are needed. We can access each reaction via the attribute instances, for example
>>> reactions.instances[0]but we can also use indexing directly on the class reactions such as
>>> reactions[0] {'_gotframe': False, '_isclass': False, 'pgdb': meta, 'frameid': u'|<IP_ADDRESS>-RXN|'}but the frameid value is likely different (MetaCyc is periodically modified). As mentioned, each object in a PGDB has a unique identifier called the frame id, which in PythonCyc is stored in the field frameid of a PFrame. When the reactions were retrieved from Pathway Tools, the frame id values also became attributes of the Python PGDB object meta, that is, we can also indexed object meta with the frame ids. For example,
>>> meta['|<IP_ADDRESS>-RXN|'] {'_gotframe': False, '_isclass': False, 'pgdb': meta, 'frameid': u'|<IP_ADDRESS>-RXN|'}
This Python dictionary is a very short representation of the frame with almost no data. The attributes shown are only created by PythonCyc to maintain that frame in Python. If you access one slot of that reaction frame, which is not listed in that output, the value of that slot is retrieved from Pathway Tools. For example,
>>> reactions[0].left [u'|Double-Stranded-DNAs|', u'|WATER|']
retrieves the data for slot left and that value is kept in the PFrame. Therefore, accessing several times the same slot of a frame, only triggers one communication to Pathway Tools because after it was accessed once, it is no longer accessed again from Pathway tools. (Note: the methods get_slot_values and get_slot_value presented later in this document always trigger a transfer from Pathway Tools.) We can verify that the the PFrame has the left attribute in the PFrame itself:
>>> reactions[0] {u'left': [u'|Double-Stranded-DNAs|', u'|WATER|'], '_gotframe': False, '_isclass': False, 'pgdb': meta, 'frameid': u'|<IP_ADDRESS>-RXN|'}
Another very different approach to retrieve all the data of a list of frames is by using the Python method get_frame_objects defined for a PGDB object. That method takes a list of frame ids as input and send a request to Pathway Tools to transfer all the slots and their data for all the frames identified by these frame ids. The function creates a PFrame, for each frames retrieved, for the PGDB, if none exist.
For example, assuming that we have the variable reactions bound to the class of reactions as in the previous section, to retrieve all the frame data for the first 10 reactions, the following can be used: (We retrieve only the first 10 reactions to reduce execution time)
>>> r = meta.get_frame_objects([f.frameid for f in reactions.instances[0:10]])
The list comprehension gathers the frame ids in one list and a call to the get_frame_objects method is done, using the PGDB object meta, to retrieve from Pathay Tools all the slots and their data for all the frame ids. This approach always transfer the frames from Pathway Tools even if we already transferred them already. This can be needed if the frames were modified and there is a need to transfer them again.
Another very different way to access the frame data is to use methods get_slot_value and get_slot_values. These methods are among the more than 150 methods of the PGDB class which is the subject of the next section. The first method retrieves a scalar value on a slot that can only have one value whereas the second method retrieves a list of values from a slot that can have multiple values. In both cases, only the data from one slot is retrieved, not the whole frame. That is, there are no creation of PFrames when using these functions.
For example, the following retrieve the Gibbs free energy of reaction RXN-9000 from MetaCyc
>>> meta.get_slot_value('RXN-9000', 'GIBBS-0') 7.5217285
We did not specify the vertical bars for the frame id 'RXN-9000' and the name of the slot 'GIBBS-0' although both are symbols in Pathway Tools. The translation to symbols is handled automatically by the function get_slot_value, and many other functions that require symbols as arguments.
The following retrieves the chemical formula of compound TRP
>>> meta.get_slot_values('TRP', 'CHEMICAL-FORMULA') {u'|N|': [2], u'|C|': [11], u'|H|': [12], u'|O|': [2]}
The method get_slot_values is needed (instead of get_slot_value, the singular version) because the slot 'CHEMICAL-FORMULA' keeps the chemical formula as a list of pairs (atom-species coefficient) where atom-species is the species of the atom (e.g., 'C' for carbon) and coefficient is an integer. In that particular case, that is, a list of pairs, the result will be returned as a Python dictionary where the keys are the atom species and the values are the coefficients. In the next section there is more explanation on data conversion between Lisp and Python.
Using a variable bound to a PGDB object, which is the case for variable meta from the previous sections, any of the more than 150 methods from the PGDB class can be called, each corresponding to a specific function in Pathway Tools. The list of these methods (or functions), and their documentation, can be obtained by consulting the source code of file PGDB.py or by using the standard help mechanism of Python (or IPython). For example,
>>> help(pythoncyc.PGDB)will list the source documentation of the class PGDB with the list of all methods. For a particular function, you can request its documentation by naming the function. For example,
>>> help(pythoncyc.PGDB.get_slot_value)
Almost all these methods do not create PFrame objects but returns basic Python object, that is, boolean, numbers, strings, lists, dictionaries, and so on. When a Pathway Tools object (e.g., gene, pathway, reaction) needs to be returned, the frame id (as a string) is returned. For example, the following call retrieves all the pathways from meta by returning a list of frame ids (as strings):
>>> pwys = meta.all_pathways()
As presented in the previous section, to create PFrames, and the data about pathways, using frame ids, you can use the method get_frame_objects.
Many other Lisp functions, defined in Pathway Tools, can be called using Python's syntax. These functions often need a frame as one of the parameter. A frame can be specified as a frame id (a string) or as a PFrame object. For example,
>>> meta.reactions_of_compound('TRP')
where 'TRP' is the frame id of compound L-tryptophan. The reactions_of_compound method (which is a function in Pathway Tools) retrieves all reaction frame ids that use TRP as a substrate. Note that, if the given frame id was not existing in the PGDB, it would raise a PToolsError in PythonCyc because Pathway Tools itself will report a 'non coercible frame'.
A PFrame can also be used instead of the frame id. For example, meta.trp refers to a PFrame for compound TRP and can be used to do the same operation we just did, that is,
>>> meta.reactions_of_compound(meta.trp)
Some methods modify the PGDB in Pathway Tools, such as
>>> meta.put_slot_value('RXN-9000','GIBBS-0',2.7)
which modifies the slot 'GIBBS-0' for frame 'RXN-9000' to the value 2.7 for the PGDB associated with object meta, which in our case is MetaCyc.
Some functions have keywords arguments, which are always optional. But notice that the default value is often the Python value None. The value None is not translated to False, but indicates to use the default value of the Lisp function called. These defaults are given in the documentation of each PythonCyc method.
The transfer of all data from Pathway Tools to PythonCyc is done using the JSON (JavaScript Object Notation) syntax. On the other hand, PythonCyc does not use JSON for the transfer of data from Python to Pathway Tools because Pathway Tools uses Lisp and it is simpler to use a Lisp syntax for that transfer. Some conversion rules are applied on data types when transferring data to and from Pathway Tools and we discuss these in the following. Note that all the special rules of conversion from Lisp to Python is based on what the JSON Lisp package does whereas the special rules of conversion from Python to Lisp is what the method convertArgToLisp, of class PGDB, does.
During conversion, the numbers are kept relatively unchanged: integers and floating-point numbers are translated using the same types but floating-point numbers are not guaranteed to have the same precision. In Lisp and Python, infinite precision of integers are implemented. The rational numbers of Lisp are translated to floating-point numbers in Python.
The Python value True is translated into t in Lisp whereas False and None are translated into nil in Lisp. The value t in Lisp is translated into True in Python. On the other hand, the value nil in Lisp is translated into False, None or the empty list [] in Python depending on the context. It is translated to False when a PythonCyc method is called that expects a boolean value as a result: for example, the PythonCyc method pathway_hole_p does return False when the result of the corresponding function in Lisp is nil. It is translated to the empty list [] when a PythonCyc method is called that expects a list as a result: for example, the PythonCyc method get_slot_values does return [] when the slot value is nil. Finally, the nil values is translated to None when the result is not known to be a boolean or a list value: for example, the PythonCyc method get_slot_value would return None if the slot value is nil.
Any Lisp string is translated into a Python string. A Python string that starts and ends with a '|', and contains no space, is assumed to represent a symbol and is translated successfully into one if indeed the Python string follows the correct syntax of a Lisp symbol. For example, the Python string "|RXN-9000|" is translated into the Lisp symbol RXN-9000.
Lisp lists are translated to Python lists, but with one important exception: a Lisp list where all elements are non empty sublists, and every first element of each sublist is a symbol or string, are translated into a Python dictionary. For example, the slot chemical-formula has such lists: the chemical formula H2O is represented as the list of sublists ((H 2) (O 1)), where H and O are symbols, in that slot. Each sublist is translated, in JSON, to a key/value pair in a dictionary, where the key is the first element of the sublist and the value is the rest of the list. Therefore, the Lisp value ((H 2) (O 1)) is translated into the Python dictionary {'|H|' : [2], '|O|' : [1]}. Notice that H and O are translated into Python strings with the vertical bars to indicate that they are symbols and the coefficients 2 and 1 are translated into lists of one element because the rest of each sublist is a list.
A dictionary in Python is translated into a list of dotted pairs or list of lists when transferred to Pathway Tools. For example, {'|H|' : [2], '|O|' : [1]} is translated into ((H 2) (O 1)), which is the desired Lisp representation in Pathway Tools for the a chemical-formula slot value. On the other hand the Python dictionary {'|H|' : 2, '|O|' : 1} would be translated into ((H . 2) (O . 1)), that is, a list of dotted pairs, which is not the desired Lisp representation for that slot but could be used correctly in some other context although Pathway Tools rarely use dotted pairs.
A vector from Pathway Tools is translated into a Python Lisp. Note: there is no basic vector type in Python.
Finally, a Python tuple is translated into an improper Lisp list. For example, the Python tuple (1, 2, 3) is translated into the improper Lisp list (1 2 . 3). The last element of the list is preceded by a dot, which makes it an improper list. Note that the particular case of a tuple with only one element is translated into an improper list of nil followed by the element. For example, the Python tuple (2,) is translated into (nil . 2). Improper lists are uncommon in Pathway Tools such that you may never need to worry about them.
If you modify the slots of data frames in Pathway Tools, via the PythonCyc interface, care must be taken to store the appropriate data structures and use the appropriate corresponding Python data structures. As we just saw, this should not be a problem for numbers, strings, booleans and list of these basic types as the translation is one to one. For example, the value of the slot synonyms of compound frames is a list of strings, the synonyms of the compounds:
>>> meta.get_slot_values('atp', 'synonyms') [u'adenylpyrophosphate', u'adenosine-triphosphate', u"adenosine-5'-triphosphate"]
You could modify that list, say to only include the first two synonyms, in the following way:
>>> meta.put_slot_values('atp', 'synonyms', [u'adenylpyrophosphate', u'adenosine-triphosphate'])
Note: Typically, modifying a slot should be done on your own created PGDB, not on MetaCyc. In any case, you will not be able to save MetaCyc and any slots modified in MetaCyc will be restored to its original value after you restart the Pathway Tools application.
As for a slot such as chemical-formula, you can represent the value to store in the slot as a list of sublists, such as:
>>> meta.put_slot_values('water', 'chemical-formula', [['|H|',2],['|O|',1]]) {u'|H|': [2], u'|O|': [1]}
The returned value is a dictionary that contains frames ids (i.e., the vertical bars surrounding H and O indicate that they are symbols). Or you can use a dictionary as in
>>> meta.put_slot_values('water', 'chemical-formula', {u'|H|': [2], u'|O|': [1]})
In all cases, care must be taken to have the right representation when modifying a frame slot of a PGDB in Pathway Tools because, at the moment of modifiying the slot, there is no verification of the validity of the data being stored.
When a slot is supposed to contain frames, storing the frame ids in the slot automatically convert these frame ids into frame references. For example, the slot structure-atoms is a list of atom species frames. To modify it would simply require to list the atom species frame ids. For example, for compound water:
>>> meta.put_slot_values('water', 'structure-atoms', ['|O|', '|H|', '|H|'])
Notice that we passed the frame ids O and H using the vertical bars. This is needed because otherwise these would be taken as strings not symbols that refer to frame object in Pathway Tools.
As already mentioned, there are many more methods that can be called to access functions in Pathway Tools and some of them can run complex analysis. For example, there is a method to run flux balance analysis (FBA) called run_fba. Please, consult the file PGDB.py for the complete list of available methods and their documentation.
PFrame is a Python class to represent Pathway Tools' frames in PythonCyc. A PFrame can represent a Pathway Tools class frame (e.g., Reactions) as well as an instance frame (e.g., RXN-9000). PFrames are useful to retrieve many frames and all their data from Pathway to PythonCyc and then operate on that data locally in Python. On the other hand, if the data needs to be modified in the PGDB of Pathway Tools, PFrames are not useful because they are read only.
As discussed in the previous sections, PFrames are automatically created when retrieving classes, or instances using the attribute or indexing syntax applied to a PGDB object. You could also directly create PFrames. To do so, you need to import the class PFrame:
>>> from pythoncyc.PToolsFrame import PFrame
The required parameters to create a PFrame are the frame id (a string) and a PGDB object. For example, assuming that variable meta is bound to a PGDB object, the following create a PFrame to represent the reaction RXN-9000,
>>> PFrame('RXN-9000', meta) {'_gotframe': False, '_isclass': False, 'pgdb':, 'frameid': '|RXN-9000|'}
By default, an instance PFrame (not a class PFrame) is created and the data of the frame is not requested from the server, that is, a PFrame object is created containing only the frame id, the PGDB and a fews other attributes to maintain the PFrame. This is what the print out of that frame shows above. That PFrame is also attached, as an attribute, to the PGDB meta. That can be seen by evaluating
>>> meta._frames.keys() ['rxn_9000']
By specifying the keyword argument getFrameData=True, all slots and data of the frame are retrieved from Pathway Tools. For example, the following create a PFrame for reaction RXN-9000 and retrieve all its slots and data,
>>> PFrame('RXN-9000', meta, getFrameData=True) {u'enzymatic_reaction': [u'|ENZRXN-14558|'], u'right': [u'|PROTON|', u'|CPD-9460|', u'|UDP|'], u'schema_p': True, '_isclass': False, u'creator': u'|Kate|', u'ec_number': [u'|EC-<IP_ADDRESS>|'], u'creation_date':<PHONE_NUMBER>, u'reaction_direction': u'|LEFT-TO-RIGHT|', 'frameid': '|RXN-9000|', u'in_pathway': [u'|PWY-5756|'], u'left': [u'|CPD-9459|', u'|UDP-GLUCURONATE|'], u'citations': [u'WOJCIECHOWSKI75'], u'key_slots': u'|COMMON-NAME|', u'physiologically_relevant_p': [True], u'synonym_slots': [u'|ABBREV-NAME|', u'|SYNONYMS|'], u'atom_mappings': {u'|NO-HYDROGEN-ENCODING|': [[38, 37, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 6, 7, 9, 10, 12, 13, 60, 61, 62, 63, 64, 65, 66, 19, 20, 22, 24, 23, 68, 69, 67, 32, 0, 1, 2, 3, 4, 5, 8, 11, 14, 15, 16, 17, 18, 21, 25, 29, 33, 28, 26, 27, 30, 31, 34, 36, 35], [{u'|CPD-9459|': [37, 69], u'|UDP-GLUCURONATE|': [0, 36]}, {u'|CPD-9460|': [0, 44], u'|UDP|': [45, 69]}]]}, '_gotframe': True, u'gibbs_0': 2.7000000000000002, u'substrates': [u'|UDP-GLUCURONATE|', u'|CPD-9459|', u'|PROTON|', u'|CPD-9460|', u'|UDP|'], 'pgdb':}
For creating a class, the isClass keyword parameter must say so,
>>> PFrame('Reactions', meta, isClass=True)
When creating a class, if getFrameData=True is specified, the class slots and its data are fetched and all the instances of the class are also created as, mostly empty, PFrames. They are mostly empty in the sense that the slots and data of the instances are not transferred, but only the frame id of each frame initialized each PFrame.
The attribute values of the PFrames cannot be modified, that is, attributes are read only. If you try to modify a PFrame attribute, a PythonCycError is raised. On the other hand, slots of Pathway Tools' objects can be modified using methods put_slot_value and put_slot_values. In that case, the PGDB itself in Pathway Tools is modified. See class PGDB for these methods.
It is possible to use PythonCyc to access a Pathway Tools application running on a remote computer. First, Pathway Tools must be started with the command line option '-python' (not '-python-local-only'). That is,
./pathway-tools -pythonor with also the option -lisp to get a Lisp console to monitor the Python server
./pathway-tools -lisp -python
Note: If you were using the option '-python-local-only' instead of '-python' the Python server would not accept connection from remote computers increasing cybersecurity.
Second, you need to use the config module of PythonCyc to set the appropriate host name of that remote computer. For example, assuming that the remote computer is at address 'ptools.mydomain.com' (this is a fictive address for this example). The following would configure PythonCyc to communicate with it:
>>> import pythoncyc.config as config >>> config.set_host_name('ptools.mydomain.com')
If for some reason the Pathway Tools Python server is not using the default port (i.e., 5008), but some other port such as 5000, it can also be configured on the PythonCyc side by using method set_host_port
>>> config.set_host_port(5000)
The preceding Python configuration can be done at any time and it affects all future operations of PythonCyc. It could be done several times to access different Pathway Tools running on different ports or host names.
This example is a function that gathers the Gibbs free energy of the compounds involved in each reaction of a PGDB with a given orgid. The result is a Python dictionary with keys as the frame ids of the reactions and the values as lists of the substrates' Gibbs free energy of each reaction.
This function does not create any PFrame but uses the basic get_slot_value and get_slot_values to retrieve data from Pathway Tools. The function all_rxns retrieves the frame ids of all reactions from the PGDB, then the substrates slot is accessed to get the compound frame ids involved in each reaction. Finally, for each compound frame id, the slot 'GIBBS-0' is accessed to create pairs of compound frame id and Gibbs free energies values transformed into a dictionary using the Python dict function.
def gather_gibbs_substrates_of_reactions(orgid): """ Return a dictionary of all reactions of PGDB orgid with the Gibbs free energies of formation of their substrates. The keys are the frame ids of the reactions and the values are dictionaries of compound frame ids to Gibbs free energies of formation. """ pgdb = pythoncyc.select_organism(orgid) rxn_frameids = pgdb.all_rxns(type='all') gibbs_dict = {} for rxn_fid in rxn_frameids: cpds_fids = pgdb.get_slot_values(rxn_fid,'SUBSTRATES') gibbs_dict[rxn_fid] = dict([(cpd_fid, pgdb.get_slot_value(cpd_fid, 'GIBBS-0')) for cpd_fid in cpds_fids]) return gibbs_dict
This function could be called in the following way assuming that the PGDB with orgid 'ecoli' is available from the Python server of Pathway Tools.
>>> gibbs_dict = gather_gibbs_substrates_of_reactions('ecoli')
This function may take more than 30 seconds to execute because it is retrieving a large amount of data from Pathway Tools.
The following is a simple function to create a PGDB object based on the organism name (i.e., orgid) and retrieve all its basic PFrames for compounds and reactions. Note that these PFrames has no other data than their frame ids.
def create_pgdb_with_compounds_and_reactions(orgid): """ Create a PythonCyc PGDB object with all its compounds and reactions PFrames created. Return the PGDB object. """ pgdb = pythoncyc.select_organism(orgid) pgdb.compounds pgdb.reactions return pgdb
Assuming that the PGDB ecoli is available on your running Pathway Tools server, the following call would bound variable pgdb to a PGDB object containing the PFrames for the compounds and reactions of ecoli:
pgdb = create_pgdb_with_compounds_and_reactions('ecoli')
For comments, questions and bug reports about PythonCyc, send an email to ptools-support@ai.sri.com


A back to the basics CSS starter kit. For when you don’t need the whole boot.
Shoelace.css is a starter kit, not a framework. Think of it as a CSS reset sprinkled with helpful components. Bootstrap users will find it familiar, yet refreshing.
Shoelace is highly customizable through CSS variables. It doesn’t require Less, Sass, or any preprocessing at all. The minified version is only 32KB and much smaller when gzipped.
Just link to shoelace.css
and add customizations to your stylesheet.
<link rel="stylesheet" href="shoelace.css">
Shoelace was created by @claviska for Surreal CMS. It’s available under the MIT license.
Fork Download Report a Bug Star Follow Donate
Version 1.0.0-beta5
# Documentation
- Installing
- Customizing
- Content
- Alerts
- Badges
- Buttons
- Forms
- Loaders
- Switches
- Tabs
- Tables
- Utilities
- Grid System
- Icons
- Browser Support
- Attribution
# Installing
Shoelace is incredibly easy to use. To get started, simply link to shoelace.css
in your project. You can use the CDN version or download the source manually.
CDN
The easiest way to use Shoelace is via CDN. This service is generously provided by the folks at KeyCDN.
<link rel="stylesheet" href="https://cdn.shoelace.style/1.0.0-beta5/shoelace.css">
Download
Alternatively, you can download
the source and link to shoelace.css
from your own server.
<link rel="stylesheet" href="dist/shoelace.css">
NPM
If you’re using NPM, you can install Shoelace by running:
npm install --save-dev shoelace-css
# Customizing
You can customize Shoelace without editing core files or using a preprocessor. To add
customizations, simply override one or more of the variables found in
variables.css
in your own stylesheet.
For example, you can customize the default text color and background like this:
:root { --body-color: white; --body-bg-color: black; }
Using Variables
You can use any of Shoelace’s variables in your stylesheet. This makes it easy to reuse values without hardcoding them. It also provides a foundation for extending Shoelace with your own custom components.
.your-selector { color: var(--state-danger); }
Refer to variables.css
for a complete
list of variables in Shoelace. If you’re not familiar with CSS variables,
this article
will bring you up to speed. There’s also an
interactive demo if you want
to try it out.
Custom Components
You can create custom components to extend Shoelace’s functionality. Here are some best practices to keep things consistent and easy for others to understand.
Familiarize yourself with Shoelace’s naming conventions. A custom accordion
component, for example, would have a class name such as accordion
, modifier
classes such as accordion-open
, and variable names that look like
--accordion-bg-color
. Try to follow similar patterns as much as possible.
Define new variables when it makes sense to. Take a look at
variables.css
to see how existing
components are defined. Many use core variables instead of hardcoded properties as default
values. This makes it easy for users to customize things quickly, but still provides enough
flexibility to style individual components.
Semantic markup is strongly encouraged. Custom components should use the most appropriate elements and the minimal amount of markup required.
Keep everything together. During development, each component should be in its own folder along with its stylesheets, scripts, and documentation. Components shouldn’t depend on other components’ styles or scripts. This makes it easier to add or remove components from your app without affecting others. Of course, it’s perfectly fine to bundle components for optimization purposes in production.
# Content
Shoelace gives you an easy way to customize most HTML elements with variables. You don’t need to apply any classes to achieve these styles — just use the appropriate tags.
For easy spacing, Shoelace removes top margins and applies a bottom margin to block elements.
By default, text sizing and spacing is measured in rem
units.
Headings
 –

Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
Paragraphs

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Quaerat excepturi repellendus nostrum dolorum dignissimos quis non, minus debitis laborum vero cupiditate sequi neque, magnam dolore nemo possimus, soluta ducimus eaque.
Blanditiis ea qui, veritatis animi recusandae praesentium magnam. Commodi placeat, laboriosam accusamus laudantium quasi eveniet soluta illo ducimus quis doloremque mollitia, officia pariatur deleniti reprehenderit, maxime, dicta libero vero cum.
Ordered Lists

- List item 1
- List item 2
- Nested item 1
- Nested item 2
- Nested item 3
- List item 3
Unordered Lists

- List item 1
- List item 2
- Nested item 1
- Nested item 2
- Nested item 3
- List item 3
Definition Lists

- Term 1
- Lorem ipsum dolor sit amet, consectetur adipisicing elit. Earum autem perferendis exercitationem asperiores fuga incidunt, nam dicta amet. Dolor eligendi nisi praesentium placeat officiis esse corporis molestiae. Doloremque accusamus, vel!
- Term 2
- Veritatis repellendus porro ipsam beatae temporibus natus id adipisci nobis accusantium quidem eum fugit cupiditate deleniti nisi nesciunt dicta officia, enim, atque corporis neque error. Unde saepe molestiae hic voluptatibus?
Blockquotes

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia ipsam enim reprehenderit placeat ab voluptate totam suscipit voluptas, culpa pariatur eos quas, sequi unde perferendis officiis! Officiis eligendi eaque facilis.
Preformatted Text

CLS SCREEN 13 PRINT "SHOELACE IS AWESOME"
Text Formats
| Element | Example |
|---|---|
 |
This is strong text |
 |
This is emphasized text |
 |
This is underlined text |
<s> |
|
 |
This is link text |
 |
This is small text |
 |
This is superscript text |
 |
This is subscript text |
 |
This is code text |
<samp> |
This is sample text |
<var> |
This is variable text |
 |
This is keyboard text |
 |
This is abbreviation text |
 |
|
 |
This is inserted text |
 |
This is marked text |
# Alerts
Create an alert by applying the alert
class to an element such as a

. You can change an alert’s appearance using the
alert-*
modifier.

Default

Success

Info
Warning

Danger

Inverse

# Badges
Create a badge by applying the badge
class to an element such as a

. You can change a badge’s appearance using the badge-*
modifier.
Default Success Info Warning Danger Inverse
Default Success Info Warning Danger Inverse
Badges are sized relative to their parent element.

Heading 1 Badge

Heading 2 Badge

Heading 3 Badge

Paragraph Badge

Heading 1 Badge
Heading 2 Badge
Heading 3 Badge
Paragraph Badge
# Buttons
To create a button, use the <button>
element or apply the
button
class to another element such as an
. You can change
a button’s appearance using the button-*
modifier.
<button type="button">Default</button> <button type="button" class="button-success">Success</button> <button type="button" class="button-info">Info</button> <button type="button" class="button-warning">Warning</button> <button type="button" class="button-danger">Danger</button> <button type="button" class="button-inverse">Inverse</button> <button type="button" class="button button-link">Link</button>
Use the button-small
and button-big
modifiers to change the size of
a button.
Use the button-block
modifier to make the button span the entire width of its
parent element. You can also mix and match modifiers as needed.
Disabled buttons look like this. Set the disabled
property on
<button>
elements to achieve this effect. For all other elements, apply
class="disabled"
instead.
You can force buttons to have an active state by applying the active
class.
File Buttons
File inputs are notoriously hard to style properly in every browser. Shoelace offers file buttons as an alternative. These are much easier to style consistently, but come with the caveat that the name (or number) of files selected will not be automatically shown to the user. This aspect of a file button’s UX can be handled effectively with JavaScript, but this is left as an exercise for the user.
File buttons are simply
elements with the button
class
and a nested file input.
 Select File <input type="file">
# Forms
Shoelace gives you beautiful forms without hassle. Most form controls don’t need a special class for styling.
Form Controls
Form controls are styled at 100% of the width of their parent element.
| Input Type | Example |
|---|---|
<input type="checkbox"> |
|
<input type="color"> |
|
<input type="date"> |
|
<input type="email"> |
|
<input type="file">
File inputs aren’t supported. Use a file button instead. |
|
<input type="number"> |
|
<input type="password"> |
|
<input type="radio"> |
|
<input type="range"> |
|
<input type="search"> |
|
<input type="text"> |
|
<input type="time"> |
|
<progress></progress> |
|
<select> |
|
<textarea> |
You can change the size of most form controls with the input-small
and
input-big
modifiers.
<input type="text" class="input-small" placeholder="Small"> <input type="text" placeholder="Default"> <input type="text" class="input-big" placeholder="Big"> <select class="input-small"><option>Item</option></select> <select><option>Item</option></select> <select class="input-big"><option>Item</option></select>
Disabled form controls look like this:
Read-only form controls look like this:
Form Control Spacing
For proper spacing of individual form controls, wrap them in input-single
containers.

 Name <input type="text">

 Password <input type="password">

 <input type="checkbox"> Remember me

Input Groups
Form controls and buttons can be grouped by wrapping them in input-group
containers.

 <input type="text"> <button type="button" class="button">Submit</button>

 <button type="button" class="button">Submit</button> <input type="text">

 <input type="text" placeholder="First"> <input type="text" placeholder="Middle"> <input type="text" placeholder="Last"> <button type="button" class="button">Submit</button>

 <button type="button" class="button">Option 1</button> <button type="button" class="button">Option 2</button> <button type="button" class="button">Option 3</button>

Input Addons
To create an input addon, use
. Addons
can appear anywhere inside an input group. Use the input-addon-*
modifier to
change the size to match adjacent form controls.

 $ <input type="text" class="input-small"> .00

 $ <input type="text"> .00

 $ <input type="text" class="input-big"> .00

Form Groups
Related form controls can be grouped in a <fieldset>
. An optional
<legend>
can be used to display a name for the group.
<fieldset> <legend>User</legend> ... </fieldset>
Validation
Form controls can be made valid or invalid using the input-valid
and
input-invalid
modifiers. It’s better to apply modifiers to the surrounding
input-single
so labels will be styled as well, but modifiers can be applied
directly to form controls as needed.

 Valid <input type="text">

 Invalid <input type="text">

# Loaders
Create a pure CSS loader by applying the loader
class to an empty

element. You can use the loader-small
and
loader-big
modifiers to change the size.

You can simulate a background loader using loader-bg
. This is achieved using
position: relative
on the container and the ::after
pseudo-element.
You can use the loader-bg-small
and loader-bg-big
modifiers to
change the size.

# Switches
Switches provide an alternative to standard checkboxes. Many people find them more intuitive and easier to use, especially on mobile devices. Shoelace provides a way to create beautiful, animated switches with pure CSS.
Because this is a pure CSS solution, there are a couple important things to remember:
-
Each switch must have a unique
id
-
The

must have afor
attribute that references the switchid
-
The

must come after the checkbox, otherwise the control won’t render
The markup for a switch looks like this:
 <input type="checkbox" class="switch" id="switch-1"> Option 1   <input type="checkbox" class="switch" id="switch-2" checked> Option 2
Use the switch-small
and switch-big
modifiers to change the size of
a switch.
Disabled switches are dimmed out. To disable a switch, add the disabled
attribute
to the checkbox (not the wrapper).
# Tabs
Tab sets can be created using the markup below. By default, Shoelace renders tabs as pills because they look better than traditional tabs when rendered on smaller screens.
Note the class names used for the main container, the tab navs, and the tab panes. Also note
that each tab links to its respective tab pane’s id
.
To disable a tab, add disabled
to the appropriate tab nav.

  Tab 1 Tab 2 Tab 3 Disabled
 ...

 ...

 ...

Tab 1
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Qui repellat ea magni magnam assumenda voluptas accusantium nemo. Iusto beatae illum mollitia aut quasi odit facilis officiis, laudantium debitis! Excepturi, quis!
Tab 2
Atque eius voluptatibus ipsa ex totam odit, quidem illo distinctio sit! Quod quae minus, aut itaque. Mollitia, dolore! Facere molestiae necessitatibus sint recusandae incidunt pariatur labore iste vel, velit odit.
Tab 3
Aperiam asperiores optio iusto qui nisi, perspiciatis, ipsum, tenetur explicabo earum et laboriosam odit magni maxime quos molestias aspernatur laudantium harum placeat tempora quae necessitatibus, aut dignissimos totam non! Quod.
Tabs are not interactive by default! Shoelace is a CSS starter kit, not a framework. For convenience, a lightweight sample script is provided to demonstrate how to make tabs interactive.

Vertical Tabs
Tabs can be made vertical by adding custom CSS rules. Shoelace doesn’t include these styles by default because of the many ways tabs can be positioned, customized, and made responsive.
Here’s an example of vertical tabs that uses the CSS grid. The markup is exactly the same as the previous example, except the tabs container has a custom class and the following custom styles.
.tabs-vertical-example { display: grid; grid-template-columns: 30% 70%; } .tabs-vertical-example .tabs-nav { padding-right: 2rem; } .tabs-vertical-example .tabs-nav a { display: block; }
Tab 1
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Qui repellat ea magni magnam assumenda voluptas accusantium nemo. Iusto beatae illum mollitia aut quasi odit facilis officiis, laudantium debitis! Excepturi, quis!
Tab 2
Atque eius voluptatibus ipsa ex totam odit, quidem illo distinctio sit! Quod quae minus, aut itaque. Mollitia, dolore! Facere molestiae necessitatibus sint recusandae incidunt pariatur labore iste vel, velit odit.
Tab 3
Aperiam asperiores optio iusto qui nisi, perspiciatis, ipsum, tenetur explicabo earum et laboriosam odit magni maxime quos molestias aspernatur laudantium harum placeat tempora quae necessitatibus, aut dignissimos totam non! Quod.
# Tables
Tables are styled for you automatically.

Item	Price

Shoe Freshener	$4.79

Shoe Glue	$2.50

Shoe Polish	$5.25

Shoelaces	$3.99

| Item | Price |
|---|---|
| Shoe Freshener | $4.79 |
| Shoe Glue | $2.50 |
| Shoe Polish | $5.25 |
| Shoelaces | $3.99 |
Striped Tables
Use the table-striped
modifier to add stripes to alternating rows.

 ...

| Item | Price |
|---|---|
| Shoe Freshener | $4.79 |
| Shoe Glue | $2.50 |
| Shoe Polish | $5.25 |
| Shoelaces | $3.99 |
Bordered Tables
Use the table-bordered
modifier to add a border to the table.

 ...

| Item | Price |
|---|---|
| Shoe Freshener | $4.79 |
| Shoe Glue | $2.50 |
| Shoe Polish | $5.25 |
| Shoelaces | $3.99 |
# Utilities
Shoelace provides a number of helpful utility classes that make prototyping easier.
Text Utilities
| Class | Example |
|---|---|
text-success |
This is success text |
text-info |
This is info text |
text-warning |
This is warning text |
text-danger |
This is danger text |
text-muted |
This is muted text |
text-small |
This is small text |
text-bold |
This is bold text |
text-italic |
This is italic text |
text-left |
This is left-aligned text |
text-center |
This is centered text |
text-right |
This is right-aligned text |
text-justify |
This is justified text |
text-nowrap |
This is text that won’t wrap |
text-lowercase |
This is lowercase text |
text-uppercase |
This is uppercase text |
text-capitalize |
This is capitalized text |
Float Utilities
Float utilities are provided to easily float elements to the left or right. Just apply the
float-left
or float-right
class to an element to float it
left or right.
A clearfix utility is also available to clear floated elements. Just apply the
clearfix
class to the appropriate element.
Sizing Utilities
Sizing utilities can be used to set a relative width or height on any element. Just apply
a width-*
or height-*
class and the appropriate element will be
sized accordingly. Sizes are available as percentages from 0 – 100 in multiples of five.

25%

50%

75%

100%

25%

50%

75%

100%

Spacing Utilities
Spacing utilities can be used to add or remove paddings and margins to any element. Just apply the desired class and the appropriate element will receive the respective padding/margin.
Class names are prefixed with m-
or p-
for margin and padding,
respectively. To apply a padding/margin to all sides of an element, use the following
classes:
p-[none|small|medium|big] m-[none|small|medium|big] Example: class="p-none m-big"
To apply a padding/margin to a specific side of an element, use one or more of the following classes:
p-[top|right|bottom|left|x|y]-[none|small|medium|big] m-[top|right|bottom|left|x|y]-[none|small|medium|big] Example: class="p-left-medium m-bottom-none"
You can also use m-x-auto
to horizontally center a fixed width block.
# Grid System
Shoelace doesn’t ship with a grid system because you don’t need one. You should use the CSS Grid Layout instead.
If you have an obligation to support older browsers, consider using the Bootstrap grid without any extras.
# Icons
Shoelace doesn’t bundle its own icons, but you can easily include your favorite library such as Font Awesome. They work superbly together.
This decision was intentional. It keeps Shoelace light and makes it more customizable.
# Browser Support
TL;DR — you can use Shoelace as-is if you don’t care about Internet Explorer and older browsers (Edge is fine). If you need to support older browsers, just make sure to use a grid system and Myth as a polyfill.
Browser support for CSS variables is pretty good, but if you need to support Internet Explorer, consider using Myth as a polyfill. Myth lets you write standards-compliant CSS and “fixes” it for unsupportive browsers.
Browser support for the CSS Grid is very good, but if you need to support older browsers you can use a grid system instead.
Browser support for calc
is
excellent. Shoelace uses this internally for
relative calculations. You can use it along with CSS variables too.
Browser support for color modifiers is non-existent. There is a draft, so hopefully that will change soon. Shoelace doesn’t use this feature, but it will when support improves.
Browser support for custom media queries is non-existent. There is a draft, so hopefully that will change soon. Shoelace doesn’t use this feature, but it will when support improves.
# Attribution
Special thanks to the following individuals and organizations for their contributions to Shoelace.css. Listed in no particular order.
- Cory LaViska – for creating this project
- Adam K Olson – for designing an awesome logo
- Bootstrap – for inspiration
- KeyCDN – for providing a CDN
- GitHub – for hosting this and many other open source repos
- Surreal CMS – for sponsoring this project


Time: 0
High Scores
Welcome to the Javascript Coding Challenge Quiz
Answer the following questions and try to get a high score.
Begin


| Code | Company | Price | Change | Change % |
|---|
| AAPL | Apple | $1.38 | +2.01 | -0.36% |
| TWLO | Twilio | $2.38 | -0.01 | -1.36% |
| FB | $3.22 | +0.01 | +1.36% | |
| NFLX | Netflix | $1.02 | -1.01 | +2.36% |
| PYPL | Paypal | $1.38 | +2.01 | -0.36% |
| STX | Seagate | $2.38 | -0.01 | -1.36% |
| AAX | ADELAIDE | $3.22 | +0.01 | +1.36% |
| XXD | ADITYA BIRLA | $1.02 | -1.01 | +2.36% |
| AAC | AUSTRALIAN COMPANY | $1.38 | +2.01 | -0.36% |
| AAD | AUSENCO | $2.38 | -0.01 | -1.36% |
| AAX | ADELAIDE | $3.22 | +0.01 | +1.36% |
| XXD | ADITYA BIRLA | $1.02 | -1.01 | +2.36% |
| AAC | AUSTRALIAN COMPANY | $1.38 | +2.01 | -0.36% |
| AAD | AUSENCO | $2.38 | -0.01 | -1.36% |
| AAX | ADELAIDE | $3.22 | +0.01 | +1.36% |
| XXD | ADITYA BIRLA | $1.02 | -1.01 | +2.36% |
| AAC | AUSTRALIAN COMPANY | $1.38 | +2.01 | -0.36% |
| AAD | AUSENCO | $2.38 | -0.01 | -1.36% |
| AAX | ADELAIDE | $3.22 | +0.01 | +1.36% |
| XXD | ADITYA BIRLA | $1.02 | -1.01 | +2.36% |
| AAC | AUSTRALIAN COMPANY | $1.38 | +2.01 | -0.36% |
| AAD | AUSENCO | $2.38 | -0.01 | -1.36% |
| AAX | ADELAIDE | $3.22 | +0.01 | +1.36% |
| XXD | ADITYA BIRLA | $1.02 | -1.01 | +2.36% |


Admin Dashboard
Items Purchased by Quantity
Item Name
Quantity Sold
{% for i in items %}
{{i.item_name}}
{{i.amount_purchased}}
{% endfor %}
Orders
Order ID
Ordered By
Date
Items
Total
{% for o in orders %}
{{o.orderid}}
{{o.username}}
{{o.order_date}}
{{o.items}}
{{o.cost}}
{% endfor %}


Kylie Jenner sells majority stake in her cosmetics business
Kylie Jenner has sold a majority stake in her cosmetics business for 600 million US dollars, about £463 million.
The 22-year-old sold 51% of Kylie Cosmetics to makeup and fragrance giant Coty Inc, in a deal which values the company at about 1.2 billion US dollars (£926 million).
Jenner was still still a teenager when she launched the business in 2015 as a line of lip kits.
According to Coty, which also owns brands including Max Factor, Rimmel and Clairol, the deal will see Jenner “lead all creative efforts in terms of product and communications initiatives”.
Coty cited Jenner’s more than 270 million social media followers across her personal and business accounts , saying she is “one of the most influential voices among beauty consumers globally”.
Jenner, who appears alongside her family on reality TV show Keeping Up With The Kardashians, said: “I’m excited to partner with Coty to continue to reach even more fans of Kylie Cosmetics and Kylie Skin around the world.
“I look forward to continuing the creativity and ingenuity for each collection that consumers have come to expect and engaging with my fans across social media.
“This partnership will allow me and my team to stay focused on the creation and development of each product while building the brand into an international beauty powerhouse.”
The move solidifies Jenner’s reputation as one of the youngest billionaires in the world.


| http://www.nodeclipse.org/updates/ | nodeeclipse |
| http://sourceforge.net/projects/nodeclipse/files/update-site-archive/ | download archives |
| Help -> Install New Software -> Add -> Archive | install archive and try again and again if fails |
| create node express project | project |
| node --debug-brk=5858 bin/www | run this on the project folder first |
| Debug as node application | debug on eclipse |


Simon Bates is a software developer living and working in Toronto.
This blog is running on a Python application that I built with Django. The source code is available under the MIT license.
Site feed


CABEXTRACT(1) CABEXTRACT(1) NAME cabextract - program to extract files from Microsoft cabinet (.cab) ar‐ chives SYNOPSIS cabextract [-ddir] [-f] [-Fpattern] [-h] [-l] [-L] [-p] [-q] [-s] [-t] [-v] cabinet files ... DESCRIPTION cabextract is a program that un-archives files in the Microsoft cabinet file format (.cab) or any binary file which contains an embedded cabinet file (frequently found in .exe files). cabextract will extract all files from all cabinet files specified on the command line. To extract a multi-part cabinet consisting of several files, only the first cabinet file needs to be given as an argument to cabextract as it will automatically look for the remaining files. To prevent cabextract from extracting cabinet files you did not specify, use the -s option. OPTIONS A summary of options is included below. -d dir Extracts all files into the directory dir. -f When testing or extracting cabinet files, corrupted MSZIP blocks will be ignored. A warning will be printed if a corrupted MSZIP block is encountered. -F pattern Only files with names that match the shell pattern pattern shall be listed, tested or extracted. On non-GNU systems, this match may be case-sensitive. -h Prints a page of help and exits. -l Lists the contents of the given cabinet files, rather than extracting them. -L When extracting cabinet files, makes each extracted file's name lowercase. -p Files shall be extracted to standard output. -q When extracting cabinet files, suppresses all messages except errors and warnings. -s When testing, listing or extracting cabinets which span multiple files, only cabinet files given on the command line shall be used. -t Tests the integrity of the cabinet. Files are decompressed, but not written to disk or standard output. If the file successfully decompresses, the MD5 checksum of the file is printed. -v If given alone on the command line, prints the version of cabex‐ tract and exits. Given with a list of cabinet files, it will list the contents of the cabinet files. AUTHOR This manual page was written by Stuart Caie<EMAIL_ADDRESS>based on the one written by Eric Sharkey<EMAIL_ADDRESS>for the Debian GNU/Linux system. SEE ALSO lcab(1) October 30, 2005 CABEXTRACT(1)


| Date | : | 6/10/2008 |
| Time | : | 2:32:50 PM |
| Elapsed Time | : | 00:00:00 |
| Filename | : | E:\ActiveWaveFiles 4-16-2008\Tag101\Tag101 Rev16\Tag101 Rev16.PCB |
| Units | : |
| Nets | Layer | Length |
|---|---|---|
| +V1.2 | Signal Layers Only | 1265.175mils |
| 3V | Signal Layers Only | 6618.024mils |
| ENABLE_RCVR | Signal Layers Only | 647.097mils |
| GND | Signal Layers Only | 6808.311mils |
| I2CSCL | Signal Layers Only | 1477.102mils |
| I2CSDA | Signal Layers Only | 1203.589mils |
| LED OUT | Signal Layers Only | 1339.572mils |
| NetC10_1 | Signal Layers Only | 575.427mils |
| NetC11_2 | Signal Layers Only | 82.782mils |
| NetC12_1 | Signal Layers Only | 164.142mils |
| NetC13_2 | Signal Layers Only | 2735.873mils |
| NetC14_2 | Signal Layers Only | 198.012mils |
| NetC17_2 | Signal Layers Only | 1029.166mils |
| NetC26_2 | Signal Layers Only | 178.112mils |
| NetC27_2 | Signal Layers Only | 282.056mils |
| NetC2_1 | Signal Layers Only | 2979.809mils |
| NetC2_2 | Signal Layers Only | 263.296mils |
| NetC3_1 | Signal Layers Only | 0mils |
| NetC3_2 | Signal Layers Only | 505.522mils |
| NetC5_1 | Signal Layers Only | 778.942mils |
| NetC6_2 | Signal Layers Only | 123.485mils |
| NetC7_1 | Signal Layers Only | 168mils |
| NetC8_1 | Signal Layers Only | 119.47mils |
| NetC8_2 | Signal Layers Only | 147.091mils |
| NetC9_1 | Signal Layers Only | 772.585mils |
| NetD1_A | Signal Layers Only | 87.06mils |
| NetQ3_D | Signal Layers Only | 396.066mils |
| NetR18_2 | Signal Layers Only | 187.602mils |
| NetR19_2 | Signal Layers Only | 177.752mils |
| NetR21_2 | Signal Layers Only | 370.615mils |
| NetR23_1 | Signal Layers Only | 233.656mils |
| NetR7_2 | Signal Layers Only | 122.486mils |
| PANIC SWITCH | Signal Layers Only | 3514.058mils |
| PROG CLK | Signal Layers Only | 2218.779mils |
| PROG DATA | Signal Layers Only | 1715.245mils |
| PROG MCLR | Signal Layers Only | 1262.002mils |
| RX DATA | Signal Layers Only | 711.714mils |
| SPEAKER OUT | Signal Layers Only | 1530.781mils |
| TAMPER PWR | Signal Layers Only | 1108.971mils |
| TAMPER SIG | Signal Layers Only | 1155.981mils |
| TILT SENSOR | Signal Layers Only | 1935.297mils |
| TX DATA | Signal Layers Only | 537.351mils |
| VMP | Signal Layers Only | 82.304mils |
| VMS | Signal Layers Only | 773.169mils |


|
The basic concepts of Lisp are easily mastered. Some computer science
courses don't "teach" Lisp at all, but allow the students to
pick it up from class examples. Most of the work of mastering Lisp
comes from learning the large libraries of
utilites available to Lisp programmers.
This website gives information mostly about Common Lisp. (See also, related languages.) This site gives listings of books, reference material, and other resources. There is a also a guide to Lisp programming style which comes from the Lisp FAQ (a listing of Frequently Asked Questions, and their answers). Below, we list some book categories, courses, and on-line tutrorials To get your feet wet, here's some classic code: (write-line "Hello, world.") ;Print the famous greeting. ;;; A function to produce the factorial of an integer. (defun factorial (n) (if (= n 1) 1 (* (factorial (- n 1)) n))) Books
Courses
On-Line Tutorials
|


GR32.pas contains common functions and classes for working with 32-bit device independent bitmaps (DIBs). It also defines some other basic types and operations.


Select a project VHS (with your mouse pointer) below to view more details.
Two AA batteries (not included) are required to run this application.
This is a collection of choice works produced by Ross Brown. If you'd like to contact him, send an email to ross(at)rossisbrown.com. You might even try writing in third person, it's fun.
You could try visiting my website or my company's website for something less flashy. Or perhaps you're ready to move on to bigger and better things.
 Lucky for you, this sloppy, poorly documented code is on Github.


{{Infobox prepared food | name = Hot dog bun | image = | caption = A hot dog bun. The side-loading variety is shown in this image | alternate_name = | country = United States | region = | creator = | course = | type = Bun | served = | main_ingredient = Flour, water | variations = | calories = | other = }}
A hot dog bun is a type of soft bun shaped specifically to contain a hot dog or frankfurter. The original purpose of this food was to make it possible to eat hot dogs without burning one’s hands.<ref>[1] "The Evolution of Hot Dogs", May 8, 2003 accessed January 29, 2011.</ref>
There are two basic types: top-loading (also known as Frankfurter rolls) New England Style Rolls<ref>[2] "New England-style bun, from HoJo’s to homemade", July 2, 2013 accessed February 12, 2014.</ref> or Lobster Buns in some areas, and side-loading, common in the rest of the United States also called American Style Buns. The advantages to a top loader are that it holds the hot dog securely and fits nicely into little three-sided paper boxes. Top loaders are generally baked side by side and torn apart as needed, leaving a flat side surface for grilling.
Contents |
Hot dog historian and professor emeritus at Roosevelt University Bruce Kraig believes the term "hot dog" was invented in the late 19th century by American observers of German immigrants, who ate sausages on buns. The Americans joked that the sausages looked suspiciously like the Germans' dachshunds.<ref>National Hot Dog and Sausage Council. [3] "Straight From The "H" Files: The Hot Dog's True History"], accessed January 29, 2011</ref>
Charles Feltman invented an elongated hot dog bun on Coney Island in 1871 according to writer Jefferey Stanton.<ref>Josh Chetwynd in "How the Hot Dog Found Its Bun: Accidental Discoveries and Unexpected Inspirations that shape what we Eat and Drink, 2012.</ref>
The Bavarian concessionaire, Anton Feuchtwange, loaned gloves for his customers to hold his sausages at the 1904 Louisiana Purchase Exposition. When many were not returned, he asked his brother, who was a baker, to invent a solution. Thus, the hot dog bun was born.<ref>"History of the Hot Dog", accessed January 29, 2011.{{dead link|date=November 2013}}</ref>
In Chicago, Illinois, where poppy-seed buns are popularly served with Chicago-style hot dogs, the buns are made with high-gluten flour to hold up to steaming.<ref name="zeldes">{{Cite web | last = Zeldes | first = Leah A. | title = It takes big buns to hold Chicago hot dogs | work = Dining Chicago | publisher = Chicago's Restaurant & Entertainment Guide, Inc. | date = 2010-07-13 | url = http://www.diningchicago.com/blog/2010/07/13/it-takes-big-buns-to-hold-chicago-hot-dogs/| accessdate = 2010-07-31}}</ref>
In Austria, a "hot dog" is a baguette which is hollowed out by cutting off the end and impaling it on a spike so a sausage can be inserted. In Denmark this variation is known as a "French Hot Dog" because of the use of baguette, and a "French Hot Dog Dressing" which contains Dijon Mustard. Pre-impaled baguettes are specially made for this variety due to its popularity.
{{reflist}}


We're currently still working on the code behind this service.
We're interested in hearing what needs you have for the service, and
any possible needs you have for an open source package. If you want to use
this code in any application, send us email at
labs at metacarta dot com so we can find out what people need from an
Open Source web-based rectifier.
Where can I find maps to try out?
The University of Texas
Map Library has a great collection of maps that you can try
out. Or just use one of the existing maps in the service: It's all
open!
How can I use these maps in my own applications?
Each map page has a link to a URL which can be used as a WMS OnlineResource.
If you have a WMS client, you can use this URL in your WMS application.
Alternatively, you can download the warped source data from your image.
This data is made available as a GeoTIFF, usable in many applications.
Note that these files are very large -- in some cases 20-30 times the size
of the original images -- because TIFF is not a lossy format like jpeg, the
original format of many of these images.
If you would like us to add support for downloading the images in a
different format, please email us at labs at metacarta dot com.
What is RMS Error? What is mean RMS Error?
RMS error is an estimate of how far off a given point is from the
resulting warped image. This RMS error is currently calculated based on
a linear warp. Higher RMS error estimates are worse: you should aim to
keep these error numbers as small as possible. Usually a high error value
indicates that a single ground control point is incorrectly positioned:
deleting the highest error document will often help the entire map warp
better. The mean RMS error is a single value which represents the current
level of error on the map: if this value goes down, your map will probably
warp more cleanly.


Photo by UBCPublicAffairs / CC BY
Passion, inspiration and curiosity. Your journey through academics will incite a variety of emotions and lead you to amazing things. Prepare to embrace it.
Learn MoreIt can be hard to get a sense of what campus life is like without being there. Experience a 360° guided tour of the campus. Feel like you are there with the tour guide.
Learn MoreWhile everyone is taking many of the same classes, what defines you are the things you do outside of class. Find something you can stick with and make friends while at it.
Learn MoreWater, snow, mountains and the third most livable city worldwide, there are tons of things to do for those with a taste for adventure.
Learn MoreFind some of the best food destinations in the Vancouver area. Local and easy to get to by bus.
Learn More


class Arel::Visitors::MSSQL
Constants
- RowNumber
Public Class Methods
new(*)
click to toggle source
Calls superclass method
Arel::Visitors::ToSql.new
# File lib/arel/visitors/mssql.rb, line 6 def initialize(*) @primary_keys = {} super end
Private Instance Methods
determine_order_by(orders, x)
click to toggle source
# File lib/arel/visitors/mssql.rb, line 86 def determine_order_by orders, x if orders.any? orders elsif x.groups.any? x.groups else pk = find_left_table_pk(x.froms) pk ? [pk] : [] end end
find_left_table_pk(o)
click to toggle source
FIXME raise exception of there is no pk?
# File lib/arel/visitors/mssql.rb, line 106 def find_left_table_pk o if o.kind_of?(Arel::Nodes::Join) find_left_table_pk(o.left) elsif o.instance_of?(Arel::Table) find_primary_key(o) end end
find_primary_key(o)
click to toggle source
# File lib/arel/visitors/mssql.rb, line 114 def find_primary_key(o) @primary_keys[o.name] ||= begin primary_key_name = @connection.primary_key(o.name) # some tables might be without primary key primary_key_name && o[primary_key_name] end end
get_offset_limit_clause(o)
click to toggle source
# File lib/arel/visitors/mssql.rb, line 59 def get_offset_limit_clause o first_row = o.offset ? o.offset.expr.to_i + 1 : 1 last_row = o.limit ? o.limit.expr.to_i - 1 + first_row : nil if last_row " _row_num BETWEEN #{first_row} AND #{last_row}" else " _row_num >= #{first_row}" end end
row_num_literal(order_by)
click to toggle source
# File lib/arel/visitors/mssql.rb, line 97 def row_num_literal order_by RowNumber.new order_by end
select_count?(x)
click to toggle source
# File lib/arel/visitors/mssql.rb, line 101 def select_count? x x.projections.length == 1 && Arel::Nodes::Count === x.projections.first end
visit_Arel_Nodes_DeleteStatement(o, collector)
click to toggle source
# File lib/arel/visitors/mssql.rb, line 69 def visit_Arel_Nodes_DeleteStatement o, collector collector << 'DELETE ' if o.limit collector << 'TOP (' visit o.limit.expr, collector collector << ') ' end collector << 'FROM ' collector = visit o.relation, collector if o.wheres.any? collector << ' WHERE ' inject_join o.wheres, collector, AND else collector end end
visit_Arel_Nodes_SelectStatement(o, collector)
click to toggle source
Calls superclass method
Arel::Visitors::ToSql#visit_Arel_Nodes_SelectStatement
# File lib/arel/visitors/mssql.rb, line 25 def visit_Arel_Nodes_SelectStatement o, collector if !o.limit && !o.offset return super end is_select_count = false o.cores.each { |x| core_order_by = row_num_literal determine_order_by(o.orders, x) if select_count? x x.projections = [core_order_by] is_select_count = true else x.projections << core_order_by end } if is_select_count # fixme count distinct wouldn't work with limit or offset collector << "SELECT COUNT(1) as count_id FROM (" end collector << "SELECT _t.* FROM (" collector = o.cores.inject(collector) { |c,x| visit_Arel_Nodes_SelectCore x, c } collector << ") as _t WHERE #{get_offset_limit_clause(o)}" if is_select_count collector << ") AS subquery" else collector end end
visit_Arel_Nodes_Top(o)
click to toggle source
`top` wouldn't really work here. I.e. User.select(“distinct first_name”).limit(10) would generate “select top 10 distinct first_name from users”, which is invalid query! it should be “select distinct top 10 first_name from users”
# File lib/arel/visitors/mssql.rb, line 16 def visit_Arel_Nodes_Top o "" end
visit_Arel_Visitors_MSSQL_RowNumber(o, collector)
click to toggle source
# File lib/arel/visitors/mssql.rb, line 20 def visit_Arel_Visitors_MSSQL_RowNumber o, collector collector << "ROW_NUMBER() OVER (ORDER BY " inject_join(o.children, collector, ', ') << ") as _row_num" end


There are three main steps in creating an animated humanoid character from scratch: modelling, rigging and skinning.
Modelling
This is the process of creating your own humanoid mesh in a 3D modelling package - 3DSMax, Maya, Blender, etc. Although this is a whole subject in its own right, there are a few guidelines you can follow to ensure a model works well with animation in a Unity project.
Observe a sensible topology. The exact nature of a “sensible” structure for your mesh is rather subtle but generally, you should bear in mind how the vertices and triangles of the model will be distorted as it is animated. A poor topology will not allow the model to move without unsightly distortion of the mesh. A lot can be learned by studying existing 3D character meshes to see how the topology is arranged and why.
Be mindful of the scale of your mesh. Do a test import and compare the size of your imported model with a “meter cube” (the standard Unity cube primitive has a side length of one unit, so it can be taken as a 1m cube for most purposes). Check the units your 3D package is using and adjust the export settings so that the size of the model is in correct proportion to the cube. Unless you are careful, it is easy to create models without any notion of their scale and consequently end up with a set of objects that are disproportionate in size when they are imported into Unity.
Arrange the mesh so that the character’s feet are standing on the local origin or “anchor point” of the model. Since a character typically walks upright on a floor, it is much easier to handle if its anchor point (ie, its transform position) is directly on that floor.
Model in a T-pose if you can. This will help allow space to refine polygon detail where you need it (e.g. underarms). This will also make it easier to position your rig inside the mesh.
Clean up your model. Where possible, cap holes, weld verts and remove hidden faces, this will help with skinning, especially automated skinning processes.
Rigging
This is the process of creating a skeleton of joints to control the movements of your model.
3D packages provide a number of ways to create joints for your humanoid rig. These range from ready-made biped skeletons that you can scale to fit your mesh, right through to tools for individual bone creation and parenting to create your own bone structure. To work with Mecanim, the hips should be the root element of the bone hierarchy. A minimum of fifteen bones are required in the skeleton.
The joint/bone hierachy should follow a natural structure for the character you are creating. Given that arms and legs come in pairs, you should use a consistent convention for naming them (eg, “arm_L” for the left arm, “arm_R” for the right arm, etc). Possible structures for the hierarchy might be:-
* HIPS - spine - chest - shoulders - arm - forearm - hand
* HIPS - spine - chest - neck - head
* HIPS - UpLeg - Leg - foot - toe - toe_end
Skinning
This is the process of attaching the mesh to the skeleton.
Skinning involves binding vertices in your mesh to bones, either directly (rigid bind) or with blended influence to a number of bones (soft bind). Different software packages use different methods, eg, assigning individual vertices and painting the weighting of influence per bone onto the mesh. The initial setup is typically automated, say by finding the nearest influence or using “heatmaps”. Skinning usually requires a fair amount of work and testing with animations in order to ensure satisfactory results for the skin deformation. Some general guidelines for this process include:
Using an automated process initially to set up some of the skinning (see relevant tutorials on 3DMax, Maya, etc).
Creating a simple animation for your rig or importing some animation data to act as a test for the skinning. This should give you a quick way to evaluate whether or not the skinning looks good in motion.
Incrementally editing and refining your skinning solution.
Sticking to a maximum of four influences when using a soft bind, since this is the maximum number that Unity will handle. If more than four influences affect part of the mesh then at least some information will be lost when playing the animation in Unity.


Services
Advance Facials & Treatments - 400 SEK (60 Mins)
Cheryl’s OxyDerm - The Anti-Ageing Bleaching System - 60 SEK
Only face cleanup - 280 SEK (40 mins)
Face Fr 150 - 180:-
Eyebrow 50:-
Eyebrow with upper lips 70:-
Upper Lips 20:-
Forehead 20:-
Chin Fr 30 - 50:-
Full arm and legs with underarms 300:-
Full arm and legs 280:-
Full legs 160:-
Half legs 100:-
Full arms with under arms 150:-
Only full arms 120:-
Only under arms 50:-
International styling 200:-
Any Cut 200:-
Trimming 150:-
Retexturize with DeFabulous
Kerafusion is the latest and one of the most innovative Keratin Treatments available globally.
It is a specially formulated protein complex that eliminates frizz and out of control curls and leaves hair silky,
shiny and healthy.


Cellular Automation Show Case
This is a website which to show how the cellular automation algorithm works
Generation
Next Step
Generation
Next Step


The general SPARQL query service is accessed directly using the SPARQL protocol at URL /sparql
The full set of SPARQL specification is:
This server is running Apache Jena Fuseki.


AUGUST 29 The Passion of Saint John the Baptist
St John's fearless condemnation of
Herod's unlawful marriage incurred the hatred of the king's bride, Herodias.
 St John the Baptist teaches us to be strong
in carrying out the mission God has given us.
ENTRANCE
ANTIPHON
I spoke, O
Lord, of your decrees before kings, and was not confounded; I pondered your
commands and loved them greatly.
Introductory Rites
COLLECT
O God, who
willed that Saint John
the Baptist should go ahead of your Son both in his birth and in his death,
grant that as he died a Martyr for truth and justice, we, too, may fight hard
for the confession of what you teach. Through our Lord Jesus Christ, your Son,
who lives and reigns with you in the unity of the Holy Spirit, one God, for
ever and ever.
Readings
PRAYER
OVER THE OFFERINGS
Through these
offerings which we bring you, O Lord, grant that we may make straight your
paths, as taught by that voice crying in the desert, Saint John the Baptist, who powerfully sealed
his teaching by the shedding of his blood. Through Christ our Lord.
Preface of John the Baptist
COMMUNION
ANTIPHON
John answered
and said: He must increase; but I must decrease.
PRAYER
AFTER COMMUNION
Grant, O
Lord, as we celebrate the heavenly birth of Saint John the Baptist, that we may
revere, for what it signifies, the saving Sacrament we have received and, even
more, may rejoice at its clear effects in us. Through Christ our Lord.


rice rainfed climate areas cells cultivation models suitability extent change changes rainfall data GCMs India occurrence variables Fig. future important locations suitable CEMs temperature using {border-style high model outputs projected risk BRTs modelled px;} yield #ffffff;} area crop unsuitable Appendix CEM agreement cell Climate monsoon probability projections RCP growing used variable (i.e. crops impacts increase increased new observed production regional spatial total BRT Chang. climatically global map min project Agric. Rice Sci. different food future, grown growth low plant potential predicted presences Indian Rao based current max modelling predict px; summer variability {font-family (CEMs) (e.g. Clim. Crop India, confidence cropping font-size improved irrigated local reduce regression rice, shown statistical threshold trees (a) (see Auffhammer Environ. Lee Proc. Res. Table agriculture currently declines double; evapotranspiration farmers large little major mapping maximum periods relation ripening security sensitivity study temperatures value varieties yields (Fig. (b) A). Acad. CEMs, Jones Kim Natl. P.K. RCPs Rain Rainfed States Statistical absences addition, agree agricultural average averaged border-color border-width categorical cells) change, consensus data, distribution districts eastern ensemble generally grain heat highlight irrigation minimum order range ratio regions resolution result solid; stress values vulnerable {font-style {font-weight %–% (BRTs) (Pearson's (area (from AUC BRTs. Friedman Global However, IPCC J.R. Jayasankar ROC Science Section Shah Thuiller agreed approaches available bold boosted considerable continuous courier; cultivation, cultivation. curve decline detrimental em; expected implications importance information livelihoods location main maps methods monthly planting predictor present pt;} reduced referred relative results rice. season severity single terms times vulnerability warming


Welcome, {{teamName}}!
You'll find the first beacon by the presentation screen. Good luck!
{{completeStr}}


clustergb.structure¶
For reading and writing LAMMPS-compatible structure files.
-
clustergb.structure.
comment_count
(counts)¶ Convert raw counts of atoms in the different cluster regions to a human-readable string.
Parameters: counts (list) – int values for the number of nonbulklike atoms, atoms in the inner sphere (excluding non-bulklike), the shell between the inner and outer sphere, and the balance of atoms in the cluster. Returns: (str) – A comment describing the atom counts.
-
clustergb.structure.
comment_radii
(r_inner, r_outer, r)¶ Convert radii defining the cluster and sub-spheres to a human-readable string.
Parameters: - r_inner (float) – Inner sub-sphere radius.
- r_outer (float) – Outer sub-sphere radius.
- r (float) – Radius of the entire cluster.
Returns: (str) – A comment describing the cluster radii.
-
clustergb.structure.
read_xyz
(fin, step=-1)¶ Reads a LAMMPS-dumped .xyz file.
Parameters: - fin (str) – File to read.
- step (int) – Which frame to read. Can be negative to read from the end of the file. (Default is -1.)
Returns: 2-element tuple containing
- (np.ndarray) – \((n, 3)\) cartesian xyz positions of all atoms. and their species ids.
- (np.ndarray) – \((n,)\) and their int species flag.
-
clustergb.structure.
read_xyzin
(fin)¶ Reads ‘.xyzin’ file (the format for LAMMPS to read from when loading a structure.)
Parameters: fin (str) – File to read. Returns: 5-element tuple containing - (np.ndarray) – \((n, 3)\) cartesian xyz positions of all atoms. and their species ids.
- (np.ndarray) – \((n,)\) and their int species flag.
- (float), (float), (float) – The x-, y-, and z-lengths of the rectangular simulation cell.
-
clustergb.structure.
reorder
(pos, center, r_inner, r_outer, cna_vals=None, lattice_type=None)¶ Reorders a set of cartesian atomic positions positions so that non-bulk-like atoms are at the beginning of the position array, followed by inner atoms, followed by outer, followed by the balance of the list.
- Non-bulk-like) Has a cna_vals id that doesn’t correspond to the bulk-indicator for the given lattice_type. If
cna_vals is left as the default None type, this will be an empty list of positions.
Inner) The atoms whose position is within r_inner of the center point, but who are bulk-like.
Outer) Atoms who lie between r_inner and r_outer from center, whether they’re bulk-like or not.
Balance) The balance of atoms in the pos list, all farther that r_outer from center.
Parameters: - pos (np.ndarray) – \((n,3)\) Cartesian atom positions.
- center (np.ndarray) – \((3,)\) center of the cluster.
- r_inner (float) – Inner radius for partitioning the cluster.
- r_outer (float) – Outer radius for partitioning the cluster.
- cna_vals (np.ndarray) – \((n,)\) int LAMMPS common-neighbour analysis flags per atom. (Default has no non-bulk-like atoms.)
- lattice_type (str) – The crystal lattice type (‘fcc’ or ‘bcc’.)
Returns: 2-element tuple containing
- (np.ndarray) – \((n,3)\) atomic positions with atoms ordered non-bulklike, inner, outer, and balance.
- (np.ndarray) – \((4,)\) int counts of atoms in the same order.
-
clustergb.structure.
write_vorin
(fout, pos)¶ Write a file with atomic position data formatted for voro++ to read.
Parameters: - fout (str) – Name of file to write to.
- pos (np.ndarray) – \((n,3)\) Cartesian atomic positions to write.
-
clustergb.structure.
write_xyzin
(fout, pos, lx, ly=None, lz=None, species=None, nspecies=None, comment='Written with clustergb', mask=None)¶ Write an ‘.xyzin’ file, i.e. xyz formatted with some box information so it can be read by LAMMPS.
Parameters: - fout (str) – Name of file to write to.
- pos (np.ndarray) – \((n,3)\) Cartesian atomic positions to write.
- lx (float) – Periodic length in x-direction.
- ly (float) – Periodic length in y-direction. (Default, None, uses lx value.)
- lz (float) – Periodic length in z-direction. (Default, None, uses lx value.)
- species (np.ndarray) – \((n,)\) int species identifiers. (Default, None, is all species 1.)
- nspecies (int) – Number of species (must be at least as many as unique species in species array). (Default, None, counts the unique values in species.)
- comment (str) – Comment string to put at head of file. Must be a single line or the file may not be read properly later. (Default is “Written with clustergb”.)
- mask (np.ndarray) – \((n,)\) bool mask indicating which atoms should be written if only a subset is desired. (Default, None, writes the entire array of atoms.)


Enumeration members
ENUMERATED
ENUMERATED: = 10
GENERALIZEDTIME
GENERALIZEDTIME: = 24
GENERALSTRING
GENERALSTRING: = 27
IA5STRING
IA5STRING: = 22
NUMERICSTRING
NUMERICSTRING: = 18
OCTETSTRING
OCTETSTRING: = 4
PRINTABLESTRING
PRINTABLESTRING: = 19
T61STRING
T61STRING: = 20
ASN.1 types. Not all types are supported by this implementation.


The Contents lists Help topics available for QuickSmith. Use the scroll bar to see entries not currently visible in the Help window.
To learn how to use Help, press F1 or choose using Help from the Help menu
Smith Chart
Schematic
Amplifier Design/Analysis


--- layout: game-page title: "Maze Phase" header-img: "img/games/maze-phase/game_banner.jpg" meta_description: "Seeking the thrill of solving mazes in an arcade-style fast reaction game? Come phase through waves of mazes in this difficult and addicting experience!" ---


weekly schedule 2020 - semester 2
feb 1
- copmutation about means of understanding
-
-
-
-
- ~~history of programming languages~~
- ~~semantics in programming languages~~
feb 8
- ~~aesthetics about means of understanding (lit)~~
-
- conferences + books to order
-
-
-
-
-
- philosophy of computer science (pp.123-144, pp.492-501, pp.537-559, pp.648-667)
-
-
- aesthetics of code (pp.159-201 - pp.201-237)
-
-
- skim a-z of programming languages for references to beauty
-
-
-
- see aesthetics/ folder (based on the cambridge syllabus)
feb 15
- read refs from rapaport
- [https://www.chronicle.com/article/decoding-the-value-of-computer-science/]
- [https://www.cs.swarthmore.edu/~cfk/cs-liberal-arts-accepted.pdf]
- [http://legacy.earlham.edu/~peters/writing/software.htm] patterns!
- [https://www.jstor.org/stable/27903620] software ontology
- [https://eric.ed.gov/?id=EJ242987] what is a program?
- paragraph 10.4.2
- [https://cacm.acm.org/magazines/2005/8/6141-software-as-art/fulltext]
- read 19.4.3 for Lakoff
- putnam, representation and reality, 1988 (pp.121-125)
- rapaport 1999, implementation is semantic interpretation
- [https://www.ehu.eus/documents/1134202/0/Lamport+-+Who+Builds+a+House+without+Drawing+Blueprints.pdf] -> look for “abstraction is an art”
- [https://ruccs.rutgers.edu/images/personal-zenon-pylyshyn/class-info/FP2012/FP2012_readings/Dennett_RealPatterns.pdf]
- ~~aesthetics about means of understanding (lit)~~
-
- go through reference list
feb 22
- write recap and touch base with advisors


Which programming language you chose to learn can be a tough descision to make, were here to help! Answer the questions below and we'll match you with the right fit.
Your ideal programming language is !