Type in the following URL into your browser and search for “pancreatic cancer”:
- http://www.ncbi.nlm.nih.gov/pubmed/
- The quote signs are important for the exact search.
- Click on “Send to:” and “File” and select “XML”.
16th April 2015: 23258 PubMed-IDs
- Some PubMed-IDs might change over time. Even for the given example list of PubMed-IDs for this documentation in “data/pubmed_result.txt” it is possible, that you receive another number of downloaded publications in your XML files as well as different outcomes in the ongoing analyses.
- You can also use PubMedPortable for daily updates, but the parser will not include PubMed IDs which are already contained in the database. Therefore, we recommend to generate a completely new database and a new full text index once a year.
- The download of around 272 MB can take up to one hour depending on the time of day and internet connection.
Another possibility is to download PubMed articles with EFetch:
How to build a query:
You can also download only the PubMed-ID list from your browser by selecting “PMID List” instead of “XML” and then use EFetch (tested only on Ubuntu):
- Change into the directory “data” in your command-line and type in “python generate_efetch.py”. It will build the script “efetch.sh” which generates XML files with 100 PubMed-IDs in each document.
- The standard input filename is “pubmed_result.txt” and the block size of PubMed-IDs for one XML file is 100, but this can be changed. Type in “python generate_efetch.py -h” to show adjustable parameters.
- If you want to specify the name of the directory where the XML files should be saved, use parameter “-d” and create this folder manually before.
- The file “data/pubmed_result.txt” contains 23258 PubMed-IDs and the first 100 PubMed-IDs are saved in “data/pancreatic_cancer_example/medline_00000000.xml” as an example.
- Make “efetch.sh” executable with “chmod +x efetch.sh” in the command-line and run it in a folder of your choice by typing in “./efetch.sh”.
- This will be faster than using the browser to download a single XML file and it has the advantage of using multiprocessing in the next step as the script generates XML files with 100 titles in each document. The command also works with blocks of 500 PubMed-IDs, but not 1000.
It is also possible to download the whole PubMed via license:
These are the packages that need to be installed to use PubMedPortable:
- python>=2.7.3
- postgresql>=8.4
- python-xappy>=0.5
- python-xapian>=1.2.8
- python-sqlalchemy>=0.9.7
- python-psycopg2>=2.4.5 (dependency from SQLAlchemy)
To install, the following command can be used in the Ubuntu terminal:
- “sudo apt-get install”
If you use an older Ubuntu version, you can use “pip” to upgrade your package versions specifically for your user name, e.g.:
- “sudo pip install sqlalchemy –upgrade”
To install the Fedora packages use the following command. It will install all required packages:
- “sudo -E dnf install python python-xappy python-sqlalchemy python-psycopg2 postgresql postgresql-server postgresql-contrib”
To enable PostgreSQL in Fedora, use the following steps:
- “sudo systemctl enable postgresql”
To start postgresql use the following command
- “sudo systemctl start postgresql”
To populate initial data, the following command is required:
- “journalctl -xn”
To initialise database, use the following command:
- “sudo postgresql-setup initdb”
To allow read access to postgres, SELinux should be modified. This can be done with the following command:
- “grep postgres /var/log/audit/audit.log | audit2allow -M mypol”
Then you can do this (this is also required upto Fedora 23):
- “sudo semodule -i mypol.pp”
Append this line in the file “pg_hba.conf” (default location: “/var/lib/pgsql/data/pg_hba.conf”):
- “host all all <IP_ADDRESS> <IP_ADDRESS> trust”
- If “trust” is used instead of “ident”, you are allowed to use a password. “<IP_ADDRESS>” means that all machines are allowed to login. That means, if you want to customise which server has to reach the database, you can control it here.
If there is not yet a superuser for the PostgreSQL database, create one with the name of your local account
- “sudo -u postgres createuser --superuser <user_name>”
“sudo -u <user_name> psql template1”
- \password <press enter, type in password, and press enter, again>
- \q
Now, you can connect to the standard PostgreSQL database “postgres” with PGAdmin3 or via command-line:
- “psql -h localhost -d postgres -U <user_name>”
Install Docker - it was tested on Ubuntu (64-bit required):
- https://docs.docker.com/engine/installation/linux/ubuntulinux/
There are many different operating systems supported:
Run Docker with the PubMedPortable image:
- Create a folder on your local disk with a name of your choice.
- Go into that folder and create a directory “import_data”.
- Copy you XML files downloaded from PubMed into the directory “import_data”.
Open a terminal and type in this command:
- “sudo docker run -d -v /home/<user_name>/<folder_of_your_choice>/:/export/ -p 9999:5432 bgruening/pubmedportable”
- This will create the PostgreSQL folder as well as the full text index database folder within the <folder_of_your_choice>.
- You can see that Docker is running by typing in “sudo docker ps”. This will show a randomly generated name for your process.
- Stopping Docker is possible by doing “sudo docker stop <name>”.
Docker maps your PosgreSQL port “5432” to the port “9999”. Now, you can connect to your database with PGAdmin via “localhost”, port “9999” and user “parser” with password “parser”. If you want to connect via command-line, use this command:
- “psql -h localhost -U parser -p 9999 -d pubmed”
If you have created another folder with a name <folder_of_your_choice> and the directory “import_data”, you can create another database on port “9998” and another full text index with different data there:
- “sudo docker run -d -v /home/<user_name>/<folder_of_your_choice>/:/export/ -p 9998:5432 bgruening/pubmedportable”
You can use other parameters to open the docker container first, e.g. if you want to modify software versions:
- “sudo docker run -i -t -v /home/<user_name>/<folder_of_your_choice>/:/export/ -p 9998:5432 bgruening/pubmedportable /bin/bash”
- “startup” will initialize the building process in your docker container.
- If you want to check which version of a software is installed, you open your container first and run “pip freeze” or you can execute e.g. “sudo docker run -it bgruening/pubmedportable python -c ‘import sqlalchemy; print sqlalchemy.__version__’”.
- In case of replacing or creating a database on a port that is already used, delete the complete directory <folder_of_your_choice> and repeat the configuration steps.
This also means that you need a default PostgreSQL installation on your operating system. Restart a closed Docker session on port “9999” with the command:
- “sudo docker run -d -v /home/<user_name>/<folder_of_your_choice>/:/export/ -p 9999:5432 bgruening/pubmedportable”
It is not recommended to run the PubMedPortable examples or to develop new scripts within the Docker container. If you want to modify the image, use the Docker documentation and this repository:
During the revision process of the PubMedPortable publication, the original name PubMed2Go was changed to PubMedPortable.
- The bgruening GitHub repository name changed to pubmedportable, but the scripts and the generated outputs still contain the name pubmed2go.
- The docker container bgruening/pubmed2go still exists and contains the same version as bgruening/pubmedportable.
- Users with an older version of the docker container should execute “sudo docker pull bgruening/pubmed2go” to update their version.
Open a Terminal and type in:
- “psql template1”
Enter the following commands into psql prompt to create a database, the schema “pubmed”, and a standard user “parser”. It is important to write the user “parser” in single quotes in the creation step:
- CREATE USER parser WITH PASSWORD 'parser';
- CREATE DATABASE pancreatic_cancer_db;
- GRANT ALL PRIVILEGES ON DATABASE pancreatic_cancer_db to parser;
- \q
Now you can create a schema “pubmed” as user “parser”. You will be asked to enter your password “parser” here:
- “psql -h localhost -d pancreatic_cancer_db -U parser -f create_schema.sql”
Create the tables in your database schema “pubmed” like this:
- Use the command “python PubMedDB.py -d pancreatic_cancer_db” in your terminal. There are no other parameters that can be set.
Load the data from PubMed into your PostgreSQL database:
You can check “python PubMedParser.py -h” to get a help screen with all adjustable parameters. If you want to use the defaults, you can simply type in “python PubMedParser.py”.
- By default, previously in PostgreSQL inserted data will be deleted before loading the new XML files into the database.
- If you do not want to delete, but only add XML files to the data that is already inside your PostgreSQL database, use parameter “-c”.
- The default database name is “pancreatic_cancer_db” and the default number of processors is 2. For changing, use parameters “-d” and “-p”.
- If you want to process only part of your files, use the parameters “-s” and “-e” with numbers referring to your alphabetically sorted files, e.g. “-s 0 -e 20” for the first 20 XML files in the directory.
It is important that you only type in the name of the folder containing all XML files with parameter “-i”, but not the name of the file(s). You do not need to type in the absolute path. Suppose, you have saved your XML file(s) in the directory “data/pancreatic_cancer”, use this command to run it with 3 processors and the database “pancreatic_cancer_db”:
- “python PubMedParser.py -i data/pancreatic_cancer/ -d pancreatic_cancer_db -p 3”
- If you receive an error concerning too many database connections, make sure that you use the latest version of SQLAlchemy. In earlier versions, sometimes the database connections were closed by the programme, but still remained open for some seconds, preventing the new programme to open a new connection. You can also increase the number of possible connections to your PostgreSQL server that can be opened (Ubuntu: “max_connections = <type in number>” in “/etc/postgresql/<version number>/main/postgresql.conf”).
- For one file with around 272 MB this takes around 10 min (only one processor can be used). For the same amount of data split into files with only 100 PubMed-IDs (use “generate_efetch.py”) it takes around 4 min with 3 processors (2,83 GHz and 8 GB RAM).
If you want to extend the database schema in terms of additional columns or tables, you can have a look at this diff in the GitHub repository:
- https://github.com/KerstenDoering/PubMedPortable/commit/99f39f385c83d121422d1c48694c7fb2e6e421b3
- Consider the example of UI fields (MeSH IDs) for chemical substances.
- The column needs to be initialised (line 220 and 225 in PubMedDB.py) and the parser needs to get this XML field (line 309 in PubMedParser.py).
- The steps how to create a new table with adapted columns can be seen in the example of creating a class OtherID and OtherAbstract from the earlier existing class Other.
If you use all default values from this documentation, you will receive results in “results/results.csv” with “python RunXapian.py -x”.
- If you want to use the PostgreSQL database generated with Docker, change the port in the script “Article.py” in line 21 from “5432” to “9999” (the port you selected in Docker) and use the parameter “-d” with the database “pubmed” for the script “RunXapian.py”.
This command indexes all titles, abstracts, keywords, MeSH terms and substances from year 1809 to 2015, downloaded as XML files from PubMed (as described in section “Download a Data Set”).
- There are no abstracts with a publication date before 1809:
- http://www.nlm.nih.gov/bsd/licensee/2015_stats/baseline_med_filecount.html
After completing the step of generating the full text index, the programme searches it with the synonyms given in “synonyms/pancreatic_cancer.txt”.
- This file contains manually chosen names of drugs, genes, proteins, and diseases related to pancreatic cancer.
- User-provided synonyms can be directly stored in this file or saved in a new text document in the folder “synonyms”. Subsequently, the parameter “-s” can be used to process this file.
- The output in the command-line shows how many PubMed-IDs are indexed (23258) and how many synonyms are searched (86).
- This takes around 2-3 min on a 2,83 GHz machine with 8 GB RAM.
- You can also select single years for indexing and searching.
- If you just want to index your XML files, type in “python RunXapian.py -x -f”. (Parameter “-f” turns off the search function of the programme, default is “True”.)
- If you just want to search your synonyms, type in “python RunXapian.py” (Parameter “-x” turns on the indexing step, default is “False”.)
- The default location for your full text index database folder is “PubMedPortable/full_text_index/xapian/<xapian2015>”. You can change this location by using the parameter “-p”.
For the given example, 10392 lines were generated in “results.csv”. Run “python summary.py” to get two CSV files in directory “results”. If you have chosen another filename as output from “RunXapian.py”, you can do “python summary.py -f <name_of_input_file.csv>”:
Drug synonyms were taken from DrugBank using the exact search query “pancreatic cancer”:
Protein and gene synonyms have been extracted manually from OMIM also performing an exact search:
- Diseases related to pancreatic cancer have been taken the text given on OMIM, too.
“counts_results.csv” shows how many synonyms were found (descending - 64 lines, meaning 64 from a total of 86 search terms). The alternative input filename will be “counts_<input_file.csv>”.
- Taking into account the drugs, gemcitabine shows the most hits (2907). Erlotinib was found in 311 publications. Other approved drugs like WF10 and hydroxocobalamin were not found. Many investigational drugs were found 1-10 times: R115777, G17DT, hedgehog pathway inhibitor, imexon, GV1001, RP101, MGI-114, and PX-12. No other substances given on DrugBank were identified in this data set.
- Pancreatic ductal adenocarcinoma is the most common type of pancreatic cancer ( http://www.cancer.gov/aboutnci/budget_planning_leg/plan-2013/profiles/pancreatic ), which is shown by the 1598 hits. The tumor suppressor protein p53 was found 660 times, but also associated genes like KRAS, SMAD4, BRCA2, mTOR and CDKN2A were found (138-424 times). Many other genes were identified with a number below 10 hits and can be further analysed in “pmids_results.csv”.
- Associated diseases like breast cancer, colon cancer, ovarian cancer and diabetes were found 255-919 times.
- “pmids_results.csv” shows which synonyms co-occur in the same abstract or title, sorted by PubMed-IDs (7500 lines). In case of an alternative input filename, there will be the resulting file “pmids_<input_file.csv>”.
In case, you want to index the whole PubMed, it can be useful to index blocks of years or every year as a single directory. Like this, it is possible to use multiprocessing and decrease RAM usage. Just run the programme in different shells or on different machines and copy all resulting index folders to the same main directory. The tool “xapian-compact” summarises all generated directories to one full text index:
- http://xapian.org/docs/admin_notes.html#merging-databases
- xapian-compact -m <all input directories to be compressed, separated by space> <name of outcoming folder with complete database>
- Using Ubuntu, this tool might have to be installed additionally with “sudo apt install xapian-tools”.
Use the following scripts to work with the functions OR, AND, NEAR, ADJ, NOT, and phrase search in Xapian and have a look at the HTML output files. As the number of PubMed-IDs increases continuously, the resulting numbers in this documentation can be seen as a reference point for the given query “pancreatic cancer”. Having a look at these scripts as well as “RunXapian.py” can be useful to build your own modified queries. There is also a small note in “full_text_index/xapian/readme.txt”.
“python search_title.py” shows that only a few lines of code are required to search only publication titles. This can be important as searching especially in publication titles puts more emphasis on the queried synonyms.
- While “RunXapian.py” searches only the exact phrase “pancreatic cancer”, “search_title.py” searches for the stem “pancreat” and also finds the word “pancreatitis”.
The search terms in the scripts described in this subsection are hard-coded and have to be changed manually by the user.
- It generates “Xapian_query_results.html” which shows the first 1000 of 18085 titles. Like this, many associated words are shown, e.g. “pancreatic ductal adenocarcinoma”, “pancreatic juice”, or “pancreatic diseases”.
To further specify your search, you can query titles containing “pancreatic cancer” and the drug “erlotinib” with “python search_near_title.py”.
- This generates 38 results in “Xapian_query_results_NEAR.html”.
- In this case “NEAR/5” is used as a Xapian function. In this case, a maximum of 4 words is allowed to be between the two search terms.
- An alternative would be the query with “ADJ/5”, which reduces the number of 38 hits to 4 hits, because with this function, the order of search terms is fixed.
- Here, the exact search is performed, again.
As it was done in “RunXapian.py” different index fields can be searched.
- “python search_title_or_text.py” searches documents in which the drug “R115777” occurs in the title or the text.
- As shown in “counts_results.csv”, only 10 hits can be found. The matching titles and abstracts can be seen in “Xapian_query_results_OR.html”.
The script “python search_not_title_or_text.py” specifies the query to documents not containing the terms “colon”, “lung”, or “ovarian”, but the word “pancreatic”.
- This reduces the number of results to 9 hits, as no publications are considered that contain these other types of cancer.
- The result is shown in “Xapian_query_results_NOT.html”.
- In this way, different search queries can be combined with a few lines of code.
Type in these SQL queries in PGAdmin3 or in the PostgreSQL shell to get familiar with the schema “pubmed”:
Find all substances related to pancreatic cancer, pancreatitis, etc.
- select * from pubmed.tbl_chemical where lower(name_of_substance) LIKE 'pancreati%'; -- 180 lines
Find all MeSH terms with the substring “ancreat” and prefixes as well as suffixes.
- select distinct on (descriptor_name) * from pubmed.tbl_mesh_heading where lower(descriptor_name) LIKE '%ancreat%'; -- 29 lines
What is the number of published titles in our database?
- select count(*) from pubmed.tbl_medline_citation; -- 23258
How many publications contain an abstract?
- select count(*) from pubmed.tbl_abstract; -- 21387
Show me all different journals and abbreviations referring to our topic.
- select distinct on (title, iso_abbreviation) title, iso_abbreviation from pubmed.tbl_journal; -- 2209 lines
What is the number of publications since 1990?
- select count(*) from pubmed.tbl_journal where pub_date_year <=2000 and pub_date_year >=1990; -- between 1990 and 2000: 3736 publications
- select count(*) from pubmed.tbl_journal where pub_date_year <=2010 and pub_date_year >2000; -- after 2000 until 2010: 9497 publications
- select count(*) from pubmed.tbl_journal where pub_date_year >2010; -- after 2010: 8461 publications
What is the number of publications in USA referring to our topic?
- select count(*) from pubmed.tbl_medline_journal_info where lower(country) = 'united states'; -- 10010 publications
Take one of the first publications for the query “pancreatic cancer” in the browser on NCBI and check whether this author has other publications, e.g. Bobustuc et al., 2015.
- select count (*) from pubmed.tbl_author where last_name = 'Bobustuc'; -- 2
Try “python find_authors.py” to see an example for processing a PostgreSQL query in Python. Use “python find_authors.py -f <output_filename> -d <name_of_database>” to specify the name of the output file and the database to connect to. “python find_authors.py -h” shows all adjustable parameters.
Considering the output file “results/authors.csv”, Ralph H. Hruban has published the most articles with a number of 258 PubMed-IDs.
- The other authors and their number of publications can be found in descending order.
You can check the amount of publications from similiarly written author names in PGAdmin3 and then Helmut Friess is shown as the one with the most publications:
- select distinct on(fk_pmid) * from pubmed.tbl_author where last_name = 'Friess' and (fore_name = 'H' or fore_name = 'Helmut') order by fk_pmid; -- 375
- select distinct on(fk_pmid) * from pubmed.tbl_author where last_name = 'Büchler' and (fore_name = 'Markus W' or fore_name = 'M W') order by fk_pmid; -- 310
- select distinct on(fk_pmid) * from pubmed.tbl_author where last_name = 'Hruban' and fore_name = 'Ralph H'; -- 258
- It is possible that an author name exists twice although different persons are meant. This is not considered here.
There are examples in which you can only find a collective name:
- select * from pubmed.tbl_author where last_name is NULL and fore_name is NULL; -- 273
Based on this, it is possible to consider whether the author Helmut Friess has published something containing the query terms from the list in “synonyms/pancreatic_cancer.txt”:
Type in “python find_topics.py”. You can try “python find_topics.py -h”, to see which parameters can be varied, e.g. if your input filename is not “pmids_results.csv” or if you want to specify your output filename, which default is “pmids_results_from_author.csv”.
- 127 publications were found for the given list of synonyms and this author.
- The main research topic seems to be pancreatic ductal adenocarcinoma. This result can be compared with the outputs using other author names (hard coded in “find_topics.py”) and running “find_topics.py” with another filename, again.
- The word clouds generated here are based on the modified Xapian full text version searching only PubMed titles and abstract texts. Therefore, the files “RunXapian.py” and “SynonymParser.py” as well as the folder “synonyms” need to be copied from the folder “full_text_index” to the folder “full_text_index_title_text”. The directories “xapian” and “results” have to be created, too. Afterwards, the command “python RunXapian.py -x” can be used, again. The numbers described in the last sections can differ slightly from the results generated here. The command “python summary.py” also has to executed.
- At first, the list of the 50 most frequently occurring words that were generated with “python summary.py” needs to be extracted in logarithmic scale to visualise the search terms appropriately. In the directory “PubMedPortable/plots/word_cloud”, run the script “get_search_terms_log.py” to get the output file “counts_search_terms_log.csv”. The highest frequency is shown by the small molecule gemcitabine. The parameter “-h” shows available parameters.
- The second step in this example is to find the 50 most frequently co-occurring words in texts that contain the search term gemcitabine. This can be done by running the command “python generate_surrounding_words_log.py”. The stop word list that is used by this script was referenced by Hettne et al. [A dictionary to identify small molecules and drugs in free text. Bioinformatics. 2009 Nov 15;25(22):2983-91. doi: 10.1093/bioinformatics/btp535.]. It is provided in the folder “blacklist”. Have a look at the links given in “stop_words.txt”. These stop words were used to filter out terms with a very high frequency that have no substantial meaning for the content analysed. The numbers in the ouput file “counts_surrounding_words_log.csv” are given in logarithmic scale, too.
- The search term “Gemcitabine” is hard-coded and needs to be changed directly in the script.
The plot can be genrated with the package “PyTagCloud”. Please, follow the installation instructions on this GitHub page:
- For the first plot given here, use the command “python create_word_cloud.py -i counts_search_terms_log.csv -o cloud_search_terms.png”.
For the next figure, run “python create_word_cloud.py -i counts_surrounding_words_log.csv -o cloud_surrounding_words.png”.
- The word clouds will look different every time the script is used.
- The figure area can be enlarged by changing the value of the parameter “size” in the function “create_tag_image()”.
In this subsection, the library “matplotlib” is needed to generate a pie chart.
- In Ubuntu, this library can be installed with the command “sudo apt-get install python-matplotlib”.
- In Fedora 22, the command “dnf install python-matplotlib” can be used and in case of older Fedora versions, the command “yum install python-matplotlib”.
- By running “python pie_chart_countries.py”, the picture “pie_chart_countries_publications.png” is produced from the input file “countries_pancreatic_cancer.csv”.
- To get the CSV file, you need to connect to your database, e.g. with “psql -h localhost -d pancreatic_cancer_db -U parser” and type in “\COPY (SELECT fk_pmid, LOWER(country) FROM pubmed.tbl_medline_journal_info WHERE country IS NOT NULL ORDER BY country ASC) TO 'countries_pancreatic_cancer.csv' DELIMITER ','”.
- The script calculates the percentages of country names in which the journals given in the PostgreSQL database are published. Fractions below 2 % are summarised to “Others”.
- The plot was inspired by an example given in the Matplotlib documentation (http://matplotlib.org/examples/pie_and_polar_charts/pie_demo_features.html).
- In this subsection, the library “matplotlib” is needed, too.
- Three timelines for the publications of the genes KRAS, BRCA2, and CDKN2A are shown in one bar chart.
- Running “create_bar_chart.py -p” generates the figure “KRAS_BRCA2_CDKN2A_pubmed.png”. The year 2015 cannot be considered as a complete year. Therefore, it is removed by this script before plotting.
- The CSV files processed by this script can be downloaded from PubMed by clicking on the bar chart appearing on http://www.ncbi.nlm.nih.gov/pubmed after entering the query (15th June 2015). The title lines in these CSV files were removed manually.
- All CSV files used in this subsection are written in comma-separated format.
Running “python get_years.py” generates the same kind of CSV files as provided by the browser search, but it uses the pancreatic cancer data set from this documentation by sending a query to the PubMedPortable PostgreSQL database.
- Running this script with default parameters selects the user-based Xapian folder “full_text_index_title_text”, but it can also be used with the results file in this documentation to reproduce the plot shown here:
- python get_years.py -x ../../full_text_index/results/results_from_documentation/ -p results.csv
- Based on this, “create_bar_chart.py” without the parameter “-p” generates the bar chart “KRAS_BRCA2_CDKN2A.png”.
- The slopes of the BRCA2 and CDKN2A timelines are rather low compared to KRAS, but start earlier in both plots. The timeline of the gene KRAS shows an exponential growth. One reason for this is its role in the regulation of cell proliferation [Small molecule inhibition of the KRAS-PDEδ interaction impairs oncogenic KRAS signalling. Zimmermann et al. Nature. 2013 May 30;497(7451):638-42. doi: 10.1038/nature12205. Epub 2013 May 22.].
- The review on OMIM mentioned in section 5 (http://omim.org/entry/260350?search=%22pancreatic%20cancer%22) provides more information with references showing why and how specific these genes are related to pancreatic cancer.
Follow the installation instructions on this GitHub page:
The file “pmid_list.txt” contains 21 PubMed-IDs that were taken from “PubMedPortable/data/pubmed_result.txt”. It is used as default by the script “write_BioC_XML.py”.
- The user can store his own list of PubMed-IDs in “pmid_list.txt” or create a new file. This user-provided list of PubMed-IDs can be loaded with the parameter “-i”.
- New PubMed-IDs can be selected from the PubMedPortable PostgreSQL tables, e.g. pubmed.tbl_abstract, pubmed.tbl_medline_citation, or pubmed.tbl_mesh_heading.
PubTator can be used as a webservice in several ways. There is a website highlighting entities like genes/proteins, chemical compounds, diseases, mutations, and species. This website can be used for text curation:
There is also a RESTful API:
How to use this API is shown by the following command executed via command-line:
curl -H “content-type:application/json” http://www.ncbi.nlm.nih.gov/CBBresearch/Lu/Demo/RESTful/tmTool.cgi/Disease/1000475,1006519,1010707/BioC/ > text_PubTator.xml
- All output files in this section refer to these three PubMed-IDs. The maximum number of PubMed-IDs to send to PubTator in this case was 21. This is the reason why “pmid_list.txt” contains exactly 21 PubMed-IDs.
The script “call_PubTator.py” wraps this command with the Python module “subprocess” and downloads PubMed BioC XML annotated abstracts from PubTator.
- It contains the parameter “-t” (trigger) that selects the type of entity to be tagged (default: Disease) for a list of PubMed-IDs (default: pmid_list.txt).
- All parameters of this script can be shown with “python call_PubTator.py -h”.
The default output file “text_PubTator.xml” also shows the MeSH IDs for the extracted diseases, e.g. “pancreatic carcinoma”, the first one in the example file:
- PubTator returns two types of infon elements. Therefore, the line “<!ELEMENT annotation ( infon*, location*, text ) >” had to be changed to “<!ELEMENT annotation ( infon*, location*, text, infon* ) >”.
If you want to add MeSH term annotations from the PostgreSQL to the file “text_PubTator.xml”, you can run the command “python add_BioC_annotation.py -i text_PubTator.xml -o annotated_text_PubTator.xml”.
- MeSH terms refer to several types of entities. In this case, some of the MeSH terms will show duplicate disease annotation elements.
All these entities can also be tagged in BioC XML format from plain text input via the single software packages referenced here below “Quick Links”:
They are described in the following PDF file as well as other software packages in chapter “TRACK 1 (BioC: Interoperability)”:
- http://www.biocreative.org/media/store/files/2013/ProceedingsBioCreativeIV\_vol1\_.pdf
- There are also other webservices included as well as BioC natural language preprocessing pipelines in C++ and Java (http://bioc.sourceforge.net).
PubTator can be used to completly extract genes, diseases, and chemicals from the pancreatic cancer data set. In the case of diseases and chemicals, there are not always identifiers provided for the recognised synonyms. The following commands lead to a new word cloud based on the 150 most frequently occurring entities:
- Gene and protein NER: python call_PubTator.py -i pubmed_result_complete.txt -o gene_complete.csv -t Gene -f PubTator
- Disease NER: python call_PubTator.py -i pubmed_result_complete.txt -o disease_complete.csv -t Disease -f PubTator
- Chemical NER: python call_PubTator.py -i pubmed_result_complete.txt -o chemical_complete.csv -t Chemical -f PubTator
- File concatenation: cat gene_complete.csv disease_complete.csv chemical_complete.csv > entities_complete.csv
- Get PubMed IDs, synonyms, and identifieres: python results_PubTator_format.py -i entities_complete.csv -o entities_formatted_identifiers.csv
- Count entities, summarised by their identifiers: python unify.py -i entities_formatted_identifiers.csv -o entities_formatted_identifiers_unified.csv
- Generate logarithmic values (first 150 entities): python get_search_terms_log.py -x ../../BioC_export/results_from_documentation -i entities_formatted_identifiers_unified.csv -o counts_entities_identifiers_log.csv
- Create word cloud: python create_word_cloud.py -i counts_entities_identifiers_log.csv -o cloud_entities_identifiers.png
- This example is based on selecting one synonym per identifier. The script “results_PubTator_format.py” can be used with the parameter “-s” to extend the selection to all synonyms without using the identifiers. In this case, the step of using the script “unify.py” needs to be replaced with the script “summary.py” in the Xapian folder “full_text_index”.
The bar chart shown with manually selected search terms can also be produced with the automatically identified entities from PubTator introduced in this section:
- python get_years.py -x ../../BioC_export/results_from_documentation/ -p entities_formatted_identifiers.csv -t Entrez_GeneID/search_terms_KRAS.txt -o KRAS
- python get_years.py -x ../../BioC_export/results_from_documentation/ -p entities_formatted_identifiers.csv -t Entrez_GeneID/search_terms_BRCA2.txt -o BRCA2
- python get_years.py -x ../../BioC_export/results_from_documentation/ -p entities_formatted_identifiers.csv -t Entrez_GeneID/search_terms_CDKN2A.txt -o CDKN2A
- python merge.py
- python create_bar_chart.py
- Based on the search for a larger vocabulary from PubTator using Entrez GeneID numbers, CDKN2A shows more hits than BRCA2 and the identified numbers of abstracts are generally higher.
The same steps as performed with PubTator can be performed with other tools, too.
The disease annotation step can be replaced by the stand-alone application DNorm from the tmBioC package (http://www.ncbi.nlm.nih.gov/CBBresearch/Lu/Demo/tmTools/ - link to DNorm):
- Write BioC document from pancreatic cancer data set (BioC directory): “python write_BioC_XML.py -i pubmed_result.txt -o pancreatic_cancer_BioC.xml”
- Add DNorm annotatons (in download directory): ./RunDNorm_BioC.sh config/banner_NCBIDisease_TEST.xml data/CTD_diseases.tsv output/simmatrix_NCBIDisease_e4.bin pancreatic_cancer_BioC.xml pancreatic_cancer_BioC_DNorm.xml
- This command can be used to create the “file pancreatic_cancer_BioC_DNorm.xml” (not uploaded).
- The script “read_BioC_annotations.py” shows the basic commands how to iterate over MeSH term annotations in BioC format from the example mentioned earlier, using PubMedPortable and PubTator.
- The script “BioC_to_CSV.py” is based on the code in “read_BioC_annotations.py” and extracts the DNorm annotations in “file pancreatic_cancer_BioC_DNorm.xml” to a CSV file “DNorm_formatted.csv (not uploaded). The script needs the DNorm DTD file (in the DNorm download directory). Copy it to you execution folder and rename it to”BioC_DNorm.dtd". If this file causes an error in the PyBioC API, replace the raise command in bioc/bioc_reader.py by a print command.
- Genes and proteins can be annotated with GeneTUKit, a software for gene normalisation which was ranked among the best-performing tools in the BioCreative III challenge in 2010.
- Unfortunately, the source code is not available, but there is a GitHub repository wrapping PubMedPortable articles into a pseudo XML format used by the software (https://github.com/ElhamAbbasian/GeneTUKit-Pipeline).
- Using the list of PubMed IDs from the PubMedPortable documentation and following the first three steps in the GeneTUKit pipeline generates a file pmid_geneid_syn.csv.
- For the output format used to generate the word cloud, the orginal line to write the output in the script filter_out_genetukit_output.py can be changed to ‘outfile.write(pmid + “t” + temp[1].split(“|”)[0] + “t” + temp[0] + “n”)’. Multiple synonyms with the same Entrez Gene-ID number are separeted with a pipe (“|”) and only the first synonym is needed for the task here. Furthermore, the order from the file name “PubMed-ID-GeneID-Synonym” is changed to “PubMed-ID-Synonym-GeneID” by exchanging the elements temp[0] and temp[1].
After file concatenation (single files not uploaded: cat GeneTUKit_formatted.csv DNorm_formatted.csv chemical_formatted.csv > entities_complete_3tools.csv), the steps to generate the word cloud can be executed as already described in the PubTator example.
- python unify.py -i entities_complete_3tools.csv -o entities_complete_3tools_unified.csv
- get_search_terms_log.py -x ../../BioC_export/results_from_documentation -i entities_complete_3tools_unified.csv -o counts_entities_identifiers_log_3tools.csv
- create_word_cloud.py -i counts_entities_identifiers_log_3tools.csv -o cloud_3tools.png
The same is possible for the bar chart example.
- The Entrez GeneID numbers were extracted from the file GeneTUKit_formatted.csv with the script get_search_term_identifiers.py (KRAS gene example hard-coded).
- This has to be done with the other two genes CDKN2A and BRCA2, too. The steps “python merge.py” and “python create_bar_chart.py” lead to the new bar chart “KRAS_CDKN2A_BRCA2.png”, manually renamed to “KRAS_CDKN2A_BRCA2_3tools.png” to be distinguishable from the PubTator example.
- This approach leads to a higher number of publications for each gene, but shows basically the same tendencies as in the PubTator example.
- The example of using PubTator, DNorm, and GeneTUKit illustrates, that the infrastructure of PubMedPortable can be easily extended to combine different data formats (PubTator, BioC, and pseudo XML format), being independent from a Web service, but making use of it, if desired.
Explanations for the PMC FTP service can be found here:
The approach can be extended with a PMC XML parser, e.g. this one:
Create a directory files in your PMC folder in the GitHub project and download the 4 PMC article archives, if you want to index all of them as shown here for the first gzip file:
Unzip the files and remove the source files:
- gunzip articles.txt.0-9A-B.tar.gz
- tar -xf articles.txt.0-9A-B.tar
- rm articles.txt.0-9A-B.tar
Download the mapping of PMC IDs to PubMed IDs in your PMC folder:
- wget ftp://ftp.ncbi.nlm.nih.gov/pub/pmc/PMC-ids.csv.gz
- gunzip PMC-ids.csv.gz
Create a table tbl_pmcid_name_pmid in your PostgreSQL schema public:
- psql -h localhost -d pancreatic_cancer_db -U parser -f create_pmcid_pmid_table.sql
Insert PMC ID mapping in your PostgreSQL database with PubMed IDs, if contained (not all PMC IDs will contain a PubMed ID mapping - nevertheless, it can be checked whether the PubMed ID is referenced to a PMC ID with this table):
- python insert_PMC_ID_PubMed_ID_mapping.py
If you want to count the number of uploaded PMC IDs, use the following command, e.g. in PGAdmin:
- select count(*) from tbl_pmcid_pmid;
Insert PMC ID mapping from file_list.txt, which also contains the file names from the downloaded archives:
- psql -h localhost -d pancreatic_cancer_db -U parser -f create_pmcid_name_pmid_table.sql
- python insert_PMC_ID_Name_PubMed_ID_mapping.py
Check the total number of downloaded text files from the archives. This number will be much smaller than the number of PMC IDs in tbl_pmicid_pmid:
- select count(*) from tbl_pmcid_name_pmid;
Build the Xapian index - this might take a few hours in total, depending on the following options. Create a folder xapian first:
- mkdir xapian
- Set the boolean flag of the variable use_psql to True in line 35 in index.py (default is True) if you want to store your PMC texts in the PostgreSQL table tbl_pmcid_text, otherwise an extra Xapian data field will be used to save the file content, e.g. to read it after receiving search results.
If you want to use the PostgreSQL database, create the table tbl_pmcid_text first:
- psql -h localhost -d pancreatic_cancer_db -U parser -f create_pmcid_text_table.sql
- The indexing process for the first of four files took over an hour with one CPU core (2,83 GHz and 8 GB RAM). Setting use_psql to True or False resulted in a similar runtime.
- python index.py
Before the index can be used completely, it has to be merged with the compact-tool already mentioned earlier in this documentation. The following command will generate a folder xapian_PMC_complete in your PMC directory:
- python generate_xapian_compact_command.py
- It is also possible to include only some selected journals in the search by using the IDs generated during the indexing process (ids.txt).
To search in the index with showing identified texts, run the following script with the parameter use_psql set to True (default case, line 24) and verbose set to True (default False, line 22). Create a result directory first. Similar to the already described search procedure in the Xapian chapter of this documentation, a list of synonyms can be used (synonyms/synonyms.txt):
- search.py
- This script rather serves as a guidline how to get the search results and should be adapted to the methods already described.
| Tool Name | Entities | Availability | Authors |
|---|---|---|---|
| GNormPlus | genes/proteins | stand-alone tool and web service | Wei et al., 2015 |
| DNorm | diseases/species/taxonomy | stand-alone tool and web service | Leaman et al., 2013 |
| tmChem | drugs/chemicals | stand-alone tool and web service | Leaman et al., 2014 |
| tmVar | mutations/diseases | stand-alone tool and web service | Wei et al., 2013 |
| SR4GN | species/genes | stand-alone tool and web service | Wei et al., 2012 |
| GNAT | genes/proteins | stand-alone tool and web service | Hakenberg, J. et al. 2010 |
| LINNAEUS | species/taxonomy | stand-alone tool and web service | Gerner et al., 2010 |
| TaxonGrab | species/taxonomy | stand-alone tool | Moritz et al., 2005_ |
| Whatizit | species/taxonomy | web service | Rebholz-Schuhmann et al., 2008 |
| MutationFinder(BioNLP) | mutations | standalone tool | Caporaso et al., 2007 |
| CTD | genes/proteins/chemicals/protein interactions | web service | Wiegers et al., 2014 |
| Reflect | proteins/chemicals | stand-alone tool and web service | Pafilis et al., 2009 |
| TaggerOne | chemicals/diseases | web service | Leanman et al., 2016 |
| CD-REST | chemicals/diseases | web service | Xu et al., 2016 |
To illustrate this modularity, we created a minimalistic indexing and searching example. The examples were inspired by the following sources:
- IndexFiles.py, SearchFiles.py, and FacetExample.py in http://svn.apache.org/viewvc/lucene/pylucene/trunk/samples
- http://graus.co/blog/pylucene-4-0-in-60-seconds-tutorial
- http://blog.intelligencecomputing.io/tags/pylucene
Install the following packages using the official Ubuntu sources (“apt-get install” or “sudo synaptic”).
- jcc
- python-all-dev
If the Ubuntu default package “jcc” does not work, try the following steps (as described in the official documentation).
- svn jcc
- pushd jcc (changes into your jcc directory)
- edit your java path if your receive an error (e.g. ‘linux2’: ‘/usr/lib/jvm/java-8-openjdk-amd64’,)
- python setup.py build
- sudo python setup.py install
- popd
Change into unzipped directory and edit Makefile by deleting the comment characters in lines 93-97:
PREFIX_PYTHON=/usr
ANT=JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64 /usr/bin/ant
PYTHON=$(PREFIX_PYTHON)/bin/python
JCC=$(PYTHON) -m jcc –shared
NUM_FILES=8
Execute the following commands in your terminal (in the PyLucene folder):
- make
- make test (any errors?)
- sudo make install
The option “Field.Store.YES” can be considered analogously to the Xapian option “xappy.FieldActions.STORE_CONTENT” in PubMedXapian.py.
- Enabling this option means, that you can inspect the source of your matching document directly.
- This increases your index size. Alternatively, you can query the sources from your PostgreSQL database.
You should see the following output:
Searching for ‘text’ with OR two match both documents:
2 total matching documents.
title: text of title1 , abstract: abstract1 has many words, e.g. hellow world can be the text
title: title2 , abstract: text of abstract2
Searching for ‘text’ with OR two match only the first document:
1 total matching documents.
title: text of title1 , abstract: abstract1 has many words, e.g. hellow world can be the text
Please, write an e-mail, if you have questions, feedback, improvements, or new ideas:
If you are interested in related projects, visit our working group’s homepage:


---
layout: post
title: 11/16 schoolwork
date: '2013-11-17T21:38:00.000-07:00'
author: Jacob .
tags:
- homeschool-journal
modified_time: '2013-11-17T22:06:33.070-07:00'
blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-8643858017556279031
blogger_orig_url: http://www.svlark.com/2013/11/1116-schoolwork.html
---
Audrey


?6
7
8
9
10
T
XT
v
The
New
York
copyright
reserved
Botanical
Garden
P£RE
DUSS,
IIERBIER
DE
LA
MARTINIQUE.
t7//ÀÀÀtuioo
?'
<
_
jw
UNITED
STATES
NATIONAL
HERBARIUM
Olyra
latifolia
L.
dd
T.R
Soderstrofn
&
F
0
Zuloaga.
Aug
1983
1604203
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Alaska police officer pleads not guilty to assault charges
ANCHORAGE, Alaska (AP) - An Alaska police officer has pleaded not guilty to charges of assaulting a man while on duty in September, court officials said.
Prosecutors have accused Anchorage Officer Cornelius Aaron Pettus, 32, of punching and kicking 49-year-old Sam Allen, Anchorage Daily News reported Friday.
Pettus was charged with two counts of fourth-degree assault Oct. 11, according to court documents. The Class A misdemeanor could carry up to one year in jail and a fine of up to $10,000.
TOP STORIES
George Soros group asks Fox News to ban guest who claimed billionaire controls State Dept.
Franklin Graham calls on nation to pray for Trump as impeachment effort gains speed
Nancy Pelosi goes for slam dunk -- and crashes to court
Pettus and another officer gave Allen a bicycle citation Sept. 30 before the suspected attack, prosecutors said.
Some department officers were believed to be familiar with Allen because of his YouTube account detailing interactions he had with police and uploaded cellphone footage of the encounters, Anchorage Police Chief Justin Doll said after the charges were announced.
Doll was unsure if Pettus or the other officer knew Allen before giving him the citation, he said.
“Officer Pettus disputes the charges and intends to exercise his rights to confront the State’s evidence,” defense attorney Clinton Campion said. Pettus responded in self-defense “based on what (he) perceived and knew at the moment of the incident,” she said.
Allen told reporters Friday after arraignment that he is still healing from his injuries.
“I forgive the dude. In my heart, I’m trying to. I’m in the process of doing that so I can move forward,” Allen said.
Pettus remains on paid administrative leave pending the results of the police department’s own internal investigation, police spokesman MJ Thim said in an email.
Information from: Anchorage Daily News, http://www.adn.com
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Zika women Health health participants transmission dengue reported []. practices virus sexual {border-style study Iquitos knowledge px;} risk #ffffff;} FGD Iquitos, Zika, focus regarding Medicine Sciences group neurological research symptoms mosquito pregnant preventative use ():–. Aedes associated family including knowledge, FGDs knew local prevent severity used Peru Tropical Virus community information perceived prevention preventive promotion team Peru. Trop attitudes, education groups px; qualitative {font-family Zika. common described expressed font-size higher like mentioned participant preventing reproductive review transmission, transmitted vector FGDs, Participants Pathogens Public asked attitudes campaigns cases concern control data did district double; findings household members possible similar themes using Biology Brazil Diseases MorrisonAC, New Women [Internet]. [], [cited aegypti age border-color border-width children condoms consent fatalism felt fetal included infection informed low main planning role sex solid; studies suggested survey symptoms, {font-style {font-weight ;():–. Amazon Data Dengue Despite Dis. Diseases: Flaviviruses: Knowledge Negl Punchana Research Viral World based bold changed childbearing communities completed condom conducted confirmed contact courier; discuss discussions disease educational em; focused fumigation general high impact improve infected know men messages method methods microcephaly mild observed original potential practices, presence primarily provided pt;} region risks said, share specific time transmission. treatment verbal viral virus, virus. water women’s


The page you were looking for was not found, please keep calm and contact our team for assistance or come again later. Sorry for the trouble.
The page you were looking for was not found, please keep calm and contact our team for assistance or come again later. Sorry for the trouble.


Geometric Figures
This is the first Practical JS course's workshop
Calculate the area and perimeter of a square
Type the measure of the square's side:
Calculate perimeter
Calculate area
Calculate the area and perimeter of a Triangle
Type the measure of the triangle's side 1:
Type the measure of the triangle's side 2:
Type the measure of the triangle's side 3:
Calculate perimeter
Calculate the area and perimeter of a Cicle
Type the measure of the circle's radius:
Calculate perimeter
Calculate Area


Promise and asynchronous observer libraries, as well as hand-rolled callback
programs and libraries, often need a mechanism to postpone the execution of a
callback until the next available event.
(See Designing API’s for Asynchrony.)
The asap
function executes a task as soon as possible but not before it
returns, waiting only for the completion of the current event and previously
scheduled tasks.
asap(function () {
// ...
});
This CommonJS package provides an asap
module that exports a function that
executes a task function as soon as possible.
ASAP strives to schedule events to occur before yielding for IO, reflow, or redrawing. Each event receives an independent stack, with only platform code in parent frames and the events run in the order they are scheduled.
ASAP provides a fast event queue that will execute tasks until it is empty before yielding to the JavaScript engine's underlying event-loop. When a task gets added to a previously empty event queue, ASAP schedules a flush event, preferring for that event to occur before the JavaScript engine has an opportunity to perform IO tasks or rendering, thus making the first task and subsequent tasks semantically indistinguishable. ASAP uses a variety of techniques to preserve this invariant on different versions of browsers and Node.js.
By design, ASAP prevents input events from being handled until the task
queue is empty.
If the process is busy enough, this may cause incoming connection requests to be
dropped, and may cause existing connections to inform the sender to reduce the
transmission rate or stall.
ASAP allows this on the theory that, if there is enough work to do, there is no
sense in looking for trouble.
As a consequence, ASAP can interfere with smooth animation.
If your task should be tied to the rendering loop, consider using
requestAnimationFrame
instead.
A long sequence of tasks can also effect the long running script dialog.
If this is a problem, you may be able to use ASAP’s cousin setImmediate
to
break long processes into shorter intervals and periodically allow the browser
to breathe.
setImmediate
will yield for IO, reflow, and repaint events.
It also returns a handler and can be canceled.
For a setImmediate
shim, consider YuzuJS setImmediate.
Take care. ASAP can sustain infinite recursive calls without warning. It will not halt from a stack overflow, and it will not consume unbounded memory. This is behaviorally equivalent to an infinite loop. Just as with infinite loops, you can monitor a Node.js process for this behavior with a heart-beat signal. As with infinite loops, a very small amount of caution goes a long way to avoiding problems.
function loop() {
asap(loop);
}
loop();
In browsers, if a task throws an exception, it will not interrupt the flushing
of high-priority tasks.
The exception will be postponed to a later, low-priority event to avoid
slow-downs.
In Node.js, if a task throws an exception, ASAP will resume flushing only if—and
only after—the error is handled by domain.on("error")
or
process.on("uncaughtException")
.
Checking for exceptions comes at a cost.
The package also provides an asap/raw
module that exports the underlying
implementation which is faster but stalls if a task throws an exception.
This internal version of the ASAP function does not check for errors.
If a task does throw an error, it will stall the event queue unless you manually
call rawAsap.requestFlush()
before throwing the error, or any time after.
In Node.js, asap/raw
also runs all tasks outside any domain.
If you need a task to be bound to your domain, you will have to do it manually.
if (process.domain) {
task = process.domain.bind(task);
}
rawAsap(task);
A task may be any object that implements call()
.
A function will suffice, but closures tend not to be reusable and can cause
garbage collector churn.
Both asap
and rawAsap
accept task objects to give you the option of
recycling task objects or using higher callable object abstractions.
See the asap
source for an illustration.
ASAP is tested on Node.js v0.10 and in a broad spectrum of web browsers. The following charts capture the browser test results for the most recent release. The first chart shows test results for ASAP running in the main window context. The second chart shows test results for ASAP running in a web worker context. Test results are inconclusive (grey) on browsers that do not support web workers. These data are captured automatically by Continuous Integration.
When a task is added to an empty event queue, it is not always possible to guarantee that the task queue will begin flushing immediately after the current event. However, once the task queue begins flushing, it will not yield until the queue is empty, even if the queue grows while executing tasks.
The following browsers allow the use of DOM mutation observers to access the HTML microtask queue, and thus begin flushing ASAP's task queue immediately at the end of the current event loop turn, before any rendering or IO:
In the absense of mutation observers, there are a few browsers, and situations like web workers in some of the above browsers, where message channels would be a useful way to avoid falling back to timers. Message channels give direct access to the HTML task queue, so the ASAP task queue would flush after any already queued rendering and IO tasks, but without having the minimum delay imposed by timers. However, among these browsers, Internet Explorer 10 and Safari do not reliably dispatch messages, so they are not worth the trouble to implement.
In the absense of mutation observers, these browsers and the following browsers
all fall back to using setTimeout
and setInterval
to ensure that a flush
occurs.
The implementation uses both and cancels whatever handler loses the race, since
setTimeout
tends to occasionally skip tasks in unisolated circumstances.
Timers generally delay the flushing of ASAP's task queue for four milliseconds.
ASAP has been factored out of the Q asynchronous promise library.
It originally had a naïve implementation in terms of setTimeout
, but
Malte Ubl provided an insight that postMessage
might be
useful for creating a high-priority, no-delay event dispatch hack.
Since then, Internet Explorer proposed and implemented setImmediate
.
Robert Katić began contributing to Q by measuring the performance of
the internal implementation of asap
, paying particular attention to
error recovery.
Domenic, Robert, and Kris Kowal collectively settled on the current strategy of
unrolling the high-priority event queue internally regardless of what strategy
we used to dispatch the potentially lower-priority flush event.
Domenic went on to make ASAP cooperate with Node.js domains.
For further reading, Nicholas Zakas provided a thorough article on The Case for setImmediate.
Ember’s RSVP promise implementation later adopted the name ASAP but
further developed the implentation.
Particularly, The MessagePort
implementation was abandoned due to interaction
problems with Mobile Internet Explorer in favor of an
implementation backed on the newer and more reliable DOM MutationObserver
interface.
These changes were back-ported into this library.
In addition, ASAP factored into asap
and asap/raw
, such that asap
remained
exception-safe, but asap/raw
provided a tight kernel that could be used for
tasks that guaranteed that they would not throw exceptions.
This core is useful for promise implementations that capture thrown errors in
rejected promises and do not need a second safety net.
At the same time, the exception handling in asap
was factored into separate
implementations for Node.js and browsers, using the the Browserify browser
property in package.json
to instruct browser module loaders
and bundlers, including Browserify, Mr, and Mop, to use the
browser-only implementation.
Copyright 2009-2014 by Contributors MIT License (enclosed)


1970
☰
FSI
GDP
Inflation
Trade
Population
Employement
Reserve
FDI
Major Incidents
×
This day that year
Major
×


5
1 On that day Deborah and Barak (the son of Abinoam) sang this song:
2 "When the leaders take the lead in Israel,
when the people gladly volunteer for war—
we praise Yahweh!
3 Listen, you kings! Pay attention, you leaders!
I, I will sing to Yahweh;
I will sing praises to Yahweh, the God of Israel.
4 Yahweh, when you went out from Seir,
when you marched from Edom,
the earth shook, and the skies also trembled;
also the clouds poured down water.
5 The mountains quaked before the face of Yahweh;
even Mount Sinai quaked before the face of Yahweh, the God of Israel.
6 In the days of Shamgar (son of Anath),
in the days of Jael, the main roads were abandoned,
and those who walked only used the winding paths.
7 There were no peasants in Israel,
until I, Deborah, took command—
a mother took command in Israel!
8 They chose new gods,
and there was fighting at the city gates;
neither shields nor spears were seen
among forty thousand in Israel.
9 My heart goes out to the commanders of Israel,
along with the people who gladly volunteered—
we bless Yahweh for them!
10 Think about this—you who ride on white donkeys
sitting on rugs for saddles,
and you who walk along the road.
11 Hear the voices of those who divide up the sheep between the watering places.
There they tell again of Yahweh's righteous deeds,
and the righteous actions of his warriors in Israel.
Then the people of Yahweh went down to the city gates.
12 Awake, awake, Deborah!
Awake, awake, sing a song!
Get up, Barak, and capture your prisoners, you son of Abinoam.
13 Then the survivors came down to the nobles—
the people of Yahweh came down to me among the warriors.
14 They came from Ephraim, whose root is in Amalek;
the people of Benjamin followed you.
From Machir commanders came down,
and from Zebulun those who carry an officer's staff.
15 And my princes in Issachar were with Deborah;
and Issachar was with Barak
rushing after him into the valley under his command.
Among the clans of Reuben
there were great searchings of heart.
16 Why did you sit between the fireplaces,
listening to the shepherds playing their pipes for their flocks?
As for the clans of Reuben
there were great searchings of heart.
17 Gilead stayed on the other side of the Jordan;
and Dan, why did he wander about on ships?
Asher remained on the coast
and lived close to his harbors.
18 Zebulun was a tribe who would risk their lives to the point of death,
and Naphtali, also, on the field of battle.
19 Kings came and fought,
then the kings of Canaan fought, at Taanach
by the waters of Megiddo.
But they took away no silver as plunder.
20 From heaven the stars fought,
from their paths across the heavens they fought against Sisera.
21 The Kishon River swept them away,
that old river, the Kishon River.
March on my soul, be strong!
22 Then the sound of horses' hooves—
galloping, the galloping of his mighty ones.
23 'Curse Meroz!' says the angel of Yahweh.
'Surely curse its inhabitants!—
because they did not come to help Yahweh—
to help Yahweh in the battle against the mighty warriors.'
24 Jael is blessed more than all other women,
Jael (the wife of Heber the Kenite),
she is more blessed than all the women who live in tents.
25 The man asked for water, and she gave him milk;
she brought him butter in a dish fit for princes.
26 She put her hand to the tent peg,
and her right hand to the workman's hammer;
with the hammer she struck Sisera, she crushed his head.
She smashed his skull into pieces when she pierced him through the side of his head.
27 He collapsed between her feet, he fell and he lay there.
Between her feet he fell limp.
The place he collapsed is where he was violently killed.
28 Out of a window she looked—
the mother of Sisera looked through the lattice and she called out in sadness,
'Why has it taken his chariot so long to come?
Why have the hoofbeats of the horses that pull his chariots been delayed?'
29 Her wisest princesses replied,
and she gave herself the same answer:
30 'Have they not found and divided up the plunder?
—A womb, two wombs for every man;
the plunder of dyed fabric for Sisera,
the plunder of dyed fabric embroidered,
two pieces of dyed fabric embroidered for the necks of those who plunder?'
31 So may all your enemies perish, Yahweh!
But let those who love him be like the sun when it rises in its might."
And the land had peace for forty years.


See: Description
| Class | Description |
|---|---|
| ArrivalTerminalExit |
Arrival Terminal Exit ientity
|
| ArrivalTerminalTransfer |
Arrival Terminal Transfer Quay shared memory
|
| BaggageCollectionPoint |
Conveyor Belt shared memory entity
|
| BaggageReclaim |
Luggage reclaim office shared memory entity
|
| DepartureTerminalEntrance |
Departure Terminal Entrance shared memory entity
|
| DepartureTerminalTransfer |
Departure Terminal Transfer Quay shared memory entity
|
| GeneralRepository |
General repository of information for the rhapsody
Here lies the data that is general to all and will be logged, like flightId, luggage on plane,
passenger type and the real age fo the earth according to the holy bible.
|
| Lounge |
Lounge datatype implements the Arrival Lounge shared memory region.
|
| StoreRoom |
Storeroom shared memory entity
|


I apoligise if the following does not make sense, as I wrote it while I was 'tripping'. In fact it was extremely difficult to read the words on my laptop. While this is not my first trip, it was definitely the most intense.
I am currently “high” on hallucinogenic mushrooms, and as I sit, watching the letters I have written bend and distort, I will make a rudimentary account of the passing hours. This is a unique experience, as I am attempting to explain with words of another existence, the happenings of this one. Shrooms are fun. I feel as though, starting at 9:00 P.M, my mind has been on a steady downward spiral. Slowly after taking the shrooms, my mind has begun to lose grip on all of the things that made its foundations. Everything is reduced to it’s most simple. Slowly my mind was reduced to: sit, smoke, feel, watch, etc. with each action that I undertook requiring extreme introspection. For example, “Weed, I smoke this and I feel high, happy without reason. Shrooms, these things made me feel like I do right now. But I cant explain how I feel. All I know is what is before me”.
I am reduced to carnal instincts, all other things, such as walking, require extreme thought. So everything else, such as being in college, love, money, life, everything is COMPLETELY out of the reach of my now hollowed thoughts. All of this occurring in the span of seconds. My mind commences on this trail, losing hold off all formerly held for granted, until It reached a “peak.” A point at which I honestly think I knew nothing. It was as if my mind had been removed, and my spirit is left to watch the chaos ensue. To be honest the entire experience up to that point was depressingly horrid. My mind fighting against this poison that I in took to stop it’s function. My mind felt devoid of thought, as clearly as lungs feel devoid air. I am watching a clock, every second knowing less than I did the second before. I am my mind reduced to nothing .
All the while I feel as though I have a companion, some THING there watching all I do, answering all I ask myself, giving me guidance. After returning to my room at 1am, I feel the loss well, recede. As the tide leaves the beach, is gone, and then returns. My mind is between losing and gaining. Learning and forgetting, thinking and remembering.
2:00 a.m., apparently, after an hour I started to learn. I realized that I could see whatever I imagined. I remember now a point, between 10:00 and 12:00 that my reality collapsed. I remember watching as my physical/spiritual/mental/logical functions are reduced to nothing. My mind paralyzed. I remember watching, literally, as my world caves in around itself. Knowing nothing and not being able to explain the absence. But after that I began to learn.
The poison released it’s grip on my mind, my mind grasping at every new piece of information it encountered. Going from nothing, and confusion. To realizing happiness and nothing else. To feel one’s mind lose everything, and then to gain something good. To literally know nothing but happiness. To be as a baby, a puppy. To see everything for the first time. The first time I walk, eat, think, talk, feel, learn. All happening in the span of hours instead of years. To feel anew, and to feel I gain it all back. Is an awe-inspiring experience for lack of a better word.
So taking shrooms isn’t so much feeling something new. As feeling nothing and feeling anew. Soul. Mind. Mind is removed. Soul exists alone. Mind is dead. Soul remains intact, unchanged. Mind is reborn. Soul watches the rise from nothing to something. If time ceases to exist. And existence ceases to be. And something is left to observe it’s passing. I am that something. My mind was obliterated with a powerful and natural poison that has existed longer than I or my kind.
And was left without. I existed in the lack of existence. I existed in the lack of lacking. I watched as I re-learnt life’s nuances. I watched as my physical world was ripped and devoid of reality. I watched life begin. I watched as logic began. I watched the first yes or no. the first knowledge of such a things existence. I experienced the experience of nothing.
My mind feels thankful for the existence of existence. My soul watching my minds decay. For I have watched myself die. And I have learnt what it is to live. I have watched the demise of time. And I have watched the beginning of knowledge. I have learnt what it is like to be god. And I have been left wanting. This is what it is like to shroom. It is to litteraly witness ones own demise, and to see ones soul re-build. It is to exist for the first time.
Shrooming is committing suicide, being reborn, and seeing existence begin anew. Shrooming is gaining the knowledge of Jesus in the mind of a mortal. Shrooming is an awesome thing to behold. So after killing myself through poison. And being reborn through the same, after learning what it's like to be Jesus, I begin life anew, with the knowledge of a life past to guide me and enough hallucinations to watch the time away.
I am man, reborn. Dark side of the moon is my first song. My first question is that of homosexuality. My first discovery is myself. I feel humble. I think about Dina, my soul feels like a half. I feel my absence, and am reminded that absence makes the heart grow fonder. I understand what it is to be in love, for I understand what it is to not. And I understand that I am neither, and that I am blessed.
I miss Dina, and I relish the knowledge that love is indeed there.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


I provide two services: a post-production for commercial photography and an expertise in technical and artistic aspects of photography. As a post-producer I ca ...
Hey dudes, I'm a highly skilled professional photo/videographer with years of experience in VR 360 panoramic photography (Kolor Autopano Giga | PTGui), VR 360 vi ...
Hi there! I am Beatrice, a creative Graphic Designer and Photographer at bocreativenomad.com, with an eye for qualitative, modern and minimalistic yet efficient ...


We have users!
- aggregate web-enabled initiatives
- brand robust applications
- syndicate vertical web-readiness
- maximize open-source metrics
- extend dot-com architectures
- brand customized experiences
- drive synergistic infrastructures
- seize mission-critical infrastructures
- engineer sticky paradigms


Machine Learn You Some Dota2
Table of Contents
Introduction
The problem is this: We have a Dota2 bot that is becoming increasingly hard to program. Our bot is built with a heuristics based state machine. Each state has a hard coded weight that will give precedence to an action that can be taken that moment. Dota is an incredibly complex game and it is nearly impossible to tell if a change to a weight is beneficial or if the bot just got lucky one game. We need a way to run hundreds of games and get hard data on if the change was beneficial.
Distributed Dota as a service
We need to run a Dota executable multiple times with different bot files to determine which set of weights were the most effective in practice. Docker is the obvious choice. Docker lets us automatically load the game, the bot files, and return the output. Setting up a docker container that grabs the Dota and bot files from the local disk is simple. After some googling and testing we have a way to run a game of Dota and pipe the output to a file.
FROM fedora:latest COPY . /scripts VOLUME /dota CMD sh /scripts/run_game.sh
Parsing Game Logs
Of course Dota couldn't provide nice json files as logs so let's get
to parsing. Dota game logs vary in length but are consistent with
spacing and formatting. For example, if a tower dies the log will
always read: Building: npc_Dota_3_tower destroyed
. Man if only there
were a way to use regular expressions to match lines and grab fields
from those lines.
AWK
Awk is a specific purpose programming language (like wolfram alpha or bison) as opposed to a general purpose programming language (like Lisp or Prolog). This means that awk does one thing, and one thing well; text stream processing. Using GNU Awk we can easily write statement that will write the time a tower dies. Using this as the basis, it is a non issue to implement every other action that can happen throughout the game.
if($0 ~ /Building: npc_Dota_.*_(tower|rax)/){ printf "tower %s died at %d", $2, systime() }
Distributed Dota
We can run multiple games and pipe the nicely formatted output to files. Now we would like to run hundreds of games and use the data from them to create pretty graphs representing how well our bot does. Each docker container runs one game of Dota, uses two cores, and about 1.3 gigs of ram. Since our computers have 8 threads and 8 gigs of ram we can optimally run 4 games at a time. What we would like to do is tell the server to run 100 games and have each computer run up to 4 games in parallel until that 100 game quota is met.
Coroutines Are Cool
We will build our own custom solution in a programming language made for distributed computing. Our general layout will work like this.
Server
The server is informed that 100 games are to be played. The server then starts each worker and opens a http server to listen for requests from each worker. It listens for a START request and replies yes or no depending on if there are still games to be run or not. If it receives a json file instead of a start request it will log it and increment the number of games ran. The server is just smart enough to worry about how many games it is running and how many games it needs to run, nothing else. Load balancing is handled by the worker.
// start http server finished.Add(1) go httpListener() // spin up workers for i, worker := range(workers) { fmt.Printf("Starting worker %s\n", worker) err := startWorker(worker) if err != nil { log.Print(err) } } // wait for every worker to complete their games finished.Wait()
finished
is a wait group meaning that finished.Wait() will block
until every worker has sent back it's json data. We have a wait
group so that our server will not end before the workers have all
sent back their game data.
Worker
The worker is in charge of load balancing it's computer and running
games. When the server is woke it sends MAX_GAMES
requests to the
server, asking to start games. In Go this is easy:
limit := limiter.NewConcurrencyLimiter(MAX_GAMES) done := false for !done { done = limit.Execute(RunGame) time.Sleep(time.Second * 3) // because other computers are slow } limit.Wait()
RunGame
sends a http request to the server and runs a game based on
the response. Since running a docker container/Dota game, blocks until
it has finished running we need to spawn a new process every time we
start a game. Again, in Go this is easy.
Now that we have our server and workers communicating nicely we can run lots of games and generate huge amounts of data.
Machine Learning
As fun as tweaking random bot variables is, it's not very efficient.. for humans. Luckily computers can do boring tasks very fast. Since we have a lack of time and processing power we will use an algorithm that takes less of both.
Genetic Algorithms
Genetic algorithms are a type of machine learning based on random mutations and survival of the fittest. Instead of running the server once and getting a result back, we want that result to be fed back into next round's bots. The new server will work as follows:
For the sake of clarity I'm not explaining the nitty gritty of how genes are selected but if you want to learn more about genetic algorithms Wikipedia has a good article here. Genetic algorithms are just a small taste of machine learning and are still incredibly complicated.
Implementing a genetic algorithm is only as hard as running the server over and over and processing data. In order to process each games data we need to write a function that will go over the logs and generate a fitness score for each hero. A fitness score is a cumulative score of how well the bot did with the new mutated genes. An example fitness function would look something like this:
func CalculateFitness(hero *heroEvaluation) float64 { fitness := 0.0 fitness += hero.winrate * WIN_MOD fitness += hero.killsPerMinute * KPM_MOD fitness += hero.assistsPerMinute * APM_MOD fitness += hero.goldPerMinute * GPM_MOD fitness += hero.deathsPerMinute * DPM_MOD fitness += hero.experiencePerMinute * XPM_MOD return fitness }
Each score would then be added together and given a percentage to be incorporated into the gene pool.
chance := (heroFitness = totalFitness)
And voila, you taught a computer to reproduce.
Conclusion
Writing a Dota bot is not fun. Designing and implementing a distributed, machine learning powered Dota swarm is. The complexity and variance in each little problem means that we were able to help each other solve things we may not have learned in a one dimensional project. From docker, to machine learning, to shell scripting and network administration. I learned a lot about programming and, more importantly, project design and problem solving.


You can review and provide feedback for the local band concert that you recently attended. Below you will find the concerts that took place recently. Feel free to check for more information, and write review, or you can write a review directly from this page.


mutation mutations HIV- KR/SG patients CRF_AE resistance drug virus subtype {border-style double reverse subtypes px;} transcriptase #ffffff;} HIV infected viral []. immunodeficiency using mutant study susceptibility type human replication detected failed fitness natural role various associated non-B used DRMs data gene increased input patients, phenotypic pol polymorphisms protease px; quasispecies studies treatment {font-family HIV-. RTI-treated analyzed development font-size frequency interpretation mutants polymorphism sequencing treatment. . ± ., ART Agents China Drug However, Medical PCR analysis assay double; file high individuals mutation. post quality respectively. ART, Affiliated CRF_AE-infected DNA Moreover, RNA University association border-color border-width change different genes increase kit obtained occurred occurrence patient patients. performed plasmid prevalence prior rate resistance. solid; stocks strains time {font-style {font-weight (n = ,), AZT, Additional CA, HIV-, Hospital NRTI Resistance Stanford Table amplified bold carrying clone. combination compared compensatory competition conducted courier; demonstrated em; experiments fidelity infectious information inhibitor manuscript. minimum molecular new next-generation nucleoside observed plasma polymerase produce provided pt;} recombinant reported significantly strain strains. suggested temporal viruses wild-type months – months


These fields are used by the Remote File System Driver to describe the machine to other machines that wish to access its drives. You may specify a name for the machine by which others may identify it and also set up communications parameters.
baudRate = <number>
This
SerialBaud
value defines the communication speed this machine supports for RFSD.
baudRate = <list of drives>
Normally, all of your drives will be accessible by the remote machine. This field allows you to specify exactly which drives are accessible. For instance, to restrict remote machines to accessing your C: and E: drives, use the following entry:
drives = { C: E: }
name = <machine name>
A string by which remote machines may identify you. When the remote machine sees your drives, their names will be <machine-name>-<drive-letter>:.
port = <SerialPortNum>
This number specifies which serial port is to be used for RFSD.


Messenger connector handover protocol model
AppRolesWebhook |
data class AppRolesWebhook : Webhook |
PassThreadControl |
data class PassThreadControl |
PassThreadControlRequest |
data class PassThreadControlRequest |
PassThreadControlWebhook |
data class PassThreadControlWebhook : Webhook |
RequestThreadControl |
data class RequestThreadControl |
RequestThreadControlRequest |
data class RequestThreadControlRequest |
RequestThreadControlWebhook |
data class RequestThreadControlWebhook : Webhook |
SecondaryReceiverData |
data class SecondaryReceiverData |
SecondaryReceiverResponse |
data class SecondaryReceiverResponse |
TakeThreadControl |
data class TakeThreadControl |
TakeThreadControlRequest |
See https://developers.facebook.com/docs/messenger-platform/reference/handover-protocol#take. data class TakeThreadControlRequest |
TakeThreadControlWebhook |
data class TakeThreadControlWebhook : Webhook |
ThreadControlRequest |
See https://developers.facebook.com/docs/messenger-platform/reference/handover-protocol. data class ThreadControlRequest |
ThreadOwner |
data class ThreadOwner |
ThreadOwnerData |
data class ThreadOwnerData |
ThreadOwnerResponse |
data class ThreadOwnerResponse |


## Welcome to localstorage-markdown-editor! **localstorage-markdown-editor is the Markdown editor for your local browser.** No signup or installation required. Using the new HTML5 web storage and [Strapdown.js](http://strapdownjs.com/), everything stays inside your local browser - 100% privacy for your data! #### Features * Edit and live preview inside the browser (offline Markdown parsing, no data will be transfered to any server!) * Uses HTML5 local storage (avoids going crazy when accidently closing the browser window!) * Download as Markdown and HTML * Synchronization for multiple windows #### Contributing * Fork me on GitHub * Make some mind-blowing feature changes * Send me a pull request #### License MIT


| Usage | Synopsis |
|---|---|
| General | $ tns build android [--compileSdk <API Level>] [--key-store-path <File Path> --key-store-password <Password> --key-store-alias <Name> --key-store-alias-password <Password>] [--release] [--static-bindings] [--copy-to <File Path>] |
Builds the project for Android and produces an APK that you can manually deploy on device or in the native emulator.
--compileSdk
- Sets the Android SDK that will be used to build the project.--release
- If set, produces a release build. Otherwise, produces a debug build. When set, you must also specify the --key-store-*
options.--key-store-path
- Specifies the file path to the keystore file (P12) which you want to use to code sign your APK. You can use the --key-store-*
options along with --release
to produce a signed release build. You need to specify all --key-store-*
options.--key-store-password
- Provides the password for the keystore file specified with --key-store-path
. You can use the --key-store-*
options along with --release
to produce a signed release build. You need to specify all --key-store-*
options.--key-store-alias
- Provides the alias for the keystore file specified with --key-store-path
. You can use the --key-store-*
options along with --release
to produce a signed release build. You need to specify all --key-store-*
options.--key-store-alias-password
- Provides the password for the alias specified with --key-store-alias-password
. You can use the --key-store-*
options along with --release
to produce a signed release build. You need to specify all --key-store-*
options.--copy-to
- Specifies the file path where the built .apk
will be copied. If it points to a non-existent directory, it will be created. If the specified value is directory, the original file name will be used.<API Level>
is a valid Android API level. For example: 22, 23. For a complete list of the Android API levels and their corresponding Android versions, click here.
--release
flag is set, you must also specify all --key-store-*
options.| Command | Description |
|---|---|
| build ios | Builds the project for iOS and produces an APP or IPA that you can manually deploy in the iOS Simulator or on device, respectively. |
| build | Builds the project for the selected target platform and produces an application package that you can manually deploy on device or in the native emulator. |
| debug android | Debugs your project on a connected Android device or in a native emulator. |
| debug ios | Debugs your project on a connected iOS device or in a native emulator. |
| debug | Debugs your project on a connected device or in a native emulator. |
| deploy | Builds and deploys the project to a connected physical or virtual device. |
| emulate android | Builds the specified project and runs it in a native Android emulator. |
| emulate ios | Builds the specified project and runs it in the native iOS Simulator. |
| emulate | You must run the emulate command with a related command. |
| livesync | Synchronizes the latest changes in your project to devices. |
| livesync ios | Synchronizes the latest changes in your project to iOS devices or the iOS Simulator. |
| livesync android | Synchronizes the latest changes in your project to Android devices. |
| run android | Runs your project on a connected Android device or in a native Android emulator, if configured. |
| run ios | Runs your project on a connected iOS device or in the iOS Simulator, if configured. |
| run | Runs your project on a connected device or in the native emulator for the selected platform. |
| test init | Configures your project for unit testing with a selected framework. |
| test android | Runs the tests in your project on Android devices or native emulators. |
| test ios | Runs the tests in your project on iOS devices or the iOS Simulator. |


| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Appendix E. Release Notes | Next |
Release date: 1997-10-02
A dump/restore is required for those wishing to migrate data from previous releases of PostgreSQL.
This migration requires a complete dump of the 6.1 database and a restore of the database in 6.2.
Note that the pg_dump and pg_dumpall utility from 6.2 should be used to dump the 6.1 database.
Those migrating from earlier 1.* releases should first upgrade to 1.09 because the COPY output format was improved from the 1.02 release.
Bug Fixes --------- Fix problems with pg_dump for inheritance, sequences, archive tables(Bruce) Fix compile errors on overflow due to shifts, unsigned, and bad prototypes from Solaris(Diab Jerius) Fix bugs in geometric line arithmetic (bad intersection calculations)(Thomas) Check for geometric intersections at endpoints to avoid rounding ugliness(Thomas) Catch non-functional delete attempts(Vadim) Change time function names to be more consistent(Michael Reifenberg) Check for zero divides(Michael Reifenberg) Fix very old bug which made rows changed/inserted by a command visible to the command itself (so we had multiple update of updated rows, etc.)(Vadim) Fix for SELECT null, 'fail' FROM pg_am (Patrick) SELECT NULL as EMPTY_FIELD now allowed(Patrick) Remove un-needed signal stuff from contrib/pginterface Fix OR (where x != 1 or x isnull didn't return rows with x NULL) (Vadim) Fix time_cmp function (Vadim) Fix handling of functions with non-attribute first argument in WHERE clauses (Vadim) Fix GROUP BY when order of entries is different from order in target list (Vadim) Fix pg_dump for aggregates without sfunc1 (Vadim) Enhancements ------------ Default genetic optimizer GEQO parameter is now 8(Bruce) Allow use parameters in target list having aggregates in functions(Vadim) Added JDBC driver as an interface(Adrian & Peter) pg_password utility Return number of rows inserted/affected by INSERT/UPDATE/DELETE etc.(Vadim) Triggers implemented with CREATE TRIGGER (SQL3)(Vadim) SPI (Server Programming Interface) allows execution of queries inside C-functions (Vadim) NOT NULL implemented (SQL92)(Robson Paniago de Miranda) Include reserved words for string handling, outer joins, and unions(Thomas) Implement extended comments ("/* ... */") using exclusive states(Thomas) Add "//" single-line comments(Bruce) Remove some restrictions on characters in operator names(Thomas) DEFAULT and CONSTRAINT for tables implemented (SQL92)(Vadim & Thomas) Add text concatenation operator and function (SQL92)(Thomas) Support WITH TIME ZONE syntax (SQL92)(Thomas) Support INTERVAL unit TO unit syntax (SQL92)(Thomas) Define types DOUBLE PRECISION, INTERVAL, CHARACTER, and CHARACTER VARYING (SQL92)(Thomas) Define type FLOAT(p) and rudimentary DECIMAL(p,s), NUMERIC(p,s) (SQL92)(Thomas) Define EXTRACT(), POSITION(), SUBSTRING(), and TRIM() (SQL92)(Thomas) Define CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP (SQL92)(Thomas) Add syntax and warnings for UNION, HAVING, INNER and OUTER JOIN (SQL92)(Thomas) Add more reserved words, mostly for SQL92 compliance(Thomas) Allow hh:mm:ss time entry for timespan/reltime types(Thomas) Add center() routines for lseg, path, polygon(Thomas) Add distance() routines for circle-polygon, polygon-polygon(Thomas) Check explicitly for points and polygons contained within polygons using an axis-crossing algorithm(Thomas) Add routine to convert circle-box(Thomas) Merge conflicting operators for different geometric data types(Thomas) Replace distance operator "<===>" with "<->"(Thomas) Replace "above" operator "!^" with ">^" and "below" operator "!|" with "<^"(Thomas) Add routines for text trimming on both ends, substring, and string position(Thomas) Added conversion routines circle(box) and poly(circle)(Thomas) Allow internal sorts to be stored in memory rather than in files(Bruce & Vadim) Allow functions and operators on internally-identical types to succeed(Bruce) Speed up backend start-up after profiling analysis(Bruce) Inline frequently called functions for performance(Bruce) Reduce open() calls(Bruce) psql: Add PAGER for \h and \?,\C fix Fix for psql pager when no tty(Bruce) New entab utility(Bruce) General trigger functions for referential integrity (Vadim) General trigger functions for time travel (Vadim) General trigger functions for AUTOINCREMENT/IDENTITY feature (Vadim) MOVE implementation (Vadim) Source Tree Changes ------------------- HP-UX 10 patches (Vladimir Turin) Added SCO support, (Daniel Harris) MkLinux patches (Tatsuo Ishii) Change geometric box terminology from "length" to "width"(Thomas) Deprecate temporary unstored slope fields in geometric code(Thomas) Remove restart instructions from INSTALL(Bruce) Look in /usr/ucb first for install(Bruce) Fix c++ copy example code(Thomas) Add -o to psql manual page(Bruce) Prevent relname unallocated string length from being copied into database(Bruce) Cleanup for NAMEDATALEN use(Bruce) Fix pg_proc names over 15 chars in output(Bruce) Add strNcpy() function(Bruce) remove some (void) casts that are unnecessary(Bruce) new interfaces directory(Marc) Replace fopen() calls with calls to fd.c functions(Bruce) Make functions static where possible(Bruce) enclose unused functions in #ifdef NOT_USED(Bruce) Remove call to difftime() in timestamp support to fix SunOS(Bruce & Thomas) Changes for Digital Unix Portability fix for pg_dumpall(Bruce) Rename pg_attribute.attnvals to attdispersion(Bruce) "intro/unix" manual page now "pgintro"(Bruce) "built-in" manual page now "pgbuiltin"(Bruce) "drop" manual page now "drop_table"(Bruce) Add "create_trigger", "drop_trigger" manual pages(Thomas) Add constraints regression test(Vadim & Thomas) Add comments syntax regression test(Thomas) Add PGINDENT and support program(Bruce) Massive commit to run PGINDENT on all *.c and *.h files(Bruce) Files moved to /src/tools directory(Bruce) SPI and Trigger programming guides (Vadim & D'Arcy)


bin
folderThis file contains RegEx patterns used to identify comment patterns for the various supported languages.
...
"typescript": {
"commentRegExp": "\\/\\/(.*)",
"longCommentOpenRegExp": "\\/\\*\\*(.*)",
"longCommentLineRegExp": "\\* (.*)",
"longCommentCloseRegExp": "\\*\/"
}
...
| Setting | Description |
|---|---|
| commentRegExp | RegEx to identify the beginning of a standard (non-long-form) comment. |
| longCommentOpenRegExp | RegEx to identify the beginning of a long-form comment. |
| longCommentLineRegExp | RegEx for a continuation char used in long-form comments. |
| longCommentCloseRegExp | RegEx to identify the end of a long-form comment. |
For Example: ` '//' <== commentRegExp
'/**' <== longCommentOpenRegExp
' * ' <== longCommentLineRegExp
' */' <== longCommentCloseRegExp
`
This file contains the default values for settings. When any new settings is added a default should be set here so that those folks we are upgrading don't face breaking changes. See issue/3
Please remember to document all settings in the main README.md.
This is the default duly noted json file that is copied when the user runs Index/init
This is the entry file for running the NPM package from the command line. See NPM Blog for some more info. Points all actions to Index/run
Temlates used by the HtmlGenerator/generate


BLUE FOREST JUMPER
£250.00
SELECT OPTION
BLUE FOREST JUMPER
£250.00
BUY
BLUE FOREST JUMPER
£250.00
BUY


Qcert.Basic.TypeSystem.RTypeLattice
Section RTypeLattice.
Context {ftype:foreign_type}.
Context {br:brand_relation}.
Global Instance rtype_lattice : Lattice rtype eq
:= { meet:=rtype_meet;
join:=rtype_join;
meet_commutative := rtype_meet_commutative;
meet_associative := rtype_meet_associative;
meet_idempotent := rtype_meet_idempotent;
join_commutative := rtype_join_commutative;
join_associative := rtype_join_associative;
join_idempotent := rtype_join_idempotent;
meet_absorptive := rtype_meet_absorptive;
join_absorptive := rtype_join_absorptive
}.
Global Instance rtype_olattice :
OLattice eq subtype
:= { consistent_meet := consistent_rtype_meet }.
End RTypeLattice.