Free offset software for mac

UTC (GMT) offset contains just one function that returns the local times difference in minutes to the UTC (Universal Time Coordinated) or to the GMT (greenwich mean time) without daylight savings.

BaseTen is a freeware, open source database framework created in Cocoa for working with PostgreSQL databases. BaseTen has been designed with familiar, Core Data -like semantics and APIs.

Main features:
- BaseTen Assistant imports Core Data / Xcode data models.
- Discovers the database schema automatically at runtime, including 1-1, 1-many and many-many relationships.
- Database changes are propagated to clients automatically, without polling.
- In-memory database objects are uniqued, and objects fetched via relationships are faults by default.
- Support for RDBMS features like database-driven data validation, multi-column primary keys and updateable views.
- Autocommit and manual save/rollback modes, both with NSUndoManager integration.
- A BaseTen-aware NSArrayController subclass automates locking and change propagation.
- Fetches are specified with NSPredicates (the relevant portions of which are evaluated on the database).

System requirements:
-
- AppKit for the optional BXSynchronizedArrayController.
-

Enhancements
BaseTen:
- BaseTens date and time type handling has been significantly overhauled.
- Timestamp and datetime types are now always returned as NSDates.
- NSDates are stored into the database in UTC. When fetching, database values are assigned the UTC time zone, or, if they are qualified with some other time zone on the database, converted to UTC.
- NSCalendar is now used instead of NSCalendarDate when converting NSDates to date strings.
- PostgreSQL "time" types are now handled. On the Cocoa side, they are converted to NSDates with the appropriate time offset from the reference date.
- New and changed data type support
- The XML data type can now be fetched as NSXMLDocument. This happens if the database schema is enforcing document-only values with a constraint such as CHECK(column IS DOCUMENT).
- "bit" and "varbit" fields are now fully supported. They are fetched as NSStrings because they cant easily be represented as octets.
- In additiong to fetching "point" fields as NSPoints, NSPoint values can now be saved into the database.
- Changes to the way BaseTen supports database relationships
- The default key names for to-many relationships have changed to the format "Set". The previous form, "", is now deprecated. Add a symbolic breakpoint to BXDeprecationWarning to find uses of these deprecated keys.
- BaseTen can now extract direction-specific relationship names from a foreign key constraints name. The combined length of these two names can be a maximum of 61 bytes of UTF-8. This facility is used by the updated BaseTen Assistant to import the direction-specific names from Xcode Data Modeler schemas.
- When creating new objects with a field values dictionary, to-one related objects (or their object IDs) can now be specified as an alternative to specifying the values of the foreign key fields. The relationship name is used as the key.
Other changes:
- All text transferred between the database and BaseTen will now be normalized to Unicode normal form D, ie. the format produced by -[NSString decomposedStringWithCanonicalMapping].
- Most locking queries sent by BaseTen can now be disabled, and documentation has been added to describe the locking functionality.
- More of BaseTens internals have now been documented in the reference manual.
- When inserting, updating or deleting rows, BaseTen now notices (and posts notifications of) changes that occur as a result of database triggers or rules firing. The only requirement is that said changes are to entities other than the one being changed by BaseTen; changes to the same entity will still be ignored.
- BXDatabaseObjectID is now documented as thread-safe since it only uses NSURL.
- BXSetProxies are now declared as deriving from NSMutableSet, as the NSCountedSets countability property isnt currently used by BaseTen.
- BaseTen will no longer try to unescape non-"bytea" columns.
- More SSL status codes are now available for determining when SSL is unavailable, automatic SSL certificate verification fails, user clicks Cancel in the certificate trust panel or some other SSL error occurs.
- Worked around potential issues with garbage collection where BaseTen used pointers to objects internal structures.
- KVO willChange notifications sent from -setPrimitiveValue:forKey: are now always called before the update. In certain cases with earlier BaseTen versions, observers might receive the notification after the change had been made.
- Some connection error messages are now more accurate.
BaseTenAppKit:
- BXSynchronizedArrayController can now remove objects even if the content set is bound to another array controller.
- BXSynchronizedArrayControllers property fetchesOnConnect is now called fetchesAutomatically. If its set, a fetch will also be performed when an already-connected database context is assigned to the array controller.
- BaseTenAppKit now embeds the Interface Builder plug-in. Interface Builder loads the plug-in if the framework has been added to a project.
- Fixed a crasher which occurred when connecting to a server with SSL capability in asynchronous mode.
- Fixed awkward user interaction when clicking Cancel in the certificate trust panel.
- Fixed a bug which caused object creation to fail if BXSynchronizedArrayController was instantiated in a nib and hadnt performed a fetch.
BaseTen Assistant:
- BaseTen Assistant can now name both sides of one-to-many and one-to-one relationships with the names entered in the Xcode Data Modeler.
- Optional relationships are now be created as optional and required relationships as required.
- Columns will no longer be created for transient attributes in data models.
- Relationships are now listed in the Inspector and info windows.
- A graphical representation of the database schema can now be created for use with Graphviz or OmniGraffle.
- Temporary information can now be deleted from BaseTen schema.
- Help is now more comprehensive.

ToneTester is a Macintosh application that tests hearing.
Specifically, it looks for offsets in how each of a persons ears hears pitch (the formal term for this is "binaural diplacusis" or "interaural pitch difference").
To use it, you adjust a slider until your ears hear the same pitch, and then ToneTester tells you the actual pitch difference.
Enhancements:
- First release.

Keith 9.06 is an effective solution which was developed for a print and design company but can be modified to suit any business needs. Functionality is principally for price calculations of digital and offset printing, including finishing, a client database, order records with various search criteria for efficient retrieval of previous orders, an email client built directly into the solution, a to do list for in house administration, a purchase order system and summary reports for immediate access to turnover and profit.

The Zope Object Database provides an object-oriented database for Python that provides a high-degree of transparency.
Applications can take advantage of object database features with few, if any, changes to application logic. ZODB includes features such as a plugable storage interface, rich transaction support, and undo.
The components you get with the ZODB release are as follows:
- Core ZODB, including the persistence machinery
- Standard storages such as FileStorage
- The persistent BTrees modules
- ZEO, for scalability needs
- documentation (needs more work)
ZODBs primary development platforms are Mac OS X, Linux, and Windows XP.

System requirements:
-

Enhancements
New Features (in more or less reverse chronological order):
- The Database class now has an xrefs keyword argument and a corresponding allow-implicit-cross-references configuration option. which default to true. When set to false, cross-database references are disallowed.
- As a convenience, the connection root method for returning teh root object can now also be used as an object with attributes mapped to the root-object keys.
- Databases have a new method, transaction, that can be used with the Python (2.5 and later) with statement
- This uses a private transaction manager for the connection. If control exists the block without an error, the transaction is committed, otherwise, it is aborted.
- Convenience functions ZODB.connection and ZEO.connection provide a convenient way to open a connection to a database. They open a database and return a connection to it. When the connection is closed, the database is closed as well.
- The ZODB.config databaseFrom... methods now support multi-databases. If multiple zodb sections are used to define multiple databases, the databases are connected in a multi-database arrangement and the first of the defined databases is returned.
The zeopack script has gotten a number of improvements:
- Simplified command-line interface. (The old interface is still supported, except that support for ZEO version 1 servers has been dropped.)
- Multiple storages can be packed in sequence.
- This simplifies pack scheduling on servers serving multiple databases.
- All storages are packed to the same time.
- You can now specify a time of day to pack to.
- The script will now time out if it cant connect to s storage in 60 seconds.
- The connection now estimates the object size based on its pickle size and informs the cache about size changes.
- The database got additional configurations options (cache-size-bytes and historical-cache-size-bytes) to limit the cache size based on the estimated total size of cached objects. The default values are 0 which has the interpretation "do not limit based on the total estimated size". There are corresponding methods to read and set the new configuration parameters.
- Connections now have a public opened attribute that is true when the connection is open, and false otherwise. When true, it is the seconds since the epoch (time.time()) when the connection was opened. This is a renaming of the previous _opened private variable.
- FileStorage now supports blobs directly.
- You can now control whether FileStorages keep .old files when packing.
- POSKeyErrors are no longer logged by ZEO servers, because they are really client errors.
- A new storage interface, IExternalGC, to support external garbage collection, http://wiki.zope.org/ZODB/ExternalGC, has been defined and implemented for FileStorage and ClientStorage.
- As a small convenience (mainly for tests), you can now specify initial data as a string argument to the Blob constructor.
- ZEO Servers now provide an option, invalidation-age, that allows quick verification of ZEO clients less than a given age even if the number of transactions the client hasnt seen exceeds the invalidation queue size. This is only recommended if the storage being served supports effecient iteration from a point near the end of the transaction history.
- The FileStorage iterator now handles large files better. When iteratng from a starting transaction near the end of the file, the iterator will scan backward from the end of the file to find the starting point. This enhancement makes it practical to take advantage of the new storage server invalidation-age option.
- Previously, database connections were managed as a stack. This tended to cause the same connection(s) to be used over and over. For example, the most used conection would typically be the onlyt connection used. In some rare situations, extra connections could be opened and end up on the top of the stack, causing extreme memory wastage. Now, when connections are placed on the stack, they sink below existing connections that have more active objects.
- There is a new pool-timeout database configuration option to specify that connections unused after the given time interval should be garbage colection. This will provide a means of dealing with extra connections that are created in rare circumstances and that would consume an unreasonable amount of memory.
- The Blob open method now supports a new mode, c, to open committed data for reading as an ordinary file, rather than as a blob file. The ordinary file may be used outside the current transaction and even after the blobs database connection has been closed.
- ClientStorage now provides blob cache management. When using non-shared blob directories, you can set a target cache size and the cache will periodically be reduced try to keep it below the target size.
- The client blob directory layout has changed. If you have existing non-shared blob directories, you will have to remove them.
- ZODB 3.9 ZEO clients can connect to ZODB 3.8 servers. ZODB ZEO clients from ZODB 3.2 on can connect to ZODB 3.9 servers.
- When a ZEO cache is stale and would need verification, a ZEO.interfaces.StaleCache event is published (to zope.event). Applications may handle this event and take action such as exiting the application without verifying the cache or starting cold.
- Theres a new convenience function, ZEO.DB, for creating databases using ZEO Client Storages. Just call ZEO.DB with the same arguments you would otherwise pass to ZEO.ClientStorage.ClientStorage.
- Object saves are a little faster
- When configuring storages in a storage server, the storage name now defaults to "1". In the overwhelmingly common case that a single storage, the name can now be ommitted.
- FileStorage now provides optional garbage collection. A gc keyword option can be passed to the pack method. A false value prevents garbage collection.
- The FileStorage constructor now provides a boolean pack_gc option, which defaults to True, to control whether garbage collection is performed when packing by default. This can be overridden with the gc option to the pack method.
- The ZConfig configuration for FileStorage now includes a pack-gc option, corresponding to the pack_gc constructor argument.
- The FileStorage constructor now has a packer keyword argument that allows an alternative packer to be supplied.
- The ZConfig configuration for FileStorage now includes a packer option, corresponding to the packer constructor argument.
- MappingStorage now supports multi-version concurrency control and iteration and provides a better storage implementation example.
DemoStorage has a number of new features:
- The ability to use a separate storage, such as a file storage to store changes
- Blob support
- Multi-version concurrency control and iteration
- Explicit support dfor demo-storage stacking via push and pop methods.
- Wen calling ZODB.DB to create a database, you can now pass a file name, rather than a storage to use a file storage.
Added support for copying and recovery of blob storages:
- Added a helper function, ZODB.blob.is_blob_record for testing whether a data record is for a blob. This can be used when iterating over a storage to detect blob records so that blob data can be copied. In the future, we may want to build this into a blob-aware iteration interface, so that records get blob file attributes automatically.
- Added the IBlobStorageRestoreable interfaces for blob storages that support recovery via a restoreBlob method.
- Updated ZODB.blob.BlobStorage to implement IBlobStorageRestoreable and to have a copyTransactionsFrom method that also copies blob data.
- New ClientStorage configuration option drop_cache_rather_verify. If this option is true then the ZEO client cache is dropped instead of the long (unoptimized) verification. For large caches, setting this option can avoid effective downtimes in the order of hours when the connection to the ZEO server was interrupted for a longer time.
- Cleaned-up the storage iteration API and provided an iterator implementation for ZEO.
- Versions are no-longer supported.
- Document conflict resolution (see ZODB/ConflictResolution.txt).
- Support multidatabase references in conflict resolution.
- Make it possible to examine oid and (in some situations) database name of persistent object references during conflict resolution.
- Moved the transaction module out of ZODB. ZODB depends upon this module, but it must be installed separately.
- ZODB installation now requires setuptools.
- Added offset information to output of fstail script. Added test harness for this script.
- Added support for read-only, historical connections based on datetimes or serials (TIDs). See src/ZODB/historical_connections.txt.
- Removed the ThreadedAsync module.
- Now depend on zc.lockfile
Bugs Fixed:
- fixed Python 2.6 compatibility issue with ZEO/zeoserverlog.py
- using hashlib.sha1 if available in order to avoid DeprecationWarning under Python 2.6
- made runzeo -h work
- The monitor server didnt correctly report the actual number of clients.
- Packing could return spurious errors due to errors notifying disconnected clients of new database size statistics.
- Undo sometimes failed for FileStorages configured to support blobs.
- Starting ClientStorages sometimes failed with non-new but empty cache files.
- The history method on ZEO clients failed.
- Fix for bug #251037: Make packing of blob storages non-blocking.
- Fix for bug #220856: Completed implementation of ZEO authentication.
- Fix for bug #184057: Make initialisation of small ZEO client file cache sizes not fail.
- Fix for bug #184054: MappingStorage used to raise a KeyError during load instead of a POSKeyError.
- Fixed bug in Connection.TmpStore: load() would not defer to the backend storage for loading blobs.
- Fix for bug #181712: Make ClientStorage update lastTransaction directly after connecting to a server, even when no cache verification is necessary.
- Fixed bug in blob filesystem helper: the isSecure check was inversed.
- Fixed bug in transaction buffer: a tuple was unpacked incorrectly in clear.
- Bugfix the situation in which comparing persistent objects (for instance, as members in BTree set or keys of BTree) might cause data inconsistency during conflict resolution.
- Fixed bug 153316: persistent and BTrees were using int for memory sizes which caused errors on x86_64 Intel Xeon machines (using 64-bit Linux).
- Fixed small bug that the Connection.isReadOnly method didnt work after a savepoint.
- Bug #98275: Made ZEO cache more tolerant when invalidating current versions of objects.
- Fixed a serious bug that could cause client I/O to stop (hang). This was accomonied by a critical log message along the lines of: "RuntimeError: dictionary changed size during iteration".
- Fixed bug #127182: Blobs were subclassable which was not desired.
- Fixed bug #126007: tpc_abort had untested code path that was broken.
- Fixed bug #129921: getSize() function in BlobStorage could not deal with garbage files
- Fixed bug in which MVCC would not work for blobs.
- Fixed bug in ClientCache that occurred with objects larger than the total cache size.
- When an error occured attempting to lock a file and logging of said error was enabled.
- FileStorages previously saved indexes after a certain number of writes. This was done during the last phase of two-phase commit, which made this critical phase more subject to errors than it should have been. Also, for large databases, saves were done so infrequently as to be useless. The feature was removed to reduce the chance for errors during the last phase of two-phase commit.
- File storages previously kept an internal object id to transaction id mapping as an optimization. This mapping caused excessive memory usage and failures during the last phase of two-phase commit. This optimization has been removed.
- Refactored handling of invalidations on ZEO clients to fix a possible ordering problem for invalidation messages.
- On many systems, it was impossible to create more than 32K blobs. Added a new blob-directory layout to work around this limitation.
- Fixed bug that could lead to memory errors due to the use of a Python dictionary for a mapping that can grow large.
- Fixed bug #251037: Made packing of blob storages non-blocking.
- Fixed a bug that could cause InvalidObjectReference errors for objects that were explicitly added to a database if the object was modified after a savepoint that added the object.
- Fixed several bugs that caused ZEO cache corruption when connecting to servers. These bugs affected both persistent and non-persistent caches.
- Improved the the ZEO client shutdown support to try to avoid spurious errors on exit, especially for scripts, such as zeopack.
- Packing failed for databases containing cross-database references.
- Cross-database references to databases with empty names werent constructed properly.
- The zeo client cache used an excessive amount of memory, causing applications with large caches to exhaust available memory.
Fixed a number of bugs in the handling of persistent ZEO caches:
- Cache records are written in several steps. If a process exits after writing begins and before it is finishes, the cache will be corrupt on restart. The way records are writted was changed to make cache record updates atomic.
- There was no lock file to prevent opening a cache multiple times at once, which would lead to corruption. Persistent caches now use lock files, in the same way that file storages do.
- A bug in the cache-opening logic led to cache failure in the unlikely event that a cache has no free blocks.
- When using ZEO Client Storages, Errors occured when trying to store objects too big to fit in the ZEO cache file.
- Fixed bug in blob filesystem helper: the isSecure check was inversed.
- Fixed bug in transaction buffer: a tuple was unpacked incorrectly in clear.
- Fixed bug in Connection.TmpStore: load() would not defer to the backend storage for loading blobs.
- Fixed bug #190884: Wrong reference to POSKeyError caused NameError.
- Completed implementation of ZEO authentication. This fixes issue 220856.

SaberNet DCS is a labor data collection system, designed to allow organizations to rapidly capture their labor data in real-time.
Reporting and analyzing this data provides you with real visibility into the profitability of individual jobs, projects, employees and departments.
Establishing reliable labor efficiencies enables you to more accurately estimate jobs and uncover opportunities.
Operating System:
- Linux
- Microsoft Windows
- Mac OS
Database:
- MySQL
- Microsoft SQL Server
Browser:
- Mozilla Firefox
- Microsoft Internet Explorer
Technologies Used:
- Python
- Pyro
- PyGTK

Main features:
- Single swipe clock-in allows employees to rapidly clock in at a door terminal.
- Single swipe lunch / break allows you to suspend and resume an activity using a single barcode.
- Instant activity switching allows an employee to immediately end one task and begin another.
- One employee on multiple jobs (job ganging)
- Multiple employees on one job
- Indirect activities and set-up time tracking
- Web enabled administration allows managers and supervisors to reference the live active employee list, manage jobs, and edit time records from any browser
- Runs as either a stand-alone application (autonomous) or it can be integrated with an ERP/CRM/MIS or payroll system
- 2 modes of operation: shop floor automated (bar-codes and scanners) and desktop standalone (mouse and keyboard)
- Powerful reporting can be generated with Crystal Reports

Enhancements
- gtk/Application.py, sndcs/Store.py: Python 2.6 (at least on Ubuntu)
- has some new install schemes that puts data files into /usr/local
- even though the docs say that it is based on sys.prefix which is
- probably just /usr. So we need to look in several places possibly
- for the glade file and the sndcs.mkmodel directory.
- configure_sndcs.py, setup.py, sndcs/Employee.py,
- sndcs_client/Config.py, sndcs_client/gtk/Application.py,
- sndcs_client/gtk/AvailableActivitiesTreeView.py,
- sndcs_client/gtk/EventSubscriber.py, sndcs_common/Logger.py,
- upgrade/UpgradeDatabase.py: Some minor fix ups when checked for python
- 3.0 compatibility. Mostly removing has_key().
- sndcs_common/DateTimeMixin.py: Added new convertDeltaToHours()
- function.
- gtk/Application.py: Small refactoring of code that calculates dates
- and times based on the clock offset to the server time.

OpenOffice.org is a multiplatform and multilingual office suite and an open-source project. Compatible with all other major office suites, the product is free to download, use, and distribute.
OpenOffice.org is a suite that individuals, governments, and corporations around the world have been expecting for the last two years. Easy to use and fluidly interoperable with every major office suite, OpenOffice.org realises the potential of open source.
With new features, advanced XML capabilities and native support for the OASIS Standard OpenDocument format, OpenOffice.org gives users around the globe the tools to be engaged and productive members of their society.
Platforms currently supported include Mac OS X (under X11), Microsoft Windows (98 - Vista), GNU/Linux ("Linux"), Sun Solaris, and FreeBSD.
NOTE: OpenOffice.org is licensed under the GNU Lesser General Public License.

System requirements:
- X11
-

Enhancements:
- Sheet names can contain almost any character.
- ADDRESS and INDIRECT support additional parameter for A1/R1C1 notation.
- ODFF: automatic intersection !! operator.
- ODFF: store ERRORTYPE as ORG.OPENOFFICE.ERRORTYPE.
- New: XML Documents XForm models support "internal" vs. "external" data.
- Change to table view when a new database was created by the db wizard.
- INDEX() function supports return of an entire vector of a 2D array.
- GCD() and LCM() convert arguments to integer.
- LOOKUP in columns of a row if range is wider than tall.
- INDEX of vector needs just one offset parameter.
- COUNT ignores error results.
- Adding MS Access databases in Writer now possible.

EarToner is ear training software to help you learn to identify various musical sounds such as intervals, chords, scales and whether two notes are in tune with each other. EarToner is designed to be easy to use and quick to setup.
I originally wrote a rough version for myself just for identifying intervals. When I mentioned it to other musical friends they were very interested in using it also. I thought I would just formalize it a little more and release it for free on the internet to whoever wants to use it.
Main features:
General:
- number of items played - currently the scoring only indicates how many correct guesses youve made and how many guesses youve made total.
- playback mode - click on the buttons and have it play the interval/chord (currently only has a testing mode, so clicking on the buttons is considered a guess at the last interval played)
- documentation - info on working with the various modules and what their settings can do.
Intervals:
- all intervals from a minor second up to a perfect 15th (two octaves) in half step increments.
- direction of intervals (only play up or down, or both randomly)
- set tonic - this helps newer ears learning to hear just a few intervals in from a single reference point.
- allowable range - keeps the notes within a certain number of octaves above and below middle C so it doesnt get too ridiculous.
- ability to play the intervals separately or together.
- number of intervals - I found that after awhile I could start hearing intervals pretty close to 100&pct of the time, so I thought Id add an extra twist, in the spirit of most college ear training classes requirement for dictation. This helps to develop an intervallic memory of sorts. EarToner will play a certain number of pitches, and you must identify the interval between them in the proper order.
- note duration
Chords:
- chords able to be tested on Major Triad, Minor Triad, Augmented Triad, Diminished Triad, Major 7th, Dominant 7th, Minor 7th, Minor-Major 7th (1, b3, 5, 7), Half-Diminished 7th (1, b3, b5, b7), Full-Diminished 7th (1, b3, b5, bb7), Augmented-Major 7th (1, 3, #5, 7) and Augmented 7th (1, 3, #5, b7).
- inversions - ability to select which inversions of chords as well as the chords you wanted to be trained on.
- allowable range - keeps the notes within a certain number of octaves above and below middle C so it doesnt get too ridiculous.
- set tonic - probably if someone is going to want it for intervals, theyre going to want it for chords too.
- arppeggiation of chord - seems handy for hearing all of the intervals in the chord when trying to learn new chords.
Scales:
- scales able to be tested on Major (Ionian), Natural Minor (Aeolian), Harmonic Minor, Melodic Minor, Dorian, Phrygian, Lydian, Mixolydian, Locrian, Whole Tone, Chromatic, Major Pentatonic, Minor Pentatonic, Blues, Diminished Whole/Half, Diminished Half/Whole.
- allowable range - keeps the notes within a certain number of octaves above and below middle C so it doesnt get too ridiculous.
- set tonic - same as above.
Tuning:
- Playing of two notes to identify whether the second note is sharp, flat or in tune
- Variable length of notes in time.
- Variable offset of the second note from the first note, from being played at the same time to playing immediately after the first note.
- Ability to select different sound (MIDI patch) for the second note
- User selectable maximum detuning, so the second note can be out of tune from the first one as far as a whole step (good for young ears learning to identify lower and higher).
- Changeable granularity for the second note, so the detuning of the second note can be anywhere from 1/64th of a whole step all the way up to a whole step
- set tonic - same as other modules
- interval - separate the two notes by a set interval. Good for string players and others that need to learn to tune in 4ths, 5ths, etc.
- direction - for using an interval other than unison allows the second note to be above, below or randomly selected by EarToner.
Enhancements:
- This release adds new playback functionality of incorrect guesses.
- A simple Windows executable has been created.