Stalker Changes — Stalker v0.1.1.a9 documentation

### Navigation

- index
- next |
- previous |
- Stalker v0.1.1.a9 documentation »

# Stalker Changes

## v0.1.1.a9

> - Introduced `Type`. A new class to define types. With this introduction, all the classes deriving from `TypeEntity` (and the TypeEntity it self) are removed from Stalker.
> - Added an attribute called `type` to the `SimpleEntity`. Which will be used to create new types to the derived classes.
> - Introduced a new attribute called `__strictly_typed__` to all the classes (by the means of the EntityMeta), which will force the class to have a proper (not None) `type`.
> - `SimpleEntity` now has its own test module.
> - `TypeTemplate` is renamed to `FilenameTemplate` to reflect its duty more clearly.
> - fixed the tests for the `db`. Previously each of the tests were creating an instance of a specific class then storing it in the database, retrieved it back and then comparing the instances, one just created and one queried from the database. The problem was that, SA was returning the same instance (can be checked with id(instance)) so in any case they were equal, it was not possible to compare them and get a meaningful difference to see if the database part worked properly. Now, all the attributes of the original instance are stored in new variables and then the original instance is deleted, and the a new one is retrieved back from the database, and all the attributes are compared with the stored ones. (probably there are other good ways)
> - fixed `nice_name` in the `SimpleEntity`, if the instance is created by using `__new__` (like in SA) then the `nice_name` attribute was not initialized correctly.
> - fixed mapping of `lead` attribute in `Department` class.
> - fixed `device_aspect` attribute in `ImageFormat`, it is now correctly calculated when the instance is created with `__new__` instead of `__init__`
> - fixed mapping of `users` attribute in `Project` class.
> - fixed mapping of `duration` attribute in `Project` class (also possibly fixed all the classes mixed with `ScheduleMixin`)
> - fixed mapping of `lead` attribute in `Sequence` class
> - updated the behavior of `users` attribute in `Project` class. Now the list of `User`s are gathered from the `Task`s of the `Project` and from the `Sequence`s, the `Shot`s and the `Asset`s of the same `Project`.
> - updated the behavior of `project` attribute in class `User` class. Now the list of `Project`s are gathered from all the `Task`s assigned to the current `User`.
> - The `Group` class is renamed to `PermissionGroup`.
> - The default duration for the `ScheduleMixin` is now defined by the `stalker.conf.defaults.DEFAULT_TASK_DURATION` attribute.
> - The `ScheduleMixin` class now accepts a third argument called `duration`.
> - The `duration` attribute in the `ScheduleMixin` is now a settable. See the `ScheduleMixin` class documentation for details.
> - The `due_date` in `ScheduleMixin` doesn’t accept `datetime.timedelta` objects anymore.
> - The behavior of `start_date`, `due_date` and `duration` in `ScheduleMixin` is updated.
> - Added `CircularDependencyError`.
> - All the `ValueError`s are converted to `TypeError`s in the `ValidatedList`.
> - Finished the implementation of `Task` class.
> - Updated the formatting of the `code` attribute in `SimpleEntity` class. See the documentation of the `SimpleEntity` class for details.0
> - Updated the `code` attribute in `User`.
> - Updated all the exceptions raised by the SOM classes. Now they are correctly raising `TypeError` and ValueError``s.
> - added a new mixin class called `ProjectMixin`.
> - `Sequence`, `Asset` and `Task` classes are now using the `ProjectMixin` mixin class instead of implementing this common feature by themselfs.
> - added `ProjectMixinDB` for classes which are mixed with `ProjectMixin`.
> - `ValidatedList` now accepts a third argument called the `validator` which should be a callable, which is called when any of the methods of the `ValidatedList` is called and the list of elements are modified. The list of elements modified will be passed to the validator function where the first argument is a list containing the elements added and the last argument is a list contatining the elements removed.
> - `resources` in `Task` is now updating the `tasks` attribute in the `User` class.
> - `tasks` is not an argument for the `User` anymore. It was meaningles to have the `Task`s in the initialization of the `User` instances.
> - `User` classes `projects` attribute is now gathered by looking at the `project` attribute of the `Task`s in the `tasks` attribute.
> - `StatusList` now accepts classes for the `target_entity_type` argument.
> - `ReferenceMixin` now accepts anything derived from the `Entity`.
> - `Task` class now has a `part_of` attribute which accepts `SimpleEntity` instances and shows which entity is this task a part of.

## v0.1.1.a8

> - From now on an `Asset` instance can not be created without a `AssetType` object defining the type of the current `Asset`. This is done to prevent creation of `Asset`s without a certain type.

> - Fixed `Project` where it was not raising a ValueError properly for `sequence`, `assets` and `users` attributes when the assigned value is not iterable.

> - Fixed `Department` where it was not raising a ValueError properly for `members` attribute when the assigned value is not iterable.

> - Changed the representaion string of the `Shot` to <Shot (Shot.code, Shot.code)> because the `name` is not meaningful.

> - Changed the way `EntityMeta` metaclass working. It is now using the `__new__` method and the `dict_` of the class to set the attributes.

> - The `EntityMeta` now adds another attribute called `plural_name` to the classes, which shows the plural form of the class name. By default it tries to set it to a good name using plural form rules of English but if the name has an irregular plural name (or it is not in English) you can override this attribute by adding `plural_name` to the class attributes:

>       from stalker.core.models import SimpleEntity

>       class MyEntity(SimpleEntity):
>           plural_name = "MyEntities"
>           pass

> - From now on the table names are in the following format:

>   > - The plural name of the class if the table belongs to one class
>   > - The class1.__name__ + “_” + class2.plural_name if the table is a join join table

> - Updated the table names in the `stalker.db.mixin` module

## v0.1.1.a7

> - Updated the Stalker Development Roadmap to reflect the current development history and cycle

> - Merged all the model classes which were previously in separate files in to `stalker.core.models` module, to make it easy to use (and possibly hard to develop)

> - All the references to modules or classes or anything in the source codes are now represented by an absolute path in the docs ( `stalker.core.models.User` instead of `User`)

> - moved the `stalker.db.auth` to `stalker.ext.auth`

> - `stalker.core.models.User` class now uses the `stalker.ext.auth.set_password()` and `stalker.ext.auth.check_password()` utility functions to handle passwords. The user passwords are now always hidden, but not strongly encrypted.

> - The `stalker.ext.auth.session()` renamed to `stalker.ext.auth.create_session()` to reflect its functionality properly. And removed the return value from the function. Now it doesn’t return any bool value but None. To check if the user is already logged in use `stalker.ext.auth.SESSION` dictionary as follows:

>       from stalker.ext import auth

>       # initialize the session
>       auth.create_session()

>       # check if there is a user
>       if auth.SESSION_KEY in auth.SESSION:
>           print "There is a logged in user"
>       else:
>           print "There is no logged in user"

> - `stalker.ext.auth.authenticate()` updated to use `stalker.ext.auth.check_password()`

> - Fixed the `last_login` attribute in the database mapper, it was set as a synonym for it self.

> - Removed the `tearDown` methods in `tests.db.test_db`, there are problems with cleaning the mappers and disposing the engine, so instead of killing them the db.setup is called over and over again with different in memory databases.

> - From now on the `code` attribute doesn’t format the given string value too heavily, to allow more individual naming conventions to work with Stalker.

> - Updated How To Contribute

> - Renamed the `PipelineStep` to `TaskType` and changed the idea behind the relation between `AssetType` and `Task`

> - `stalker.core.models.AssetType` classes `pipeline_steps` attribute has been renamed to `task_types`

> - Fixed a little error in the mapper of `stalker.core.models.Structure`

> - Re-implemented the `stalker.ext.auth.login()` function and updated the tests accordingly.

> - All the error classes in `stalker.core.models` moved to `stalker.core.errors`

> - Added a new error class called `stalker.core.errors.DBError`

> - Fixed a bug in `stalker.db.__mappers__`, it is now possible to add new mappers without deleting the previous `stalker.conf.defaults.MAPPERS` list.

> - Removed the `AssetType` and derived the `Shot` and `Asset` classes from `Entity`.

> - Moved the mixin classes from `stalker.core.models` to `stalker.core.mixins`

> - Introduced the `TaskMixin` which gives the ability to connect a list of tasks to the mixed in class. Also added the mapper setup for this mixin.

> - `ValidatedList` now accepts string values for the `type_` argument.

> - Added `Shot` class and test for it.

> - Updated the `Sequence` database tests according to new rules introduced with the `Shot` class.

> - `ValidatedList` now imports the given types lazily when the type is given as a string path.

> - `Sequence` now needs a `Project` instance to be created.

> - It is now possible to assign `Task`s to `Project` and `Sequence`s. Also updated the tests for this change.

> - Removed the `shots` argument from the `Sequence` class initialization. Because there is no way to create a `Shot` without a `Sequence` instance.

> - Added tests for mixin initialization for `Project`, `Sequence`, `Shot` and `Asset` classes.

> - Fixed a bug in `Project` where it was always initializing the references with an empty list no matter what is given.

> - Fixed a bug in `Project` where it was always initializing the `start_date` to datetime.date.today and the `due_date` to 10 days later then the `start_date` no matter what are given.

> - Fixed a bug in `ReferenceMixin` where it was not initializing the reference attribute correctly.

> - Fixed a bug in `Asset` where the `project` attribute was not correctly getting the given `Project` instance.

> - Added the mappers and tables for `Shot` class.

> - Updated database model tests to test all the attributes of the models.

## v0.1.1.a6

> - updated/fixed tests for `stalker.ext.validatedList.ValidatedList`

> - updated a couple of tests to increase tests coverage

> - `stalker.core.models.status.Status` class instances now can be compared to string or unicode values

> - A `stalker.core.models.status.Status` object in a `stalker.core.models.status.StatusList` can now be accessed by its name as the index in `stalker.core.models.status.StatusList` only while getting the item.

> - Added `stalker.core.models.mixin.ScheduleMixin` which introduces date variables like, start_date, due_date and duration to the mixed in class.

> - Removed some parts of the `stalker.core.models.project.Project` class which are now satisfied by the `stalker.core.models.mixin.ScheduleMixin`

> - Improved the implementation of the `stalker.db.auth` module

> - removed the `stalker.db.__setup__` module which were helping to reference the variables in `stalker.db` module but it is not needed any more

> - It is now possible to initialize a `stalker.core.models.project.Project` object without a `stalker.core.models.repository.Repository`, `stalker.core.models.structure.Structure` or an `stalker.core.models.imageFormat.ImageFormat` or a `stalker.core.models.types.ProjectType`

> - Updated the Tutorial

> - From now on, in a `stalker.core.models.entity.SimpleEntity`, setting the code attribute to None or empty string will not raise any `ValueError`s but will re-initialize the `code` value from the `nice_name` attribute.

> - Implemented `stalker.core.models.sequence.Sequence` class along with its tests

> - added `stalker.core.models.sequence.Sequence` equality tests

> - improved `stalker.core.models.project.Project` equality tests

> - Implemented `stalker.core.models.assetBase.AssetBase` class along with its tests

> - The index.rst of the documentation now references the README from the project root.

> - added the basic implementation of `stalker.core.models.task.Task` and `stalker.core.models.shot.Shot` and mapped them very basically to be able to test the dependent classes like `stalker.core.models.assetBase.AssetBase` and `stalker.core.models.sequence.Sequence`

> - Added mappers and tables for `stalker.core.models.assetBase.AssetBase`

> - Now all the mixin classes have proper `__init__()` methods, and in a mixed class, the mixin classes’ `__init__()` method can be called directly by giving the current object instance (self) like shown below:

>       class ANewEntity(entity.SimpleEntity, mixin.StatusMixin):
>           def __init__(self, **kwargs):
>               super(ANewEntity, self).__init__(**kwargs)
>               mixin.StatusMixin.__init__(self, **kwargs)

>   and it can be repeated for any number of mixins in class inheritance path

> - Added the CHANGELOG to the documentation, and updated all formating of the mentioned references inside the file.

## v0.1.1.a5

> - removed the `stalker.core.models.entity.StatusedEntity` and its tests, with the introduction of `stalker.core.models.mixin.StatusMixin`, it is not necessary any more

> - added camera_lens.py to the examples, which shows how to extend SOM in its very basic form, also added tests testing this example

> - changed the database uri for the DatabaseTester, it now uses an in memory SQLite database instead a file based one.

> - Updated the version numbers in the roadmap

> - Added `last_login` attribute to `stalker.core.models.user.User` class tables and mapped it

> - because it was taking too much space in the diffs the VUE file which shows the design sketches has been removed from the trunk

> - added the `stalker.ext.validatedList.ValidatedList` class which is a list derivative that accepts only one type of object.

> - these SOM classes listed below uses `stalker.ext.validatedList.ValidatedList` in their list attributes requiring specific types of objects to be assigned:

>   > - `stalker.core.models.entity.Entity`
>   > - `stalker.core.models.status.StatusList`
>   > - `stalker.core.models.structure.Structure`
>   > - `stalker.core.models.types.AssetType`
>   > - `stalker.core.models.department.Department`
>   > - `stalker.core.models.user.User`
>   > - `stalker.core.models.mixin.ReferenceMixin`

> - added tests of the `stalker.core.models.project.Project` class

> - completed the first implementation of the `stalker.core.models.project.Project` class

> - to be able to use assertIsInstance method of `mocker.MockerTestCase` all the `unittest.TestCase` test classes are converted to `mocker.MockerTestCase`

> - changed the design of the stalker.db.mixins.ReferenceMixin.setup and stalker.db.mixins.StatusMixin.setup to organize the mixin classes’ database setup helper functions, now they are converted to classes with a classmethod called `stalker.db.mixin.ReferenceMixinDB.setup()` doing all the functionality of the previous setup function and placed them under the `stalker.db.mixin` module.

> - added persistence tests for `stalker.core.models.project.Project`

> - fixed secondary table generation for `stalker.core.models.mixin.ReferenceMixin`, the table is now created only if it doesn’t exists already, and it is retrieved from `stalker.db.metadata` if it exists

## v0.1.1.a4

> - changed the arguments of the `stalker.db.mixins.ReferenceMixin.setup()` function, to allow carrying the data from one to the next mixin (this part still needs a lot of attention)
> - removed the unnecessary `statusedEntity_statuses` secondary table, because one `stalker.core.models.entity.StatusedEntity` owns just one `stalker.core.models.status.StatusList` its a many2one relation, so no need to have a secondary table
> - introduced the `stalker.core.models.mixin.StatusMixin` (will replace StatusedEntity soon)
> - Added a new example for the usage of `stalker.core.models.mixin.StatusMixin`
> - Updated the `stalker.db.mixins.ReferenceMixin.setup()` function, now it takes three arguments, the class, the table and the mapper_options dictionary.

## v0.1.1.a3

> - Removed the included tests from the egg build

> - Added/fixed equality and inequality operators for classes:

>   > - `stalker.core.models.department.Department`
>   > - `stalker.core.models.entity.StatusedEntity`

> - `stalker.core.models.entity.SimpleEntity` now has a **kwargs in the `__init__()` so it doesn’t give `TypeError` for extra keywords

> - added `stalker.core.models.entity.EntityMeta` metaclass which adds `entity_type` attribute and sets its value to the unicode version of the name of the class

> - the `stalker.core.models.entity.SimpleEntity` uses the `stalker.core.models.entity.EntityMeta` metaclass to automatically add all the `entity_type` attribute to all the derived classes

> - all the mappers now uses the `ClassName.entity_type` class attribute as the polymorphic discriminator (polymorphic identity)

> - instead of LBYL moving toward EAFP idiom for all the models in the `stalker.core`

> - `stalker.core.models.status.StatusList` now supports indexing

> - `stalker.core.models.status.StatusList` now has an `target_entity_type` attribute which accepts strings with the class name and shows the compatible class of this `stalker.core.models.status.StatusList`

> - `stakler.core.models.status.StatusList.__eq__()` now checks for the `target_entity_type` also

> - `stalker.core.models.status.StatusedEntity` now checks for the given `stalker.core.models.StatusList.target_entity_type` for compability with the current class

> - All the validation methods in the `stalker.core.models` now has the validate word in their name instead of check

> - Little fixes:

>   > - the mapper of `stalker.core.models.types.TypeTemplate` was trying to setup a synonym to a parameter with the same name (file_code)

>   > - `stalker.core.models.user.User` classes `_sequence_lead`

>   >     attribute renamed to `_sequences_lead`

> - Added persistence tests for `stalker.core.models.entity.StatusedEntity`

> - Added `stalker.utils.path_to_exec()` which converts the given module full paths to an executable python code which imports the given python object to the current namespace

> - Added `entity_types` table to hold the possible entity types in Stalker. The content of the table comes from the `stalker.conf.defaults.CORE_MODEL_CLASSES` list. And possibly going to be extended by the users.

> - Added `stalker.db.__setup__.__fill_entity_types_table__()` which fills the `entity_types` table with default values.

> - `stalker.core.models.user.User` class now has `initials` attribute, which is automatically calculated from the first and last name if there is no one given.

> - Atarted developing the `stalker.core.models.message.Message` class

> - Added the `stalker.core.models.mixin` module which holds the common mixins

> - Added the `stalker.core.models.mixin.ReferenceMixin` class which gives reference abilities to mixed in classes

> - Added the database part of the `stalker.core.models.mixin.ReferenceMixin`. Now it is possible to create a new type of entity and mix it with ReferenceMixin and also persist it in the database. But it needs a lot of effort before to have something usable.

> - Added examples module, which holds usage examples and recipes

> - Added an example about how to create a new mixed in entity type for SOM.

## v0.1.1.a2

> - Updated the Tutorial

> - Added code attribute to `stalker.core.models.entity.SimpleEntity`

> - Updated the `stalker.core.models.user.User` class for the new code attribute, and also updated the tests to add tests for code attribute (simply copied the test code from `SimpleEntityTester`, bad code repetition, need to change it later, by may be inheriting the test case from the other one)

> - Updated the database tables and mappers for the new code attribute

> - Removed the clashing code attribute from `stalker.core.models.pipelineStep.PipelineStep` class and the tables and mappers.

> - Added `stalker.core.models.note.Note` class

> - Added `notes` table and a mapper for `stalker.core.models.note.Note` class

> - Added note attribute to `stalker.core.models.entity.Entity` class

> - Fixed `EntityTester` in tests

> - Added `__repr__` to entity classes

> - Added tests for persistence of `stalker.core.models.note.Note`` class

> - Added equality (__eq__) and inequality (__ne__) operators for classes:

>   > - `stalker.core.models.user.User`
>   > - `stalker.core.models.tag.Tag`
>   > - `stalker.core.models.status.Status`
>   > - `stalker.core.models.status.StatusList`
>   > - `stalker.core.models.imageFormat.ImageFormat`
>   > - `stalker.core.models.repository.Repository`
>   > - `stalker.core.models.pipelineStep.PipelineStep`
>   > - `stalker.core.models.structure.Structure`
>   > - `stalker.core.models.types.AssetType`
>   > - `stalker.core.models.types.LinkType`
>   > - `stalker.core.models.entity.TypeEntity`
>   > - `stalker.core.models.types.ProjectType`

> - `stalker.core.models.Status` classes’ short_name attribute has been removed, from now on the `code` attribute will be used, also updated the database tables and mappers

> - The `stalker.core.models.user.User.login_name` is now superior to the `stalker.core.models.user.User.name` attribute, giving both of them as arguments will lead the `login_name` to be used as both the `login_name` and the `name`

## v0.1.1.a1

> - Fixed a couple of documentation errors like:

>   > - Inheritance Diagram had references to modules
>   > - A couple of docstring documentation errors in `stalker.core.models.structure.Structure`, `stalker.core.models.user.User` and `stalker.core.models.types.TypeTemplate` classes

> - Updated Installation

> - Added Tutorial page to the documentation

> - All the classes, functions from SQLAlchemy are now imported to the `sqlalchemy` namespace, this will let the Sphinx to correctly include classes, functions from Stalker only

> - Removed the `db.meta module`, now all the functionalities supplied by `stalker.db.meta` are supplied by `db` itself (`db.meta.session` –> `db.session` etc.)

> - Added `query` variable to `stalker.db` module so instead of `db.session.query` now `db.query` can be used

> - Updated `stalker.db.auth.login_required()` decorator function, it now accepts a `view` function

> - Added `stalker.db.auth.permission_required()` decorator function

> - `name` attribute of `stalker.core.models.entity.SimpleEntity` is not any more forced to start with an upper case letter

> - From now on `login_name` is now a synonym for `name` in `stalker.core.models.user.User` class and just the `name` attribute is going to be stored in the database

> - To make things simple all the properties with name type_ is now using the name type even though it is a Python keyword, Python is clever enough to understand what is meant

## v0.1.1.a0

> - Changed the versioning scheme a little bit to follow the setuptools guide

## v0.1.0.20110111.1

> - Persistence tests for Link is now fixed
> - Now every table correctly has a `primary_key`

## v0.1.0.20110110.1

> - Added Installation to the documentation

> - Updated README file for PyPI

> - Added the package to PyPI

> - Fixed `StatusedEntityTester` test suit, now it properly creates mock `satlker.coer.models.status.StatusList` object for the `__eq__` and `__ne__` tests

> - Updated tables and mappers for `stalker.core.models.typeEntity.TypeTemplate`

> - Updated mappers for `stalker.core.models.typeEntity.AssetType`

> - `stalker.core.models.entity.TypeEntity` class is moved to `entity.py`, right beside the other entity classes

> - `typeEntity.py` renamed to `types.py`

> - Created tables and mappers for:

>   > - `stalker.core.models.structure.Structure`
>   > - `stalker.core.models.entity.TypeEntity`
>   > - `stalker.core.models.types.TypeTemplate`
>   > - `stalker.core.models.types.AssetType`
>   > - `stalker.core.models.types.LinkType`
>   > - `stalker.core.models.types.ProjectType`

> - Updated `simpleEntities` table, now the `name` by itself is not a unique constraint, but added an explicit `UniqueConstraint` on `name` and `entity_type` columns to allow entities with different types to have the same name, also added test for that.

> - Fixed all the errors in `test_db.py`, there are only failures left.

> - Added tests for `stalker.core.models.link.Link`, all the test are green for `stalker.core.models.link.Link` except the persistence tests.

## v0.1.0.20110108.1

> - `Template` class is renamed to `TypeTemplate` and moved inside `stalker.core.models.typeEntity` to prevent the name clashing with Jinja2 Template class
> - added `__eq__` to `stalker.core.models.entity.SimpleEntity` and still trying to add it to the derived classes
> - organized the project structure to conform setup tools for PyPI

## v0.1.0.20110107.2

> - updating the db tests
> - stalker.core.models.user.User class is now allowed to have its department to be set None

## v0.1.0.20110107.1

> - organized the existent tests

## v0.1.0.20110106.2

> - added nice_name property to the stalker.core.models.entity.SimpleEntity class
> - added tests for stalker.core.models.structure.Structure class
> - implemented the stalker.core.models.structure.Structure class
> - added last_login attribute to the stalker.core.models.user.User class and added all the tests

## v0.1.0.20110106.1

> - re-introduced the link.Link, which has a general meaning than reference.Reference (I bet it will be reference again tomorrow)
> - stalker.models moved to stalker.core.models
> - renamed tests/z_db to tests/db, because the sqlalchemy/mocker problem is solved by moving the models to core/models

## v0.1.0.20110105

> - improved the stalker.models.template.Template class documentation, and added an example showing the usage of it.

## v0.1.0.20110104

> - removed the link.Link and introduced reference.Reference and typeEntity.ReferenceType classes, which I think are more organized then the previous design.
> - reorganized the AssetType and ReferenceType objects by introducing the new TypeEntity class and deriving the AssetType and ReferenceType from this class
> - added ProjectType class to hold different project types (like Commercial, Film, Still etc., it is different than having a Commercial Structure object)
> - removed AssetTemplate and ReferenceTemplate concepts and generalized the Template class by adding a type parameter to it, which accepts TypeEntity and classes derived from TypeEntity.

## v0.1.0.20110103.2

> - added login_required decorator to the stalker.db.auth module, but the implementation is not done yet

## v0.1.0.20110103

> - user.User._password is now scrambled, but the password property uses the raw password
> - added stalker.db.auth for authentication, removed the db.login function.

## v0.1.0.20110102

> - added the error.LoginError exception for login errors
> - started to add tests for db.login function

## v0.1.0.20101231

> - moved the login function to the db.__init__ to let it used just after setting up the database without importing any new module
> - updated the example in the docstring of the template.AssetTemplate

## v0.1.0.20101229.3

> - generalized the Template class. Now every Entity can be assigned to a template, it is not limited with Assets or References.

## v0.1.0.20101229.2

> - entity.SimpleEntity.name now can have white spaces, but not at the beginning or end, just in the middle
> - done mapping template.Template class

## v0.1.0.20101229.1

> - trying to create a session system with Beaker, to hold user login information
> - done mapping assetType.AssetType class
> - done mapping pipelineStep class

## v0.1.0.20101228.1

> - added repositories table and mapper for the repository.Repository class
> - added imageFormats table and mapper for the imageFormat.ImageFormat class
> - renamed extensions module to ext
> - added roadmap to docs

## v0.1.0.20101228

> - created the block of database tests
> - added stalker.db.meta.__mappers__ list to hold the mappers and use it to check if anything is already mapped
> - added tests for db initialization
> - removed the whole stalker.models.unit module from SOM, only TimeUnit was usable in some cases, but in fact it is also not important, the only object using TimeUnit was the Project class and it can go well without it. Don’t need to make things more complex than it needs to be.
> - increased the version number to 0.1.0 to follow the stalker roadmap

## v0.0.1.20101227

> - the test_db is converted to a proper unittest which is testing all the models one by one
> - test/db renamed to test/z_db to let nose run it latest to solve the problem about mocker and sqlalchemy fighting each other.
> - Mapping syntax is changed a little bit, now to do the mapping, the <mapper>.setup() function needs to be called to be able to do the mapping any time
> - started adding tests for every class in SOM

## v0.0.1.20101226

> - in user.User the last_name attribute could be an empty string
> - removed SimpleEntity, TaggedEntity and introduced StatusedEntity to make the inheritance clear and let users to find somebody to blame by moving all the audit information to the the SimpleEntity class in which everything is inherited from. Now even a Tag has audit information.

## v0.0.1.20101225

> - entity.AuditEntity.created_by can now be None (for now)
> - user.User.last_name can now be None, to let users like admin have no last name
> - creating tables for catch the general inheritance of the entity classes
> - entitiy.SimpleEntity.name’s first letter is not capitalized any more
> - department.Department class now accepts Null for lead attribute (for now again)

## v0.0.1.20101224

> - started playing with the SQLAlchemy side of the system

## v0.0.1.20101223

> - updating the documentation
> - AuditEntity now accepts None for updated_by attribute when it an object is created, but sets it to the same value with created_by attribute

## v0.0.1.20101219

> - started to implement:

>   > - a database entry point
>   > - a customizable object model and database tables
>   > - an automatic mapper to map the objects and tables together according to user settings

>   things can change a lot in this phase, I’m just trying to figure out the best possible way to do it.

> - added a new entity type called TaggedEntity which derives from SimpleEntity, and moved all the tag related attributes of SimpleEntity to TaggedEntity, and all the child classes deriving from SimpleEntity now derives from TaggedEntity, also moved the tests related with tag in SimpleEntity to TaggedEntity.

> - tag.Tag now derives from the SimpleEntity and doesn’t add any other attribute to its super.

> - updated tests for tag.Tag

> - updated docs for TaggedEntity

> - finished implementing the Department object and its tests

> - removed the notes attribute from the Entity class

## v0.0.1.20101209

> - added the inheritance diagram as an rst page to reference it anywhere needed

> - added the empty classes for:

>   > - Asset
>   > - AssetBase
>   > - Booking
>   > - Shot
>   > - Structure
>   > - Template
>   > - Version

> - added the Department class

> - added inheritance diagrams to the autosummary pages of the classes

### Navigation

- index
- next |
- previous |
- Stalker v0.1.1.a9 documentation »