Free price watcher software for linux

ps-watcher monitors various processes based on ps-like information. ps-watcher runs the ps command periodically and triggers commands on matches.
The match patterns are Perl regular expressions which can refer to the process information via variables.
Installation:
The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.
It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.
Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up
reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).
If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.
If at some point `config.cache contains results you dont want to keep, you may remove or edit it.
The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.
The simplest way to compile this package is:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Optionally, type `make check to run any self-tests that come with the package.
4. Type `make install to install the programs and any data files and documentation.
5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.
There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
Enhancements:
- Some minimal Cygwin support was added, and support for other operating systems (NetBSD, OpenBSD, and OS X) was corrected.
- For security, there is aa --path option to limit the path used in running commands.
- Some bugs were fixed and the code was modernized a little.

Bidwatcher is a free auction tool for eBay users, available for Linux and (soon?) Microsoft Windows. It was created by Trent and Tom McNair, and is currently maintained by volunteers at SourceForge.
Main features:
- Tracks your eBay listings and items that you have bid on.
- Allows you to track auctions that you do not own and have not bid on.
- Snipe tool allows you to schedule your bid to be placed seconds before the auction ends, avoiding driving the price high early in the auctions life.
- Prioritizes updates according to the time left in an auction. (i.e. updates auctions that are almost over more often than ones that have a while to go).
- Clock on main window synchronized to eBay time.
- Runs in the background with minimal toll on system resources.
- Its free!
Requierments:
- GTK+ version 1.2+

PRICE can open several image file formats and apply high-quality filters and other enhancements. PRICE was written to support the authors research in image processing.

PRICE was born to support my research in image processing. So I have decided to work on a usable application that can open several file formats and apply high quality filters and other enhancements to the image.

pINET implements a Python interface for the NASDAQ INET XML service. pINET allows access to real-time stock orders, executions, and statistics.
Installation:
- Place pINET.py in the directory your source resides in (site-lib, if youd like, but theres no setup.py yet)
- Replace the token variable with your INET developer token (http://data.inetats.com/members/ws/newtoken.jsp)
- import pINET ...
Examples:
- test.st.py: single-threaded example
- test.mt.py: multi-threaded example
API:
Single-threaded (see test.st.py)
- requestOrders (symbol): returns up to 50 open orders on both sides in form:
{ buy:
[{price: ..., shares: ..., type: ...}, ...],
sell:
[{price: ..., shares: ..., type: ...}, ...]
}
- requestExecs (symbol): returns up to last 100 INET executions in form:
[ {price: ..., shares: ..., time: ..., type: ...} ... ]
- requestStats (symbol): returns open, booked, and matched share statistics in form:
{ book: {shares: ..., orders: ...},
open: {shares: ..., orders: ...},
match: {shares: ..., price: ...}
}
Multi-threaded (see test.mt.py)
- class RequesterThread
RequesterThread(symbol, type):
-symbol: NASDAQ symbol
-type: {reqOrders, reqExecs, reqStats}
RequesterThread.ID contains the threads job ID, which in turn is used as the key by the pINET.jobQueue dictionary.
Enhancements:
- The Top List API has been implemented and the source has been fully documented with examples via pydoc.
- The setup.py install script and unit.py test script have also been integrated into the release.
- Lastly among minor fixes, there is also a beta Tk interface that allows tracking of the top volume list and any NASDAQ symbol, displaying price, ask and bid, volume, and five-day graph.

mswatch project is a command line unix program that keeps two mailboxes synchronized more efficiently and with shorter delays than periodically synchronizing the two mailboxes.
mswatch watches mailboxes to know when to initiate mailbox syncs. Using mswatch, your mail synchronization program can be called on demand instead of through polling, resulting in prompter mail delivery and lower bandwidth usage and server load.
mswatch is designed to work in conjunction with mailbox synchronization programs, currently supports watching Linux (2.4+) hosted Maildirs (including Maildir folders, Maildir++), and is licensed under the GNU GPL. Future support for additional mailbox formats, especially for mbox, is planned.
Why mswatch
Keeping a set of mailboxes on multiple computers means keeping the copies synchronized (eg on ones desktop and laptop or on a personal computer that can not be reached while on the road an always-reachable server). While the IMAP protocol is designed to support this and is widely used, IMAP clients can only detect mailbox changes by querying the server.
Thus clients generally either sync when the user requests or sync periodically. However, because each mailbox sync uses server and network resources and because users often have a number of mailboxes, many of which receive mail infrequently, one must compromise between prompt message delivery and low server and network resource usage. Typical practice is to sync only when the user requests or to sync periodically with 5-10 minute frequencies. Nonetheless, it is often helpful for users to see new mail fairly soon after its arrival (eg notifications, group meeting changes, or active conversation threads).
mswatch addresses this speed of delivery vs resource usage tradeoff using interrupt-based instead of polling behavior to detect mailbox changes. mswatch asks each of the two mailstores to send mailbox change notifications; when mswatch receives a notification it in turn invokes the users mailbox synchronization program for the changed mailbox. Thus, idle mailboxes do not use active resources and prompt mailbox synchronization is efficient.
Version restrictions:
- Because mswatch abstracts mail changes and synchronization to the mailbox (instead of message) level and because mail watcher communication is one-way, extra mailbox syncs occur. While it would be great to avoid this extra work, it is in the noise compared to the number of empty syncs that polling accumulates.
For example, the case of new mail delivered to the mail servers INBOX:
(1) mswatch detects the changed server INBOX
(2) mswatch invokes the mail syncer for INBOX, which adds the mail to the local INBOX
(3) mswatch detects the changed local INBOX
(4) mswatch invokes the mail syncer for INBOX, which detects no changes
Thus two syncs occur in this case instead of the single necessary sync.
Enhancements:
- Per-mailbox inter-sync delays were added to rarely sync high volume mailboxes and quickly sync important mailboxes.
- Inter-sync delays are allowed to be greater than the maximum error delay.
- mswatch now prints the names of pending mailboxes upon receiving SIGUSR1.

Finance::BeanCounter is a Perl module for stock portfolio performance functions.

Finance::BeanCounter provides functions to download, store and analyse stock market data.

Downloads are available of current (or rather: 15 or 20 minute-delayed) price and company data as well as of historical price data. Both forms can be stored in an SQL database (for which we currently default to PostgreSQL though MySQL is supported as well; furthermore any database reachable by means of an ODBC connection should work).

Analysis currently consists of performance and risk analysis. Performance reports comprise a profit-and-loss (or p/l in the lingo) report which can be run over arbitrary time intervals such as --prevdate friday six months ago --date yesterday -- in essence, whatever the wonderful Date::Manip module understands -- as well as dayendreport which defaults to changes in the last trading day. A risk report show parametric and non-parametric value-at-risk (VaR) estimates.

Most available functionality is also provided in the reference implementation beancounter, a convenient command-line script.

The API might change and evolve over time. The low version number really means to say that the code is not in its final form yet, but it has been in use for well over four years.

More documentation is in the Perl source code.

Finance::YahooQuote is a Perl module that can get stock quotes from Yahoo! Finance.

SYNOPSIS

use Finance::YahooQuote;
# setting TIMEOUT and PROXY is optional
$Finance::YahooQuote::TIMEOUT = 60;
$Finance::YahooQuote::PROXY = "http://some.where.net:8080";
@quote = getonequote $symbol; # Get a quote for a single symbol
@quotes = getquote @symbols; # Get quotes for a bunch of symbols
useExtendedQueryFormat(); # switch to extended query format
useRealtimeQueryFormat(); # switch to real-time query format
@quotes = getquote @symbols; # Get quotes for a bunch of symbols
@quotes = getcustomquote(["DELL","IBM"], # using custom format
["Name","Book Value"]); # note array refs

This module gets stock quotes from Yahoo! Finance. The getonequote function will return a quote for a single stock symbol, while the getquote function will return a quote for each of the stock symbols passed to it. getcustomquote allows to specify a format other than the default to take advantage of the extended range of available information.

The download operation is efficient: only one request is made even if several symbols are requested at once. The return value of getonequote is an array, with the following elements:

0 Symbol
1 Company Name
2 Last Price
3 Last Trade Date
4 Last Trade Time
5 Change
6 Percent Change
7 Volume
8 Average Daily Vol
9 Bid
10 Ask
11 Previous Close
12 Todays Open
13 Days Range
14 52-Week Range
15 Earnings per Share
16 P/E Ratio
17 Dividend Pay Date
18 Dividend per Share
19 Dividend Yield
20 Market Capitalization
21 Stock Exchange

If the extended format has been selected, the following fields are also retrieved:

22 Short ratio
23 1yr Target Price
24 EPS Est. Current Yr
25 EPS Est. Next Year
26 EPS Est. Next Quarter
27 Price/EPS Est. Current Yr
28 Price/EPS Est. Next Yr
29 PEG Ratio
30 Book Value
31 Price/Book
32 Price/Sales
33 EBITDA
34 50-day Moving Avg
35 200-day Moving Avg
If the real-time format has been selected, the following fields are also retrieved:
36 Ask (real-time)
37 Bid (real-time)
38 Change in Percent (real-time)
39 Last trade with time (real-time)
40 Change (real-time)
41 Day range (real-time)
42 Market-cap (real-time)

The getquote function returns an array of pointers to arrays with the above structure.
The getonequote function returns just one quote, rather than an array. It returns a simple array of values for the given symbol.

The setQueryString permits to supply a new query string that will be used for subsequent data requests.

The useExtendedQueryFormat and useRealtimeQueryFormat are simpler interfaces which append symbols to the default quote string, as detailed above.

The getcustomquote returns an array of quotes corresponding to values for the symbols supplied in the first array reference, and the custom fields supplied in the second array reference. Here the custom fields correspond to the named fields of the list below.

Beyond stock quotes, Finance::YahooQuote can also obtain quotes for currencies (from the Philadephia exchange -- however Yahoo! appears to have stopped to support the currency symbols in a reliable manner), US mutual funds, options on US stocks, several precious metals and quite possibly more; see the Yahoo! Finance website for full information. Finance::YahooQuote can be used for stocks from the USA, Canada, various European exchanges, various Asian exchanges (Singapore, Taiwan, HongKong, Kuala Lumpur, ...) Australia and New Zealand. It should work for other markets supported by Yahoo.

You may optionally override the default LWP timeout of 180 seconds by setting $Finance::YahooQuote::TIMEOUT to your preferred value.

You may also provide a proxy (for the required http connection) by using the variable $Finance::YahooQuote::PROXY. Furthermore, authentication-based proxies can be used by setting the proxy user and password via the variables $Finance::YahooQuote::PROXYUSER and $Finance::YahooQuote::PROXYPASSWD.

Two example scripts are provided to help with the mapping a stock symbols as well as with Yahoo! Finance server codes. The regression tests scripts in the t/ subdirectory of the source distribution also contain simple examples.