#!/usr/bin/env python

# -*- coding: utf8 -*-

# ============================================================================

# Copyright (c) nexB Inc. http://www.nexb.com/ - All rights reserved.

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

# http://www.apache.org/licenses/LICENSE-2.0

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ============================================================================

"""

AboutCode toolkit is a tool to process ABOUT files. ABOUT files are

small text files that document the provenance (aka. the origin and

license) of software components as well as the essential obligation

such as attribution/credits and source code redistribution. See the

ABOUT spec at http://dejacode.org.

AboutCode toolkit reads and validates ABOUT files and collect software

components inventories.

"""

import json

import os

import posixpath

from requests import get, head, exceptions

import sys

import traceback

from itertools import zip_longest

from urllib.parse import urljoin

from urllib.parse import urlparse

from license_expression import Licensing

from packageurl import PackageURL

from attributecode import __version__

from attributecode import CRITICAL

from attributecode import ERROR

from attributecode import INFO

from attributecode import WARNING

from attributecode import api

from attributecode import Error

from attributecode import saneyaml

from attributecode import gen

from attributecode import util

from attributecode.transform import write_excel

from attributecode.util import add_unc

from attributecode.util import boolean_fields

from attributecode.util import copy_license_notice_files

from attributecode.util import copy_file

from attributecode.util import csv

from attributecode.util import file_fields

from attributecode.util import filter_errors

from attributecode.util import get_spdx_key_and_lic_key_from_licdb

from attributecode.util import is_valid_name

from attributecode.util import on_windows

from attributecode.util import norm

from attributecode.util import replace_tab_with_spaces

from attributecode.util import wrap_boolean_value

from attributecode.util import UNC_PREFIX

from attributecode.util import ungroup_licenses

from attributecode.util import ungroup_licenses_from_sctk

genereated_tk_version = "# Generated with AboutCode Toolkit Version %s \n\n" % __version__

class Field(object):

"""

An ABOUT file field. The initial value is a string. Subclasses can and

will alter the value type as needed.

"""

def __init__(self, name=None, value=None, required=False, present=False):

# normalized names are lowercased per specification

self.name = name

# save this and do not mutate it afterwards

if isinstance(value, str):

self.original_value = value

# elif value:

# Don't convert it to string. Leave the format as-is

# self.original_value = repr(value)

else:

self.original_value = value

# can become a string, list or OrderedDict() after validation

self.value = value or self.default_value()

self.required = required

# True if the field is present in an About object

self.present = present

self.errors = []

def default_value(self):

return ""

def validate(self, *args, **kwargs):

"""

Validate and normalize thyself. Return a list of errors.

"""

errors = []

name = self.name

self.value = self.default_value()

if not self.present:

# required fields must be present

if self.required:

msg = "Field %(name)s is required"

errors.append(Error(CRITICAL, msg % locals()))

return errors

else:

# present fields should have content ...

# The boolean value can be True, False and None

# The value True or False is the content of boolean fields

if not name in boolean_fields and not self.has_content:

# ... especially if required

if self.required:

msg = "Field %(name)s is required and empty"

severity = CRITICAL

else:

severity = INFO

msg = "Field %(name)s is present but empty."

errors.append(Error(severity, msg % locals()))

else:

# present fields with content go through validation...

# first trim any trailing spaces on each line

if isinstance(self.original_value, str):

value = "\n".join(s.rstrip() for s in self.original_value.splitlines(False))

# then strip leading and trailing spaces

value = value.strip()

else:

value = self.original_value

self.value = value

try:

validation_errors = self._validate(*args, **kwargs)

errors.extend(validation_errors)

except Exception as e:

emsg = repr(e)

msg = "Error validating field %(name)s: %(value)r: %(emsg)r"

errors.append(Error(CRITICAL, msg % locals()))

raise

# set or reset self

self.errors = errors

return errors

def _validate(self, *args, **kwargs):

"""

Validate and normalize thyself. Return a list of errors.

Subclasses should override as needed.

"""

return []

def _serialized_value(self):

return self.value if self.value else ""

def serialize(self):

"""

Return a unicode serialization of self in the ABOUT format.

"""

name = self.name

value = self.serialized_value() or ""

if self.has_content or self.value:

value = value.splitlines(True)

# multi-line

if len(value) > 1:

# This code is used to read the YAML's multi-line format in

# ABOUT files

# (Test: test_loads_dumps_is_idempotent)

if value[0].strip() == "|" or value[0].strip() == ">":

value = " ".join(value)

else:

# Insert '|' as the indicator for multi-line follow by a

# newline character

value.insert(0, "|\n")

# insert 4 spaces for newline values

value = " ".join(value)

else:

# FIXME: See https://github.com/nexB/aboutcode-toolkit/issues/323

# The yaml.load() will throw error if the parsed value

# contains ': ' character. A work around is to put a pipe, '|'

# to indicate the whole value as a string

if value and ": " in value[0]:

value.insert(0, "|\n")

# insert 4 spaces for newline values

value = " ".join(value)

else:

value = "".join(value)

serialized = "%(name)s:" % locals()

if value:

serialized += " " + "%(value)s" % locals()

return serialized

def serialized_value(self):

"""

Return a unicode serialization of self in the ABOUT format.

Does not include a white space for continuations.

"""

return self._serialized_value() or ""

@property

def has_content(self):

return self.original_value

def __repr__(self):

name = self.name

value = self.value

required = self.required

has_content = self.has_content

present = self.present

r = "Field(name=%(name)r, value=%(value)r, required=%(required)r, present=%(present)r)"

return r % locals()

def __eq__(self, other):

"""

Equality based on string content value, ignoring spaces.

"""

return (

isinstance(other, self.__class__)

and self.name == other.name

and self.value == other.value

)

class StringField(Field):

"""

A field containing a string value possibly on multiple lines.

The validated value is a string.

"""

def _validate(self, *args, **kwargs):

errors = super(StringField, self)._validate(*args, **kwargs)

no_special_char_field = [

"license_expression",

"license_key",

"license_name",

"declared_license_expression",

"other_license_expression ",

]

name = self.name

if name in no_special_char_field:

val = self.value

special_char = detect_special_char(val)

if special_char:

msg = (

"The following character(s) cannot be in the %(name)s: "

"%(special_char)r" % locals()

)

errors.append(Error(ERROR, msg))

return errors

def _serialized_value(self):

return self.value if self.value else ""

def __eq__(self, other):

"""

Equality based on string content value, ignoring spaces

"""

if not (isinstance(other, self.__class__) and self.name == other.name):

return False

if self.value == other.value:

return True

# compare values stripped from spaces. Empty and None are equal

if self.value:

sval = "".join(self.value.split())

if not sval:

sval = None

if other.value:

oval = "".join(other.value.split())

if not oval:

oval = None

if sval == oval:

return True

class SingleLineField(StringField):

"""

A field containing a string value on a single line. The validated value is

a string.

"""

def _validate(self, *args, **kwargs):

errors = super(SingleLineField, self)._validate(*args, **kwargs)

if self.value and isinstance(self.value, str) and "\n" in self.value:

name = self.name

value = self.original_value

msg = "Field %(name)s: Cannot span multiple lines: %(value)s" % locals()

errors.append(Error(ERROR, msg))

return errors

class ListField(StringField):

"""

A field containing a list of string values, one per line. The validated

value is a list.

"""

def default_value(self):

return []

def _validate(self, *args, **kwargs):

errors = super(ListField, self)._validate(*args, **kwargs)

# reset

self.value = []

if isinstance(self.original_value, str):

values = self.original_value.splitlines(False)

elif isinstance(self.original_value, list):

values = self.original_value

else:

values = [repr(self.original_value)]

for val in values:

if isinstance(val, str):

val = val.strip()

if not val:

name = self.name

msg = "Field %(name)s: ignored empty list value" % locals()

errors.append(Error(INFO, msg))

continue

# keep only unique and report error for duplicates

if val not in self.value:

self.value.append(val)

else:

name = self.name

msg = "Field %(name)s: ignored duplicated list value: %(val)r" % locals()

errors.append(Error(WARNING, msg))

return errors

def _serialized_value(self):

return self.value if self.value else ""

def __eq__(self, other):

"""

Equality based on sort-insensitive values

"""

if not (isinstance(other, self.__class__) and self.name == other.name):

return False

if self.value == other.value:

return True

# compare values stripped from spaces.

sval = []

if self.value and isinstance(self.value, list):

sval = sorted(self.value)

oval = []

if other.value and isinstance(other.value, list):

oval = sorted(other.value)

if sval == oval:

return True

class PackageUrlField(StringField):

"""

A Package URL field. The validated value is a purl.

"""

def _validate(self, *args, **kwargs):

"""

Check that Package URL is valid. Return a list of errors.

"""

errors = super(PackageUrlField, self)._validate(*args, **kwargs)

name = self.name

val = self.value

if not self.is_valid_purl(/sitelet?url=https%3A%2F%2Fgithub.com%2Faboutcode-org%2Faboutcode-toolkit%2Fblob%2Fdevelop%2Fsrc%2Fattributecode%2Fval):

msg = "Field %(name)s: Invalid Package URL: %(val)s" % locals()

errors.append(Error(WARNING, msg))

return errors

@staticmethod

def is_valid_purl(/sitelet?url=https%3A%2F%2Fgithub.com%2Faboutcode-org%2Faboutcode-toolkit%2Fblob%2Fdevelop%2Fsrc%2Fattributecode%2Fpurl):

"""

Return True if a Package URL is valid.

"""

try:

return bool(PackageURL.from_string(purl))

except:

return False

class UrlListField(ListField):

"""

A URL field. The validated value is a list of URLs.

"""

def _validate(self, *args, **kwargs):

"""

Check that URLs are valid. Return a list of errors.

"""

errors = super(UrlListField, self)._validate(*args, **kwargs)

name = self.name

val = self.value

for url in val:

if not self.is_valid_url(/sitelet?url=https%3A%2F%2Fgithub.com%2Faboutcode-org%2Faboutcode-toolkit%2Fblob%2Fdevelop%2Fsrc%2Fattributecode%2Furl):

msg = "Field %(name)s: Invalid URL: %(val)s" % locals()

errors.append(Error(WARNING, msg))

return errors

@staticmethod

def is_valid_url(/sitelet?url=https%3A%2F%2Fgithub.com%2Faboutcode-org%2Faboutcode-toolkit%2Fblob%2Fdevelop%2Fsrc%2Fattributecode%2Furl):

"""

Return True if a URL is valid.

"""

scheme, netloc, _path, _p, _q, _frg = urlparse(url)

valid = scheme in ("http", "https", "ftp") and netloc

return valid

class UrlField(StringField):

"""

A URL field. The validated value is a URL.

"""

def _validate(self, *args, **kwargs):

"""

Check that URL is valid. Return a list of errors.

"""

errors = super(UrlField, self)._validate(*args, **kwargs)

name = self.name

val = self.value

if not self.is_valid_url(/sitelet?url=https%3A%2F%2Fgithub.com%2Faboutcode-org%2Faboutcode-toolkit%2Fblob%2Fdevelop%2Fsrc%2Fattributecode%2Fval):

msg = "Field %(name)s: Invalid URL: %(val)s" % locals()

errors.append(Error(WARNING, msg))

return errors

@staticmethod

def is_valid_url(/sitelet?url=https%3A%2F%2Fgithub.com%2Faboutcode-org%2Faboutcode-toolkit%2Fblob%2Fdevelop%2Fsrc%2Fattributecode%2Furl):

"""

Return True if a URL is valid.

"""

scheme, netloc, _path, _p, _q, _frg = urlparse(url)

valid = scheme in ("http", "https", "ftp") and netloc

return valid

class PathField(ListField):

"""

A field pointing to one or more paths relative to the ABOUT file location.

The validated value is an ordered dict of path->location or None.

The paths can also be resolved

"""

def default_value(self):

return {}

def _validate(self, *args, **kwargs):

"""

Ensure that paths point to existing resources. Normalize to posix

paths. Return a list of errors.

base_dir is the directory location of the ABOUT file used to resolve

relative paths to actual file locations.

"""

errors = super(PathField, self)._validate(*args, **kwargs)

self.about_file_path = kwargs.get("about_file_path")

self.running_inventory = kwargs.get("running_inventory")

self.base_dir = kwargs.get("base_dir")

self.reference_dir = kwargs.get("reference_dir")

if self.base_dir:

self.base_dir = util.to_posix(self.base_dir)

name = self.name

# Why are paths a dict?

# Ans: The reason why the PathField use a dict is because

# for the FileTextField, the key is used as the path to the file and

# the value is used as the context of the file

# dict of normalized paths to a location or None

paths = {}

for path_value in self.value:

p = path_value.split(",")

for path in p:

path = path.strip()

path = util.to_posix(path)

# normalize eventual / to .

# and a succession of one or more ////// to . too

if path.strip() and not path.strip(posixpath.sep):

path = "."

# removing leading and trailing path separator

# path are always relative

path = path.strip(posixpath.sep)

# the license files, if need to be copied, are located under the path

# set from the 'license-text-location' option, so the tool should check

# at the 'license-text-location' instead of the 'base_dir'

if not (self.base_dir or self.reference_dir):

msg = (

"Field %(name)s: Unable to verify path: %(path)s:"

" No base directory provided" % locals()

)

errors.append(Error(ERROR, msg))

location = None

paths[path] = location

continue

if self.reference_dir:

location = posixpath.join(self.reference_dir, path)

else:

# The 'about_resource' should be a joined path with

# the 'about_file_path' and the 'base_dir

if not self.running_inventory and self.about_file_path:

# Get the parent directory of the 'about_file_path'

afp_parent = posixpath.dirname(self.about_file_path)

# Create a relative 'about_resource' path by joining the

# parent of the 'about_file_path' with the value of the

# 'about_resource'

arp = posixpath.join(afp_parent, path)

normalized_arp = posixpath.normpath(arp).strip(posixpath.sep)

location = posixpath.join(self.base_dir, normalized_arp)

else:

location = posixpath.normpath(posixpath.join(self.base_dir, path))

location = util.to_native(location)

location = os.path.abspath(os.path.normpath(location))

location = util.to_posix(location)

location = add_unc(location)

if not os.path.exists(location):

# We don't want to show the UNC_PREFIX in the error message

location = util.to_posix(location.strip(UNC_PREFIX))

msg = "Field %(name)s: Path %(location)s not found" % locals()

# We want to show INFO error for 'about_resource'

if name == "about_resource":

errors.append(Error(INFO, msg))

else:

errors.append(Error(CRITICAL, msg))

location = None

paths[path] = location

self.value = paths

return errors

class AboutResourceField(PathField):

"""

Special field for about_resource. self.resolved_paths contains a list of

the paths resolved relative to the about file path.

"""

def __init__(self, *args, **kwargs):

super(AboutResourceField, self).__init__(*args, **kwargs)

self.resolved_paths = []

def _validate(self, *args, **kwargs):

errors = super(AboutResourceField, self)._validate(*args, **kwargs)

return errors

class IgnoredResourcesField(PathField):

"""

Special field for ignored_resources. self.ignored_paths contains a list of

path patterns (glob patterns) which are not part of the summarization provided

by the ABOUT file.

"""

def __init__(self, *args, **kwargs):

super(AboutResourceField, self).__init__(*args, **kwargs)

self.resolved_paths = []

def _validate(self, *args, **kwargs):

errors = super(AboutResourceField, self)._validate(*args, **kwargs)

return errors

class FileTextField(PathField):

"""

A path field pointing to one or more text files such as license files.

The validated value is an ordered dict of path->Text or None if no

location or text could not be loaded.

"""

def _validate(self, *args, **kwargs):

"""

Load and validate the texts referenced by paths fields. Return a list

of errors. base_dir is the directory used to resolve a file location

from a path.

"""

errors = super(FileTextField, self)._validate(*args, **kwargs)

# a FileTextField is a PathField

# self.value is a paths to location ordered dict

# we will replace the location with the text content

name = self.name

for path, location in self.value.items():

if not location:

# do not try to load if no location

# errors about non existing locations are PathField errors

# already collected.

continue

try:

# TODO: we have lots the location by replacing it with a text

location = add_unc(location)

with open(location, encoding="utf-8", errors="replace") as txt:

text = txt.read()

self.value[path] = text

except Exception as e:

# only keep the first 100 char of the exception

emsg = repr(e)[:100]

msg = (

"Field %(name)s: Failed to load text at path: "

"%(path)s "

"with error: %(emsg)s" % locals()

)

errors.append(Error(ERROR, msg))

# set or reset self

self.errors = errors

return errors

class BooleanField(SingleLineField):

"""

An flag field with a boolean value. Validated value is False, True or None.

"""

def default_value(self):

return None

true_flags = ("yes", "y", "true", "x")

false_flags = ("no", "n", "false")

flag_values = true_flags + false_flags

def _validate(self, *args, **kwargs):

"""

Check that flag are valid. Convert flags to booleans. Default flag to

False. Return a list of errors.

"""

errors = super(BooleanField, self)._validate(*args, **kwargs)

self.about_file_path = kwargs.get("about_file_path")

flag = self.get_flag(self.original_value)

if flag is False:

name = self.name

val = self.original_value

about_file_path = self.about_file_path

flag_values = self.flag_values

msg = (

"Path: %(about_file_path)s - Field %(name)s: Invalid flag value: %(val)r is not "

"one of: %(flag_values)s" % locals()

)

errors.append(Error(ERROR, msg))

self.value = None

elif flag is None:

name = self.name

msg = "Field %(name)s: field is present but empty. " % locals()

errors.append(Error(INFO, msg))

self.value = None

else:

if flag == "yes" or flag is True:

self.value = True

else:

self.value = False

return errors

def get_flag(self, value):

"""

Return a normalized existing flag value if found in the list of

possible values or None if empty or False if not found or original value

if it is not a boolean value

"""

if value is None or value == "":

return None

if isinstance(value, bool):

return value

else:

if isinstance(value, str):

value = value.strip()

if not value:

return None

value = value.lower()

if value in self.flag_values:

if value in self.true_flags:

return "yes"

else:

return "no"

else:

return False

else:

return False

@property

def has_content(self):

"""

Return true if it has content regardless of what value, False otherwise

"""

if self.original_value:

return True

return False

def _serialized_value(self):

# default normalized values for serialization

if self.value:

return "yes"

elif self.value is False:

return "no"

else:

# self.value is None

# TODO: should we serialize to No for None???

return ""

def __eq__(self, other):

"""

Boolean equality

"""

return (

isinstance(other, self.__class__)

and self.name == other.name

and self.value == other.value

)

class BooleanAndTwoCharactersField(SingleLineField):

"""

Field with either a boolean value or character(s) value (at most 2

characters). Validated value is False, True, None or character value.

"""

def default_value(self):

return None

true_flags = ("yes", "y", "true", "x")

false_flags = ("no", "n", "false")

flag_values = true_flags + false_flags

def _validate(self, *args, **kwargs):

"""

Check that flag are valid with either boolean value or character value.

Default flag to False. Return a list of errors.

"""

errors = super(BooleanAndTwoCharactersField, self)._validate(*args, **kwargs)

self.about_file_path = kwargs.get("about_file_path")

flag = self.get_value(self.original_value)

if flag is False:

name = self.name

val = self.original_value

about_file_path = self.about_file_path

flag_values = self.flag_values

msg = (

"Path: %(about_file_path)s - Field %(name)s: Invalid value: %(val)r is not "

"one of: %(flag_values)s and it is not a 1 or 2 character value." % locals()

)

errors.append(Error(ERROR, msg))

self.value = None

elif flag is None:

name = self.name

msg = "Field %(name)s: field is present but empty. " % locals()

errors.append(Error(INFO, msg))

self.value = None

else:

if flag == "yes" or flag is True:

self.value = True

elif flag == "no":

self.value = False

else:

self.value = flag

return errors

def get_value(self, value):

"""

Return a normalized existing value if found in the list of

possible values or None if empty or False if not found or original value

if it is not a boolean value

"""

if value is None or value == "":

return None

if isinstance(value, bool):

return value

else:

if isinstance(value, str):

value = value.strip()

if not value:

return None

value = value.lower()

if value in self.flag_values or len(value) <= 2:

if value in self.true_flags:

return "yes"

elif value in self.false_flags:

return "no"

else:

return value

else:

return False

else:

return False

@property

def has_content(self):

"""

Return true if it has content regardless of what value, False otherwise

"""

if self.original_value:

return True

return False

def _serialized_value(self):

# default normalized values for serialization

if self.value:

if isinstance(self.value, bool):

return "yes"

else:

return self.value

elif self.value is False:

return "no"

else:

# self.value is None

# TODO: should we serialize to No for None???

return ""

def validate_fields(fields, about_file_path, running_inventory, base_dir, reference_dir=None):

"""

Validate a sequence of Field objects. Return a list of errors.

Validation may update the Field objects as needed as a side effect.

"""

errors = []

for f in fields:

val_err = f.validate(

base_dir=base_dir,

about_file_path=about_file_path,

running_inventory=running_inventory,

reference_dir=reference_dir,

)

errors.extend(val_err)

return errors

def validate_field_name(name):

if not is_valid_name(name):

msg = (

"Field name: %(name)r contains illegal name characters "

"(or empty spaces) and is ignored."

)

return Error(WARNING, msg % locals())

class License:

"""

Represent a License object

"""

def __init__(self, key, name, filename, url, text):

self.key = key

self.name = name

self.filename = filename

self.url = url

self.text = text

class About(object):

"""

Represent an ABOUT file and functions to parse and validate a file.

"""

# special names, used only when serializing lists of ABOUT files to CSV or

# similar

# name of the attribute containing the relative ABOUT file path

ABOUT_FILE_PATH_ATTR = "about_file_path"

# name of the attribute containing the resolved relative Resources paths

about_resource_path_attr = "about_resource_path"

# name of the attribute containing the resolved relative Resources paths

ABOUT_RESOURCE_ATTR = "about_resource"

# Required fields

required_fields = ["name"]

def get_required_fields(self):

return [f for f in self.fields if f.required]

def set_standard_fields(self):

"""

Create fields in an ordered dict to keep a standard ordering. We

could use a metaclass to track ordering django-like but this approach

is simpler.

"""

self.fields = dict(

[

("about_resource", AboutResourceField()),

("ignored_resources", AboutResourceField()),

("name", SingleLineField(required=True)),

("version", SingleLineField()),

("download_url", UrlField()),

("description", StringField()),

("homepage_url", UrlField()),

("package_url", PackageUrlField()),

("notes", StringField()),

("license_expression", SingleLineField()),

("license_key", ListField()),

("license_name", ListField()),

("license_file", FileTextField()),

("license_url", UrlListField()),

("spdx_license_expression", SingleLineField()),

("spdx_license_key", ListField()),

("declared_license_expression", SingleLineField()),

("other_license_expression", SingleLineField()),

("copyright", StringField()),

("notice_file", FileTextField()),

("notice_url", UrlField()),

("redistribute", BooleanField()),

("attribute", BooleanAndTwoCharactersField()),

("track_changes", BooleanField()),

("modified", BooleanField()),

("internal_use_only", BooleanField()),

("changelog_file", FileTextField()),

("owner", StringField()),

("owner_url", UrlField()),

("contact", StringField()),

("author", StringField()),

("author_file", FileTextField()),

("vcs_tool", SingleLineField()),

("vcs_repository", SingleLineField()),

("vcs_path", SingleLineField()),

("vcs_tag", SingleLineField()),

("vcs_branch", SingleLineField()),

("vcs_revision", SingleLineField()),

("checksum_md5", SingleLineField()),

("checksum_sha1", SingleLineField()),

("checksum_sha256", SingleLineField()),

("spec_version", SingleLineField()),

]

)

for name, field in self.fields.items():

# we could have a hack to get the actual field name

# but setting an attribute is explicit and cleaner

field.name = name

setattr(self, name, field)

def __init__(self, location=None, about_file_path=None, strict=False):

"""

Create an instance.

If strict is True, raise an Exception on errors. Otherwise the errors

attribute contains the errors.

"""

self.set_standard_fields()

self.custom_fields = {}

self.errors = []

# about file path relative to the root of an inventory using posix

# path separators

self.about_file_path = about_file_path

# os native absolute location, using posix path separators

self.location = location

self.base_dir = None

if self.location:

self.base_dir = os.path.dirname(location)

self.errors.extend(self.load(location))

if strict and self.errors and filter_errors(self.errors):

msg = "\n".join(map(str, self.errors))

raise Exception(msg)

def __repr__(self):

return repr(self.all_fields())

def __eq__(self, other):

"""

Equality based on fields and custom_fields., i.e. content.

"""

return (

isinstance(other, self.__class__)

and self.fields == other.fields

and self.custom_fields == other.custom_fields

)

def all_fields(self):

"""

Return the list of all Field objects.

"""

return list(self.fields.values()) + list(self.custom_fields.values())

def as_dict(self):

"""

Return all the standard fields and customer-defined fields of this

About object in an ordered dict.

"""