- SgFieldColor2.value() added arg "linkEvaluate"

  SgFieldColor2.value() now supports a new argument "linkEvalute"
  (default=True).  This evalutes Task and Phase color fields that
  are pointers to other Entity color fields.

  Before this new arg the eval functionality was hard coded to always
  happen.  Now the arg allows the value of a color field to be
  returned raw.

- SgFieldColor2 fixed bug where a list of strings were always returned

  SgFieldColor2 was spliting the fields value but not converting the
  split result into ints.  Now a list of ints is returned.
SgField.validate() added an arg "forReal"

SgField.validate() has a new arg "forReal" so fields can be soft
validated, such as when they have a pending sync update.  Passing
False through "forReal" will not cause the field to hit Shotgun for
its value, thus the field will remain invalid.

This allows calling validate() on fields that have a pending update.
Added SgFieldColor2.linkField(), fixed validate bug "id","type" fields

Exposed the ability to retrieve the link field name that a color2
field references.  SgFieldColor2.linkField().  This will return
"pipeline_step" for Task and "project" for Phase Entity types.

The UserFields for "id" and "type" were not updated with the new
validate arg "forReal" which broke the ORM.
Added new event log functionality for Entity and Field classes

- SgEntity,SgField lastEventLog() and eventLogs() functions now accept
  an argument "sgFields" for specifying the fields to fill for thier
  returned result.

  Also refactored lastEventLog() as it was duplicate code.

- SgField added new functions lastModifiedInfo(), lastModifiedAt(),
  and lastModifiedBy().

  It is now easy to retrieve the user/time of the fields last
  modification with these functions.
Tweaked Shotgun filter when only one Entity is to be returned by a job

Switched the search filter from an "in" to a "is" when only one entity
id is present.
Added extra debug call in SgEntity.valuesSg to show the pulling fields

valuesSg only output to the logger what fields were passed to the
the function.  Because the list of fields is checked for if they are
queryable now the debug logger will also print the fields that passed
the queryable test.
SgField.valueSg() updated for better subclass control

- SgField.valueSg() performed a check if the parent exists and if not
  returned immediately.  This works well except for SgUserFields which
  do no depend on the parent existing for the return result.  Moved
  the parent exists check into the sub-class section _valueSg().

SgUserField.setValueFromShotgun() no longer always returns False

- This was originally done for the "id" and "type" fields however both
  classes already define setValueFromShotgun() and return False.  This
  forced subclasses into a undesireable spot as they would always have
  to define setValueFromShotgun() manually.

  This removes the burdon of user field subclasses from always having
  to reimplement setValueFromShotgun().
Added SgFieldSchemaInfo.createSchemaData() refactored code

- Created a new function createSchemaData() that will return a proper
  schema info dictionary that can be used to create new field schema
  info objects.  Reduces the need to hand build the data dict objects.

  Code refactored to use the new call.
Added SgField.isUserField()

- Added SgField.isUserField() for easy checking that a field is a user
  one or not.

Added doc string for arg "sgSyncFields" to Entity fields value()

- The "sgSyncFields" arg for SgFieldEntity and SgFieldMultiEntity is
  now documented as to what it does.

First commit SgUserFieldAbstractEntity, SgUserFieldAbstractMultiEntity

- These two new classes are so that subclasses of user fields can
  return Entities as thier value without having to copy code from the
  main Entity and multi Entity field classes.

  All the conversion from a dict to an Entity object as well as async
  pulling are coded into the classes.

Added an example SgUserField called SearchExpressionField

- This example shows how to create a user field that performs a
  Shotgun search as its return value.
Fixed bug with Entity and MultiEntity fields storing a "name" field

- A recent commit allowed Entity fields to store a name value if
  the value passed to _fromFieldData contained it.

  This was in response to AppWelcome and Banner Entity types returning
  a field only avaiable when quried from a field belonging to another
  Entity.

  The Entity field classes now only allow AppWelcome and Banner types
  to store the "name" field, before it was allowed for all types.
SgField validate changed to no longer call setValueFromShotgun()

- validate() will no longer call setValueFromShotgun(), instead it will
  call _fromFieldData().

  The old way was messy and caused issues with changed() which meant
  validation had to be tracked.

Added forReal debug printing in validate

- validate() now debug prints the value of forReal.

Removed debug print statement left in previous commit.

- Removed a print statement that was left in during a pervious commit.
SgEntity.buildUserFields removed

- buildUserFields() has been removed as it was redundant and no
  longer needed.

  Classes can now implement _buildFields() without having to carry
  the burdon of building all fields for the Entity.

Added new fieldValues() arg "sgSyncFields"

- SgEntity.fieldValues() now contains a new arg "sgSyncFields" that
  is passed to each Entity field that will have its value returned.

Removed internal var SgEntity._createCompleted

- No longer needed due to SgField updates.

Moved SgEntity._hasBuiltFields to a private var

- Now is a private var for Entity class.

  SgEntityClassFactorys no longer set this value as the SgEntity
  buildFields() function sets it now.

SgFieldEntity updated to support a dict passed in arg "sgSyncFields"

- SgFieldEntity now supports a dict being passed as its arg for
  "sgSyncFields".

  This allows it to support the update above to fieldValues()
SgEntityField fixed bug pointing to undefined variable

- The last commit for SgEntityField changed a variable name and left
  a pointer to the old name still around.
First pass at revamping the SgField class

The field class was a nightmare in terms of subclassing, most
notably with creating custom user fields.

Major changes to the field class:
  * SgUserField removed
  * The constructor no longer takes a parentEntity and schemaInfo
  * New schema info class SgFieldSchemaInfo2 for user fields
  * _parent and _info moved to private variables
  * Return types hard coded for each field class
  * Entity class now has an add/remove function for adding fields

SgUserField removed

- User fields presented a mess for creating field subclasses.  They
  made it very manual to define a new class and you could not subclass
  pre-existing field types because of them.

  id and type fields are now subclasses of int and text field classes.

Constructor changes

- The constructor for fields no longer accepts a parent entity and
  the schema info object that defines the field.

  Instead the field accepts a name and optional label argument (which
  when not specified the name is capitalized and used for the label).
  The third arg is for specifying a SgFieldSchemaInfo object to use
  for the field.  When not specified one is generated.

  When a field is constructed as a user field it creates an info obj
  that is of SgFieldSchemaInfo2.  These new info classes are
  specifically for user fields as they are editable unlike the main
  schema info class.

_parent and _info moved to private variables

- The Fields _parent and _info variables are now private as they
  do not need to be exposed any longer.

Return types hard coded for each field

- Return types are now hard coded for each field class so they do not
  need to depend on the schema info object.

  This was needed because when a user field generates its schema info
  object it needs to know what return type the field is.

Entity class now has an add/remove field function

- User fields can be added to Entity objects by passing them to the
  addField() function.

  Field names are checked and an Exception is thrown if a field with
  the name already exists on the Entity.  The field once added has its
  parent updated to reflect the Entity it was added to.

  Fields can be removed by name with the removeField() function.
  Fields that are not user fields are not able to be removed from
  Entity objects.  Any attempt to remove a schema field will result
  in an Exception being thrown.
No longer needed after field class revamp
Creation of "type" field schema info object now happens as callback

- The creation of the "type" fields SgFieldSchemaInfo now happens
  during the onEntitySchemaInfoCreate() callback.
Updated example SearchExpressionField and added callback example

- Updated the SearchExpressionField example with the new field changes

- Added new example file that shows hooking into the callback system
Merge branch 'develop'