Free entity relationship software for linux

Bio::Ontology::Relationship is a relationship for an ontology.

SYNOPSIS

$rel = Bio::Ontology::Relationship->new( -identifier => "16847",
-subject_term => $subj,
-object_term => $obj,
-predicate_term => $pred );

This is a basic implementation of Bio::Ontology::RelationshipI.

The terminology we use here is the one commonly used for ontologies, namely the triple of (subject, predicate, object), which in addition is scoped in a namespace (ontology). It is called triple because it is a tuple of three ontology terms.

There are other terminologies in use for expressing relationships. For those who it helps to better understand the concept, the triple of (child, relationship type, parent) would be equivalent to the terminology chosen here, disregarding the question whether the notion of parent and child is sensible in the context of the relationship type or not. Especially in the case of ontologies with a wide variety of predicates the parent/child terminology and similar ones can quickly become ambiguous (e.g., A synthesises B), meaningless (e.g., A binds B), or even conflicting (e.g., A is-parent-of B), and are therefore strongly discouraged.

Term::Animation is a Perl module that provides a framework to produce sprite animations using ASCII art. Each ASCII sprite is given one or more frames, and placed into the animation as an animation entity.

An animation entity can have a callback routine that controls the position and frame of the entity. The module can also do collision detection between entities.

INSTALLATION

To install this module type the following:

perl Makefile.PL
make
make test
make install

Open Blue Lab is an enterprise resource planning system.
Whatever your goal is, the objective of this tool is to provide you the ready-to use stuff to create, update, search and view data you need for your application.
Moreover, this stuff is provided with the latest UI goodies like AJAX support that will ensure you the best feeling you never had in browsing.
Like OpenBlueLab.org project is portal aware, that means you have aggregation and personalization too.
That way, you can focus on your added value : the business logic and requirements your customer needs.
Main features:
- to collaborate and communicate better
- to manage your personal time
- to schedule your appointments
- to define and track personal and group project
- to manage your content (asset, document, ...)
- to manage your customer relationship
- to make coffee (not yet, next release maybe
We want to develop a product, free, that fits exactly your needs, so read this web site and take time to indicate us your requirements. They will appear on our todo list, maybe in a long time, but they will. Then, you may incitate people to contribute in your direction by sponsoring somebody to achieve it.
This product is completely free. You can even package it and sell it. If you wonder what is our business model, you can ask to the forum.
Built on java technology, you may download the GUI installer, double-click and use it (with all your entreprise) through your preferred browser, whatever your environment is.
Built on XML and REST technology, you may integrate (in synchronous or asynchronous mode) it very easily in your environment too.
Enhancements:
- In class diagrams, all entities (classes, attributes, and methods) are documented in order to allow HTML documentation generation.
- Some calculating methods were added.
- Inventory evaluation class diagrams were deleted from the model.
- Some changes were made in flowing modes between units of cost analysis.
- iReport reporting was integrated.

EuroMath2 project is a platform for editors editing various XML files with multiple namespaces. Able to contain and manage editors with WYSIWYG capability.
By default it contains:
- a basic XSL-FO editor, capable of editing XML documents transformable to XSL-FO,
- a read-only support for SVG and MathML,
- a (very incomplete) XHTML support (implemented using a stylesheet capable of transforming XHTML into the XSL-FO)
The power of EuroMath2 lies in its extendability by plugins. EuroMath2 offers well-defined XML processing engine extendable by custom plugins and/or XSLT stylesheets. Custom editors may use the default editor, that offers wizards for complex document modification operations. EuroMath comes in two favours: a standalone application, and an Eclipse plugin. For more information how to download and run EuroMath please see the download section.
Main features:
- Open-source, free software released under the MPL1.1 license
- Fully customizable transformers executing XSLT scripts or Eclipse Java plugins.
- XML element/attribute autocompletion driven by custom DTD, XML Schema, Relax, RelaxNG, Trex
- Entity support
- Fully supports documents with multiple namespaces

XML::Mini::Element::Entity Perl module is used internally to represent < !ENTITY name "stuff" >.

You shouldnt need to use it directly, see XML::Mini::Elements entity() method.

Tiny ERP is a free enterprise management software. Tiny ERP project covers all domains for small to medium businesses; accounting, stock management, customer relationship, sales, purchases, project management, ...
Main features:
- CRM & SRM
- Management and financial accounting
- Double-entry stock management
- Monitoring sales
- Automating tasks
- Human Ressources
- Managing and monitoring purchases

Elixir is a declarative layer on top of SQLAlchemy. The project is a fairly thin wrapper, which provides the ability to define model objects following the Active Record design pattern, and using a DSL syntax similar to that of the Ruby on Rails ActiveRecord system.

Elixir does not intend to replace SQLAlchemys core features, but instead focuses on providing a simpler syntax for defining model objects when you do not need the full expressiveness of SQLAlchemys manual mapper definitions.

Examples:

The Elixir source distribution includes a sample web application that uses the TurboGears web application framework. The application builds upon the tutorials Movie model to create a simple store for buying movies.

The Video Store sample application also includes an example of how to use Elixir with the TurboGears "identity" framework for security and authorization. If you are planning to use Elixir with your TurboGears application, and need to support authorization using identity, you can use this model as a basis:

from turbogears.database import metadata, session
from elixir import Unicode, DateTime, String, Integer
from elixir import Entity, has_field, using_options
from elixir import has_many, belongs_to, has_and_belongs_to_many
from sqlalchemy import ForeignKey
from datetime import datetime

class Visit(Entity):
has_field(visit_key, String(40), primary_key=True)
has_field(created, DateTime, nullable=False, default=datetime.now)
has_field(expiry, DateTime)
using_options(tablename=visit)

@classmethod
def lookup_visit(cls, visit_key):
return Visit.get(visit_key)

class VisitIdentity(Entity):
has_field(visit_key, String(40), primary_key=True)
has_field(user_id, Integer, ForeignKey(tg_user.user_id, name=user_id_fk, use_alter=True), index=True)
using_options(tablename=visit_identity)

class Group(Entity):
has_field(group_id, Integer, primary_key=True)
has_field(group_name, Unicode(16), unique=True)
has_field(display_name, Unicode(255)),
has_field(created, DateTime, default=datetime.now)
has_and_belongs_to_many(users, of_kind=User, inverse=groups)
has_and_belongs_to_many(permissions, of_kind=Permission, inverse=groups)
using_options(tablename=tg_group)

class User(Entity):
has_field(user_id, Integer, primary_key=True)
has_field(user_name, Unicode(16), unique=True)
has_field(email_address, Unicode(255), unique=True)
has_field(display_name, Unicode(255))
has_field(password, Unicode(40))
has_field(created, DateTime, default=datetime.now)
has_and_belongs_to_many(groups, of_kind=Group, inverse=users)
using_options(tablename=tg_user)

@property
def permissions(self):
perms = set()
for g in self.groups:
perms = perms | set(g.permissions)
return perms

class Permission(Entity):
has_field(permission_id, Integer, primary_key=True)
has_field(permission_name, Unicode(16), unique=True)
has_field(description, Unicode(255))
has_and_belongs_to_many(groups, of_kind=Group, inverse=permissions)
using_options(tablename=permission)

More Elixir examples are coming soon, and we would appreciate any additional sample applications that you could provide to illustrate more complex mappings.