class Item(Base):
__tablename__ = 'item'
name = Column(String(250), nullable=False)
id = Column(Integer, primary_key=True)
description = Column(String(250))
picture = image_attachment('ItemPicture')
created_at = Column(
DateTime, default=datetime.now(), onupdate=datetime.now())
category_id = Column(Integer, ForeignKey('category.id'))
category = relationship(Category)
user_id = Column(Integer, ForeignKey('user.id'))
user = relationship(User)
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'name': self.name,
'description': self.description,
'id': self.id,
'category_id': self.category_id,
'created_at': self.created_at,
'creator_id': self.user_id,
}
class Antibody(Base):
__tablename__ = 'antibody'
name = Column(String(80), nullable=False)
id = Column(Integer, primary_key=True)
weight = Column(Float, nullable=False)
target = Column(String(80), nullable=False)
a_lot = relationship('AntibodyLot', cascade='all, delete-orphan')
picture = image_attachment('AntibodyImg')
user_id = Column(Integer, ForeignKey('user.id'))
user = relationship(User)
@property
def serialize(self):
try:
url = self.picture.locate()
except IOError:
url = ''
return {
"antibody_id": self.id,
"antibody_name": self.name,
"molecular_weight": self.weight,
"target": self.target,
"picture_url": url,
"user_id": self.user_id
}
class Something(Base):
id = Column(Integer, primary_key=True)
name = Column(String(100), nullable=False)
cover = image_attachment('SomethingCover')
__tablename__ = 'something'
class Manything(Base):
id = Column(Integer, primary_key=True)
name = Column(String(100), nullable=False)
covers = image_attachment('ManythingCover', uselist=True)
__tablename__ = 'manything'
class Publisher(db.Model, CRUDMixin):
"""
Publisher model class with two back referenced relationships, titles and
issues.
Example: Marvel Comics, Image Comics
"""
__tablename__ = 'publishers'
#: IDs
id = db.Column(db.Integer, primary_key=True)
#: Attributes
name = db.Column(db.String(255))
#: Images
logo = image_attachment('PublisherLogo')
logo_bw = image_attachment('PublisherLogoBW')
splash = image_attachment('PublisherSplash')
#: Colors
primary_color = db.Column(db.String(20), default='#aaaaaa')
secondary_color = db.Column(db.String(20), default='#aaaaaa')
#: Relationships
titles = db.relationship(
'Title',
backref=db.backref('publisher', lazy='joined'),
lazy='dynamic'
)
comics = db.relationship(
'Issue',
backref=db.backref('publisher', lazy='joined'),
lazy='dynamic'
)
@classmethod
def from_raw(cls, record):
record = deepcopy(record)
created = 0
try:
name = record.get('publisher')
publisher = cls.query.filter_by(name=name).first()
if not publisher:
publisher = cls.create(name=name)
created = created + 1
except Exception, err:
print 'Publisher failed creation: ', record.get('publisher')
print 'Error: ', err
db.session.rollback()
publisher = None
return (publisher, created)
class Samething(Base):
"""Not S'o'mething, but s'a'mething."""
id = Column(Integer, primary_key=True)
name = Column(String(100), nullable=False)
cover = image_attachment('SamethingCover')
__tablename__ = 'samething'
class Message(Base):
__tablename__ = 'message'
id = Column(Integer, primary_key=True)
chat_id = orm.relationship('Chat', back_populates='message_set')
text = Column(Text)
owner_id = Column(Integer, ForeignKey("user.id"))
owner = orm.relationship(User, back_populates='message_set')
date = Column(DateTime, default=datetime.datetime.utcnow)
image = image_attachment('UserPicture')
class Question(Base):
__tablename__ = "questions"
id = Column(Integer, primary_key=True, index=True)
header = Column(String, index=True)
details = Column(String, index=True)
creator_id = Column(Integer, ForeignKey("users.id"))
pictures = image_attachment("QuestionPicture", uselist=True)
creator = relationship("User", back_populates="questions")
class ItemPadre(Base):
__tablename__ = "item_padre"
id = Column(Integer, primary_key=True)
nombre = Column(String(50))
marca = Column(String(50))
foto = image_attachment('ItemPhoto')
items = relationship('Item', backref="parent")
def __repr__(self):
return "ItemPadre<-%s-,'%s','%s'>" % (self.id, self.nombre, self.marca)
class FoodSet(Base):
__tablename__ = 'food_set'
id = Column(Integer, primary_key=True)
settype = Column(String(100))
breakfastbool = Column(Boolean)
picture = image_attachment('FoodImage')
rating = Column(Integer, default=0)
total_rater = Column(Integer, default=0)
last_rated_at = Column(String(100), default='')
child = relationship("FoodImage", uselist=False, back_populates="parent")
class meal(Base,db.model):
""" Contains the information about the meals prepared"""
__tablename__="meal"
meal_calories=db.Column(db.Integer, nullable=False)
meal=db.Column(db.Integer, nullable=False)
meal_type=db.Column(db.String(80), nullable=False)
meal_id=db.Column(db.Integer, nullable=False, unique=True, primary_key=True)
meal_name=db.Column(db.String(80), nullable=False)
meal_image=image_attachment('mealPicture')
def __repr__(self):
return '<Meal for :{}>'.format(self.meal_id)
class Adc(Base):
__tablename__ = 'adc'
name = Column(String(80), nullable=False)
chemistry = Column(String(80), nullable=False)
id = Column(Integer, primary_key=True)
lot = relationship('AdcLot', cascade='all, delete-orphan')
picture = image_attachment('AdcImg')
user_id = Column(Integer, ForeignKey('user.id'))
user = relationship(User)
@property
def serialize(self):
return {
'adc_id': self.id,
'conjugation_chemistry': self.chemistry,
'picture_url': self.picture.locate(),
'user_id': self.user_id
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String, unique=True, nullable=False)
avatar = entity.image_attachment('UserAvatar')
albums = db.relationship('Album', back_populates='author')
stories = db.relationship('Story', back_populates='author')
@property
def avatar_url(self) -> Optional[str]:
with store_context(image_store):
try:
return self.avatar.locate()
except IOError:
pass
return None
def __repr__(self):
return '<User: %r>' % self.nickname
class User(Base):
"""User model."""
id = Column(Integer, primary_key=True, index=True, unique=True)
email = Column(
EmailType,
unique=True,
)
hashed_password = Column(String)
is_active = Column(Boolean, default=False)
_phone_number = Column(Unicode(20), unique=True)
image = image_attachment('UserPicture')
country_code = Column(Unicode(8))
nickname = Column(String(30), )
is_admin = Column(Boolean, default=False)
created = Column(DateTime, default=datetime.datetime.utcnow)
chat_set = orm.relationship("User_Chat", back_populates='user')
phone_number = orm.composite(PhoneNumber, _phone_number, country_code)
__tablename__ = "user"
class AlbumEntry(db.Model):
id = db.Column(db.Integer, primary_key=True)
album_id = db.Column(db.Integer, db.ForeignKey('album.id'), nullable=False)
order = db.Column(db.Integer, nullable=False)
caption = db.Column(db.String)
album = db.relationship('Album', back_populates='entries')
image = entity.image_attachment('AlbumImage')
@property
def image_url(self) -> Optional[str]:
with store_context(image_store):
try:
return self.image.locate()
except IOError:
pass
return None
def __repr__(self):
return '<AlbumEntry: %r>' % self.caption
class Cytotoxin(Base):
__tablename__ = 'cytotoxin'
name = Column(String(80), nullable=False)
id = Column(Integer, primary_key=True)
weight = Column(Float, nullable=False)
drug_class = Column(String(80), nullable=False)
lot = relationship('CytotoxinLot', cascade='all, delete-orphan')
picture = image_attachment('CytotoxinImg')
user_id = Column(Integer, ForeignKey('user.id'))
user = relationship(User)
@property
def serialize(self):
return {
'cytotoxin_id': self.id,
'molecular_weight': self.weight,
'drug_class': self.drug_class,
'picture_url': self.picture.locate(),
'user_id': self.user_id
}
class User(Base):
__tablename__: str = 'users'
id = Column(Integer, primary_key=True, index=True)
first_name = Column(String(100), nullable=True)
last_name = Column(String(100), nullable=True)
username = Column(String(100), nullable=False, unique=True)
gender = Column(String(10), nullable=True)
date_of_birth = Column(TIMESTAMP(timezone=True), nullable=True)
email = Column(String(256), nullable=True, unique=True, index=True)
phone_number = Column(String(15), nullable=True, unique=True)
hashed_password = Column(String(200), nullable=False)
# UserPicture please refer to file.mode.UserPicture
picture = image_attachment('UserPicture')
created_at = Column(TIMESTAMP(timezone=True), nullable=False,
server_default=func.now())
updated_at = Column(TIMESTAMP(timezone=True), server_default=func.now(), nullable=False,
onupdate=func.now())
active = Column(Boolean, default=False)
number_of_followers = Column(Integer, default=text('0'))
shop = relationship('Shop', uselist=False, back_populates='owner')
class Photo(Base):
__tablename__ = 'photo'
__with__ = ('image_url', 'writer', 'likes_count', 'comments_count')
id = s.Column(s.Integer, primary_key=True)
content = s.Column(s.Text, nullable=False)
writer_id = s.Column(s.Integer, s.ForeignKey('user.id',
ondelete='CASCADE'))
writer = relationship('User', primaryjoin=('Photo.writer_id==User.id'))
issue_id = s.Column(s.Integer, s.ForeignKey('issue.id',
ondelete='CASCADE'))
issue = relationship('Issue', primaryjoin='Photo.issue_id==Issue.id')
image = image_attachment('PhotoImage')
created_at = s.Column(s.DateTime, nullable=False, default=func.now())
@property
def image_url(self):
try:
img = self.image.find_thumbnail(width=600)
except NoResultFound:
img = None
if img is None:
if self.image.original is None:
return None
self.image.generate_thumbnail(width=600)
img = self.image.find_thumbnail(width=600)
return img.locate().split('?', 1)[0]
@property
def likes_count(self):
return Like.query.filter_by(photo=self).count()
@property
def comments_count(self):
return Comment.query.filter_by(photo=self).count()
class Story(db.Model):
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
title = db.Column(db.String)
flavour_text = db.Column(db.String)
fulltext_html = db.Column(db.String)
cover = entity.image_attachment('StoryCover')
author = db.relationship('User', back_populates='stories')
category = db.relationship('Category', back_populates='stories')
@property
def cover_url(self) -> Optional[str]:
with store_context(image_store):
try:
return self.cover.locate()
except IOError:
pass
return None
def __repr__(self):
return '<Story: %r>' % self.title
class User(db.Model):
"""
Initializes the User Table
Sets up the following columns
1. The Unique User Identifier (id)
2. The User's username (username)
3. The User's email (email)
4. The user's password (password)
5. The user's roles (roles)
6. The user's creation data (creation)
7. The user's bio (bio)
"""
id = db.Column(db.String(12), unique=True, primary_key=True)
username = db.Column(db.String(100), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(200), nullable=False)
roles = db.Column(db.Text)
created = db.Column(db.DateTime, index=True, default=datetime.utcnow)
bio = db.Column(db.Text)
picture = image_attachment('ProfilePicture')
default_role = "user"
admin_role = "admin"
banned_role = "banned"
"""
To be done
1. Setting up moderators for rooms
2. Creating the created column
created = db.Column(db.DateTime, index=True, default=datetime.utcnow)
"""
"""
Initializes the Followers table
Sets up the following columns
1. The ID of the follower (follower_id)
2. The ID of the user being followed (followed_id)
Sets as unique
"""
followers = db.Table(
'followers',
db.Column('follower_id', db.String(12), db.ForeignKey("user.id")),
db.Column('followed_id', db.String(12), db.ForeignKey("user.id")),
db.UniqueConstraint('follower_id', 'followed_id', name='uix_1'))
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
subscribed = db.relationship(
'Room',
secondary=Room.subscribers,
primaryjoin=(Room.subscribers.c.subscriber_username == username),
secondaryjoin=(Room.subscribers.c.subscribed_id == Room.id),
backref=db.backref('subscribers', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return f'<User: {self.username}>'
def __init__(self, username, email, roles):
""" Used for Initializing the User"""
self.username = username
self.email = email
self.roles = roles
super(User, self).__init__()
@property
def rolenames(self):
try:
return self.roles.split(',')
except Exception:
return []
@classmethod
def lookup(cls, username):
return cls.query.filter_by(username=username).one_or_none()
@classmethod
def identify(cls, id):
return cls.query.get(id)
@classmethod
def is_active():
return True
def is_authenticated(self):
return self.authenticated
def set_password(self, password):
self.password = guard.encrypt_password(password)
def set_email(self, email):
self.email = email
def set_username(self, username):
self.username = username
def set_id(self, id):
self.id = id
def set_role(self, role):
self.roles = role
def set_bio(self, bio):
self.bio = bio
def check_password(self, username, password):
return guard.authenticate(username, password)
def get_id(self):
return f"{self.id}"
def follow(self, user):
self.followed.append(user)
def unfollow(self, user):
self.followed.remove(user)
def subscribe(self, room):
self.subscribed.append(room)
def unsubscribe(self, room):
self.subscribed.remove(room)
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
name = Column(String(250))
email = Column(String(250), nullable=False)
picture = image_attachment('UserImg')
class DocumentAttachment(db.Model):
"""
An attachment for a document.
Some attachments might not be associated with a document. This happens when a new
document is being added and we don't yet have a document id. When the document is
fully created the attachment ids will be included in the request and linked to the
document.
We'll clean up stranded attachments periodically.
"""
__tablename__ = "attachments"
log = logging.getLogger(__name__)
id = Column(Integer, primary_key=True)
filename = Column(String(256), nullable=False)
mimetype = Column(String(256), nullable=False)
document_id = Column(Integer,
ForeignKey('documents.id', ondelete='CASCADE'),
index=True)
created_by_user_id = Column(Integer, ForeignKey('users.id'), index=True)
created_at = Column(DateTime(timezone=True),
index=True,
unique=False,
nullable=False,
server_default=func.now())
updated_at = Column(DateTime(timezone=True),
server_default=func.now(),
onupdate=func.current_timestamp())
# Associations
created_by = relationship("User", foreign_keys=[created_by_user_id])
image = image_attachment("AttachmentImage")
THUMBNAIL_HEIGHT = 100
_deleted_attachments = set()
def generate_thumbnails(self):
self.image.generate_thumbnail(height=self.THUMBNAIL_HEIGHT)
def set_data(self, data):
""" Set the data for this attachment from a file-like object. """
if self.mimetype == PDF:
if self.id is None:
db.session.add(self)
db.session.flush()
# save pdf to s3
filename = '%d/%s' % (self.id, self.filename)
current_store.put_file(data, 'document-attachment', filename, 0, 0,
self.mimetype, False)
data.seek(0)
# convert to an image for use with thumbnails
self.log.info("Converting PDF to image")
with WandImage(file=data, resolution=300) as img:
img.format = 'png'
data = StringIO()
img.save(file=data)
data.seek(0)
self.log.info("Converted")
self.image.from_file(data)
db.session.flush()
self.generate_thumbnails()
@property
def thumbnail_url(self):
return self.image.find_thumbnail(height=self.THUMBNAIL_HEIGHT).locate()
@property
def preview_url(self):
return self.image.original.locate()
@property
def download_url(self):
if self.mimetype == PDF:
filename = '%d/%s' % (self.id, self.filename)
return current_store.get_url('document-attachment', filename, 0, 0,
self.mimetype)
return self.image.original.locate()
def size_str(self):
return '%d,%d' % self.image.original.size
def delete_file(self):
if self.mimetype == PDF:
filename = '%d/%s' % (self.id, self.filename)
return current_store.delete_file('document-attachment', filename,
0, 0, self.mimetype)
def to_json(self):
return {
'id': self.id,
'url': self.preview_url,
'thumbnail_url': self.thumbnail_url,
'download_url': self.download_url,
'size': self.size_str(),
}
@classmethod
def is_acceptable(cls, upload):
"""
Is this `werkzeug.FileStorage` object a valid upload?
"""
return upload.mimetype in MIMETYPES
@classmethod
def from_upload(cls, upload, user=None, document=None):
"""
Create a new attachment from an uploaded file, a `werkzeug.FileStorage` object.
"""
attachment = DocumentAttachment()
attachment.document = document
attachment.filename = secure_filename(upload.filename)
attachment.mimetype = upload.mimetype
if user and user.is_authenticated():
attachment.created_by = user
# set the data and generate thumbnails
attachment.set_data(upload.stream)
return attachment
@classmethod
def _mark_attachment_deleted(cls, mapper, connection, target):
cls._deleted_attachments.add(target)
@classmethod
def _session_rollback(cls, session, previous_transaction):
cls._deleted_attachments.clear()
@classmethod
def _session_commit(cls, session):
if cls._deleted_attachments:
for attachment in cls._deleted_attachments:
attachment.delete_file()
cls._deleted_attachments.clear()
class User(Base):
__tablename__ = 'user'
__with__ = ('image_url', )
__ex__ = ('password', )
id = s.Column(s.Integer, primary_key=True)
#username definitions
_username = s.Column('username', s.String(20), nullable=False, unique=True)
@hybrid_property
def username(self):
"""User's unique name
"""
return self._username
@username.setter
def username(self, username):
if not username is None:
username = username.lower()
self._username = username
@validates('_username')
def _validate_username(self, key, username):
# FIXME
return username
#password definitions
_password = s.Column('password', s.String(128), nullable=True)
@hybrid_property
def password(self):
"""User's password
"""
return self._password
@password.setter
def password(self, password):
"""Setter of :data:`password`. It automatically hashes raw password.
:param password: raw password string.
"""
if password is None:
self._password = None
return
if password == '':
hashed = ''
else:
hashed = make_password(password)
self._password = hashed
@password.expression
def password(self):
return User._password
def check_password(self, password):
"""Checks password.
:param password: raw password string.
"""
return self.password == make_password(password)
image = image_attachment('UserImage')
created_at = s.Column(s.DateTime, nullable=False, default=func.now())
@property
def image_url(self):
if self.image.original is None:
return None
return self.image.locate()
class User(Base):
id = Column(Integer, primary_key=True)
name = Column(Unicode, nullable=False)
picture = image_attachment('UserFoodPicture')
class Service(db.Model):
"""Service model"""
id = db.Column(db.Integer, primary_key=True)
providerName = db.Column(db.String(100), nullable=False)
serviceHash = db.Column(db.String(100), unique=True)
txHash = db.Column(db.String(100))
serviceName = db.Column(db.String(100), nullable=False)
image = image_attachment('ServiceImage')
imageName = db.Column(db.String(30), default='default.png')
description = db.Column(db.Text, nullable=False)
type = db.Column(db.PickleType, nullable=False)
features = db.Column(db.PickleType, nullable=False)
region = db.Column(db.PickleType, nullable=False)
deployment = db.Column(db.Text, nullable=False)
leasingPeriod = db.Column(db.Text, nullable=False)
price = db.Column(db.Integer, nullable=False)
currency = db.Column(db.Text, nullable=False, default='USD')
reviews = db.relationship('Review', backref="service", lazy='dynamic')
__tablename__ = 'service'
def serialize(self,
cosine_similarity='',
jaccard_similarity='',
euclidean_distance='',
manhattan_distance='',
pearson_correlation='',
minkowski_distance='',
weighted_similarity=[]):
"""Return object data in easily serializable format"""
return {
'id': self.id,
'providerName': self.providerName,
'serviceName': self.serviceName,
'serviceHash': self.serviceHash,
'txHash': self.txHash,
'image': base64.b64encode(self.image.make_blob()).decode("utf-8"),
'description': self.description,
'type': self.type,
'features': self.features,
'region': self.region,
'deployment': self.deployment,
'leasingPeriod': self.leasingPeriod,
'price': self.price,
'currency': self.currency,
'reviews': [r.serialize for r in self.reviews],
'cosineSimilarity': cosine_similarity,
'jaccardSimilarity': jaccard_similarity,
'euclideanDistance': euclidean_distance,
'manhattanDistance': manhattan_distance,
'pearsonCorrelation': pearson_correlation,
'minkowskiDistance': minkowski_distance,
'weightedSimilarity': weighted_similarity
}
def json_to_obj(self, json):
self.providerName = json["provider"]
self.serviceName = json["productName"]
self.description = json["description"]
self.image = json["logo"]
self.imageName = json["fileName"]
self.region = json["region"]
self.type = json["serviceType"]
self.features = json["attackType"]
self.deployment = json["deploymentTime"]
self.leasingPeriod = json["leasingPeriod"]
self.price = json["price"]
self.txHash = json["txHash"]
self.serviceHash = json["serviceHash"]
return self
def form_to_obj(self, form, file):
self.providerName = form["provider"]
self.serviceName = form["productName"]
self.description = form["description"]
self.imageName = file.filename
self.region = form["region"].split()
self.type = form["serviceType"].split()
self.features = form["attackType"].split()
self.deployment = form["deploymentTime"]
self.leasingPeriod = form["leasingPeriod"]
self.price = form["price"]
self.txHash = form["txHash"]
self.serviceHash = form["serviceHash"]
return self
def __repr__(self):
return f"Service('{self.serviceName}', '{self.type}', '{self.region}', '{self.price}', '{self.currency}', '{self.txHash}', '{self.serviceHash}')"
class ImageContainer(Base):
__tablename__ = 'image_container'
uuid = Column(UUIDType, default=uuid.uuid4, primary_key=True)
image = image_attachment('Image')
class Issue(db.Model, CRUDMixin):
"""
Issue model class. Title and Publisher can both be referenced with
the hidden 'publisher' and 'title' attributes
Note: hybrid property is for sorting based on subscriber (user) number.
# http://stackoverflow.com/questions/22876946/how-to-order-by-count-of-many-to-many-relationship-in-sqlalchemy
"""
__tablename__ = 'issues'
#: IDs
id = db.Column(db.Integer, primary_key=True)
title_id = db.Column(db.Integer, db.ForeignKey('titles.id'))
publisher_id = db.Column(db.Integer, db.ForeignKey('publishers.id'))
#: Attributes
product_id = db.Column(db.String(100))
issue_number = db.Column(db.Numeric(precision=6, scale=2))
issues = db.Column(db.Numeric(precision=6, scale=2))
other = db.Column(db.String(255))
complete_title = db.Column(db.String(255))
one_shot = db.Column(db.Boolean(), default=False)
a_link = db.Column(db.String(255))
thumbnail = db.Column(db.String(255))
big_image = db.Column(db.String(255))
retail_price = db.Column(db.Float())
description = db.Column(db.Text())
on_sale_date = db.Column(db.Date())
prospective_release_date = db.Column(db.Date())
genre = db.Column(db.String(100))
people = db.Column(db.String(255)) #####
popularity = db.Column(db.Float())
last_updated = db.Column(db.DateTime())
diamond_id = db.Column(db.String(100))
old_diamond_id = db.Column(db.String(100))
discount_code = db.Column(db.String(1))
category = db.Column(db.String(100))
upc = db.Column(db.String(100))
#: Relationships
cover_image = image_attachment('IssueCover')
is_parent = db.Column(db.Boolean(), default=False)
has_alternates = db.Column(db.Boolean(), default=False)
@property
def alternates(self):
return self.query.filter(
Issue.title==self.title,
Issue.issue_number==self.issue_number,
Issue.diamond_id!=self.diamond_id).all()
@classmethod
def popular_issues(cls, date, count=10):
issues = cls.query.filter(
cls.on_sale_date==date,
cls.is_parent==True)\
.order_by(
cls.num_subscribers.desc(),
cls.complete_title.asc())\
.limit(count)\
.all()
return issues
@classmethod
def featured_issue(cls, date):
# The featured issue should always have a cover image. We check against
# that here.
issues = cls.popular_issues(date, count=5)
featured_issue = None
for issue in issues:
if issue.cover_image.original:
featured_issue = issue
break
return featured_issue
@classmethod
def from_raw(cls, record, sas_id='YOURUSERID'):
# Create Issue dictionary
i = deepcopy(record)
# Complete Title
try:
complete_title = record.get('complete_title')
# m = re.match(r'(?P<title>[^#]*[^#\s])\s*(?:#(?P<issue_number>(\d+))\s*)?(?:\(of (?P<issues>(\d+))\)\s*)?(?P<other>(.+)?)', title).groupdict()
m = re.match(r'(?P<title>[^#]*[^#\s])\s*(?:#(?P<issue_number>([+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?))\s*)?(?:\(of (?P<issues>(\d+))\)\s*)?(?P<other>(.+)?)', complete_title).groupdict()
i['complete_title'] = complete_title
if m['issue_number']:
i['issue_number'] = Decimal(m['issue_number'])
if m['issues']:
i['issues'] = Decimal(m['issues'])
if m.get('other'):
i['other'] = m['other'].strip('()')
except (AttributeError, TypeError):
i['complete_title'] = ''
m = None
# Retail Price
try:
retail_price = record.get('retail_price')
i['retail_price'] = float(retail_price) if is_float(retail_price) else None
except Exception, err:
i['retail_price'] = 0.00
# Affiliate Link
try:
a_link = record.get('a_link')
i['a_link'] = a_link.replace('YOURUSERID', sas_id)
except Exception, err:
i['a_link'] = None
