Pony ORM 0.6 Release Candidate 2

This release fixes syntax errors during installation on ubuntu 14.04 (issue #81)

Pony ORM 0.6 Release Candidate 1

Blog post: http://blog.ponyorm.com/2014/10/08/pony-orm-0-6-release-candidate-1

New features:

• Python 3 support
• pymysql adapter support for MySQL databases

Backward incompatible changes

Now Pony treats both str and unicode attribute types as they are unicode strings in both Python 2 and 3. So, the attribute declaration attr = Required(str) is equal to attr = Required(unicode) in Python 2 and 3. The same thing is with LongStr and LongUnicode - both of them are represented as unicode strings now.

For the sake of backward compatibility Pony adds unicode as an alias to str and buffer as an alias to bytes in Python 3.

Other changes and bug fixes

• Fixes #74: Wrong FK column type when using sql_type on foreign ID column
• Fixes #75: MappingError for self-referenced entities in a many-to-many relationship
• Fixes #80: “Entity NoneType does not belong to database” when using to_dict

Pony ORM release 0.5.4

New functions and methods:

• pony.orm.serialization module with the to_dict() and to_json() functions was added. Before this release you could use the to_dict() method of an entity instance in order to get a key-value dictionary structure for a specific entity instance. Sometimes you might need to serialize not only the instance itself, but also the instance's related objects. In this case you can use the to_dict() function from the pony.orm.serialization module.
  • to_dict() - receives an entity instance or a list of instances and returns a dictionary structure which keeps the passed object(s) and immediate related objects
  • to_json() – uses to_dict() and returns JSON representation of the to_dict() result
• Query.prefetch() – allows to specify which related objects or attributes should be loaded from the database along with the query result . Example:

      select(s for s in Student).prefetch(Group, Department, Student.courses)

• obj.flush() – allows flush a specific entity to the database
• obj.get_pk() – return the primary key value for an entity instance
• py_check parameter for attributes added. This parameter allows you to specify a function which will be used for checking the value before it is assigned to the attribute. The function should return True/False or can raise ValueError exception if the check failed. Example:

    class Student(db.Entity):
        name = Required(unicode)
        gpa = Required(float, py_check=lambda val: val >= 0 and val <= 5)

New types:

• time and timedelta – now you can use these types for attribute declaration. Also you can use timedelta and a combination of datetime + timedelta types inside queries.

New hooks:

• after_insert, after_update, after_delete - these hooks are called when an object was inserted, updated or deleted in the database respectively (link)

New features:

• Added support for pymysql – pure Python MySQL client. Currently it is used as a fallback for MySQLdb interface

Other changes and bug fixes

• obj.order_by() method is deprecated, use Entity.select().order_by() instead
• obj.describe() now displays composite primary keys
• Fixes #50: PonyORM does not escape _ and % in LIKE queries
• Fixes #51: Handling of one-to-one relations in declarative queries
• Fixes #52: An attribute without a column should not have rbits & wbits
• Fixes #53: Column generated at the wrong side of "one-to-one" relationship
• Fixes #55: obj.to_dict() should do flush at first if the session cache is modified
• Fixes #57: Error in to_dict() when to-one attribute value is None
• Fixes #70: EntitySet allows to add and remove None
• Check that the entity name starts with a capital letter and throw exception if it is not then raise the ERDiagramError: Entity class name should start with a capital letter exception

Pony ORM release 0.5.3

This release fixes the setup.py problem that was found after the previous release was uploaded to PyPI.

Pony ORM release 0.5.2

http://blog.ponyorm.com/2014/08/11/pony-orm-release-0-5-2/

This release is a step forward to Python 3 support. While the external API wasn't changed, the internals were significantly refactored to provide forward compatibility with Python 3.

Changes/features:

• New to_dict() method can be used to convert entity instance to dictionary. This method can be useful when you need to serialize an object to JSON or other format

Bugfixes:

• Now select() function and filter() method of the query object can accept lambdas with closures
• Some minor bugs were fixed

Pony ORM release 0.5.1

Changes/features:

Before this release, if a text attribute was defined without the max length specified (e.g. name = Required(unicode)), Pony set the maximum length equal to 200 and used SQL type VARCHAR(200). Actually, PostgreSQL and SQLite do not require specifying the maximum length for strings. Starting with this release such text attributes are declared as TEXT in SQLite and PostgreSQL. In these DBMSes, the TEXT datatype has the same performance as VARCHAR(N) and doesn't have arbitrary length restrictions.

For other DBMSes default varchar limit was increased up to 255 in MySQL and to 1000 in Oracle.

Bugfixes:

• Correct parsing of datetime values with T separator between date and time
• Entity.delete() bug fixed
• Lazy attribute loading bug fixed

Pony ORM 0.5.post1

Bugfix release

Pony ORM 0.5

• New transaction model (link)
• New method Query.filter() allows step-by-step query construction (link)
• New method Database.bind() simplifies testing and allows using different settings for development and production (link)
• New method Query.page() simplifies pagination (link)
• New method MyEntity.select_random(N) is effective for large tables (link)
• New method Query.random(N) for selecting random instances (link)
• Support of new concat() function inside declarative queries
• New before_insert(), before_update(), before_delete() entity instance hooks which can be overridden
• Ability to specify sequence_name='seq_name' for PrimaryKey attributes for Oracle database
• Ability to create new entity instances specifying the value of the primary key instead of the object
• Ability to read entity object attributes outside of the db_session
• Ability to use lambdas as a reference to an entity in relationship attribute declarations (link)
• The names of tables, indexes and constraints in the database creation script now are sorted in the alphabetical order
• In MySQL and PostgreSQL Pony converts the table names to the lower case. In Oracle – to the upper case. In SQLite leaves as is.
• The option options.MAX_FETCH_COUNT is set to None by default now
• The support of PyGreSQL is discontinued, using psycopg2 instead
• Added pony.__version__ attribute
• Multiple bugs were fixed
• Stability and performance improvements