Free entity software for linux

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.

XML::DOM::EntityReference is an XML ENTITY reference in XML::DOM.

XML::DOM::EntityReference extends XML::DOM::Node.

EntityReference objects may be inserted into the structure model when an entity reference is in the source document, or when the user wishes to insert an entity reference. Note that character references and references to predefined entities are considered to be expanded by the HTML or XML processor so that characters are represented by their Unicode equivalent rather than by an entity reference.

Moreover, the XML processor may completely expand references to entities while building the structure model, instead of providing EntityReference objects. If it does provide such objects, then for a given EntityReference node, it may be that there is no Entity node representing the referenced entity; but if such an Entity exists, then the child list of the EntityReference node is the same as that of the Entity node. As with the Entity node, all descendants of the EntityReference are readonly.

The resolution of the children of the EntityReference (the replacement value of the referenced Entity) may be lazily evaluated; actions by the user (such as calling the childNodes method on the EntityReference node) are assumed to trigger the evaluation.

Torrentocracy (pronounced like the word democracy) is the combination of RSS, bit torrent, your television and your remote control. In effect, it is what gives any properly motivated person or entity the ability to have their own TV station.

By running torrentocracy on a computer connected to your television, you not only become a viewer of any available content from the internet, but you also become a part of a vast grass roots media distribution network.

This is not about the illegal distribution of media, but rather its about enabling an entirely new way to receive the video which you watch on your TV.

If you ever wondered how and when your computer, the internet and your television would merge into one seemless device with access to anything and everything, then at this very moment the theme song from 2001: A Space Odyssey ("Also Sprach Zarathustra") should be resounding through your head.

Mimicry is a mail post-postprocessor daemon. It is easy to extend since the actual processing gets done in plugins. Mail messages are received and sent with SMTP.
Current functionality includes adding disclaimers to messages and compressing attachments on the fly. Selection of attachments to be processed is based on MIME-type, filename, receipient, sender, and (to a certain extent) the position of the message part within the message.
Main features:
- Programmed in perl
- A daemon that receives and sends mails via SMTP
- A program to inspect and manipulate mail parts (mime entities) within an SMTP flow
- Easily extendable by outsourcing the actual processing to plugins that get loaded during startup
- Coded with flexibility in mind
- Filterspecification with perl regular expressions
- A configuration file where you can specify lists of actions to be executed on mail parts, based on
- (envelope) sender and recipient
- mime type and path of mime types from top level entity to inspected entity
- recommended filenames
- and (to a certain extent) the position of the part within the mails mime tree
- And of course: licensed under the GPL

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.

XML::DOM::Element is an XML element node in XML::DOM.

XML::DOM::Element extends XML::DOM::Node.

By far the vast majority of objects (apart from text) that authors encounter when traversing a document are Element nodes. Assume the following XML document:

< elementExample id="demo" >
< subelement1/ >
< subelement2 >< subsubelement/ >< /subelement2 >
< /elementExample >

When represented using DOM, the top node is an Element node for "elementExample", which contains two child Element nodes, one for "subelement1" and one for "subelement2". "subelement1" contains no child nodes.

Elements may have attributes associated with them; since the Element interface inherits from Node, the generic Node interface method getAttributes may be used to retrieve the set of all attributes for an element. There are methods on the Element interface to retrieve either an Attr object by name or an attribute value by name.

In XML, where an attribute value may contain entity references, an Attr object should be retrieved to examine the possibly fairly complex sub-tree representing the attribute value. On the other hand, in HTML, where all attributes have simple string values, methods to directly access an attribute value can safely be used as a convenience.