diff --git a/swh/model/hypothesis_strategies.py b/swh/model/hypothesis_strategies.py
index ca568ee..e9acfa1 100644
--- a/swh/model/hypothesis_strategies.py
+++ b/swh/model/hypothesis_strategies.py
@@ -1,235 +1,235 @@
 # Copyright (C) 2019 The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import attr
 import datetime
 
 from hypothesis.strategies import (
     binary, builds, characters, composite, dictionaries, from_regex,
     integers, just, lists, none, one_of, sampled_from, text, tuples,
 )
 
 
 from .from_disk import DentryPerms
 from .model import (
     Person, Timestamp, TimestampWithTimezone, Origin, OriginVisit,
     Snapshot, SnapshotBranch, TargetType, Release, Revision,
     Directory, DirectoryEntry, Content
 )
 from .identifiers import snapshot_identifier, identifier_to_bytes
 
 
 pgsql_alphabet = characters(
     blacklist_categories=('Cs', ),
     blacklist_characters=['\u0000'])  # postgresql does not like these
 
 
 def pgsql_text():
     return text(alphabet=pgsql_alphabet)
 
 
 def sha1_git():
     return binary(min_size=20, max_size=20)
 
 
 def sha1():
     return binary(min_size=20, max_size=20)
 
 
 @composite
 def urls(draw):
     protocol = draw(sampled_from(['git', 'http', 'https', 'deb']))
     domain = draw(from_regex(r'\A([a-z]([a-z0-9-]*)\.){1,3}[a-z0-9]+\Z'))
 
     return '%s://%s' % (protocol, domain)
 
 
 def persons():
     return builds(Person)
 
 
 def timestamps():
     max_seconds = datetime.datetime.max.replace(
         tzinfo=datetime.timezone.utc).timestamp()
     min_seconds = datetime.datetime.min.replace(
         tzinfo=datetime.timezone.utc).timestamp()
     return builds(
         Timestamp,
         seconds=integers(min_seconds, max_seconds),
         microseconds=integers(0, 1000000))
 
 
 def timestamps_with_timezone():
     return builds(
         TimestampWithTimezone,
         timestamp=timestamps(),
         offset=integers(min_value=-14*60, max_value=14*60))
 
 
 def origins():
     return builds(
         Origin,
         type=sampled_from(['git', 'hg', 'svn', 'pypi', 'deb']),
         url=urls())
 
 
 def origin_visits():
     return builds(
         OriginVisit,
         visit=integers(0, 1000),
-        origin=origins(),
+        origin=urls(),
         status=sampled_from(['ongoing', 'full', 'partial']),
         type=pgsql_text())
 
 
 @composite
 def releases(draw):
     (date, author) = draw(one_of(
         tuples(none(), none()),
         tuples(timestamps_with_timezone(), persons())))
     rel = draw(builds(
         Release,
         id=sha1_git(),
         author=none(),
         date=none(),
         target=sha1_git()))
     return attr.evolve(
         rel,
         date=date,
         author=author)
 
 
 def revision_metadata():
     return dictionaries(pgsql_text(), pgsql_text())
 
 
 def revisions():
     return builds(
         Revision,
         id=sha1_git(),
         date=timestamps_with_timezone(),
         committer_date=timestamps_with_timezone(),
         parents=lists(sha1_git()),
         directory=sha1_git(),
         metadata=one_of(none(), revision_metadata()))
     # TODO: metadata['extra_headers'] can have binary keys and values
 
 
 def directory_entries():
     return builds(
         DirectoryEntry,
         target=sha1_git(),
         perms=sampled_from([perm.value for perm in DentryPerms]))
 
 
 def directories():
     return builds(
         Directory,
         id=sha1_git(),
         entries=lists(directory_entries()))
 
 
 @composite
 def contents(draw):
     (status, data, reason) = draw(one_of(
         tuples(just('visible'), binary(), none()),
         tuples(just('absent'), none(), pgsql_text()),
         tuples(just('hidden'), binary(), none()),
     ))
 
     return draw(builds(
         Content,
         length=integers(min_value=0, max_value=2**63-1),
         sha1=sha1(),
         sha1_git=sha1_git(),
         sha256=binary(min_size=32, max_size=32),
         blake2s256=binary(min_size=32, max_size=32),
         status=just(status),
         data=just(data),
         reason=just(reason),
     ))
 
 
 def branch_names():
     return binary(min_size=1)
 
 
 def branch_targets_object():
     return builds(
         SnapshotBranch,
         target=sha1_git(),
         target_type=sampled_from([
             TargetType.CONTENT, TargetType.DIRECTORY, TargetType.REVISION,
             TargetType.RELEASE, TargetType.SNAPSHOT]))
 
 
 def branch_targets_alias():
     return builds(
         SnapshotBranch,
         target_type=just(TargetType.ALIAS))
 
 
 def branch_targets(*, only_objects=False):
     if only_objects:
         return branch_targets_object()
     else:
         return one_of(branch_targets_alias(), branch_targets_object())
 
 
 @composite
 def snapshots(draw, *, min_size=0, max_size=100, only_objects=False):
     branches = draw(dictionaries(
         keys=branch_names(),
         values=one_of(
             none(),
             branch_targets(only_objects=only_objects)
         ),
         min_size=min_size,
         max_size=max_size,
     ))
 
     if not only_objects:
         # Make sure aliases point to actual branches
         unresolved_aliases = {
             target.target
             for target in branches.values()
             if (target
                 and target.target_type == 'alias'
                 and target.target not in branches)
          }
 
         for alias in unresolved_aliases:
             branches[alias] = draw(branch_targets(only_objects=True))
 
     while True:
         try:
             id_ = snapshot_identifier({
                 'branches': {
                     name: branch.to_dict() if branch else None
                     for (name, branch) in branches.items()}})
         except ValueError as e:
             for (source, target) in e.args[1]:
                 branches[source] = draw(branch_targets(only_objects=True))
         else:
             break
     return Snapshot(
         id=identifier_to_bytes(id_),
         branches=branches)
 
 
 def objects():
     return one_of(
         origins().map(lambda x: ('origin', x)),
         origin_visits().map(lambda x: ('origin_visit', x)),
         snapshots().map(lambda x: ('snapshot', x)),
         releases().map(lambda x: ('release', x)),
         revisions().map(lambda x: ('revision', x)),
         directories().map(lambda x: ('directory', x)),
         contents().map(lambda x: ('content', x)),
     )
 
 
 def object_dicts():
     return objects().map(lambda x: (x[0], x[1].to_dict()))
diff --git a/swh/model/model.py b/swh/model/model.py
index baf4f54..8c31f6d 100644
--- a/swh/model/model.py
+++ b/swh/model/model.py
@@ -1,364 +1,363 @@
 # Copyright (C) 2018-2019 The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import datetime
 from enum import Enum
 from typing import List, Optional, Dict
 
 import attr
 import dateutil.parser
 
 from .identifiers import normalize_timestamp
 from .hashutil import DEFAULT_ALGORITHMS
 
 SHA1_SIZE = 20
 
 # TODO: Limit this to 20 bytes
 Sha1Git = bytes
 
 
 class BaseModel:
     """Base class for SWH model classes.
 
     Provides serialization/deserialization to/from Python dictionaries,
     that are suitable for JSON/msgpack-like formats."""
 
     def to_dict(self):
         """Wrapper of `attr.asdict` that can be overridden by subclasses
         that have special handling of some of the fields."""
 
         def dictify(value):
             if isinstance(value, BaseModel):
                 return value.to_dict()
             elif isinstance(value, Enum):
                 return value.value
             elif isinstance(value, dict):
                 return {k: dictify(v) for k, v in value.items()}
             elif isinstance(value, list):
                 return [dictify(v) for v in value]
             else:
                 return value
 
         ret = attr.asdict(self, recurse=False)
         return dictify(ret)
 
     @classmethod
     def from_dict(cls, d):
         """Takes a dictionary representing a tree of SWH objects, and
         recursively builds the corresponding objects."""
         return cls(**d)
 
 
 @attr.s(frozen=True)
 class Person(BaseModel):
     """Represents the author/committer of a revision or release."""
     name = attr.ib(type=bytes)
     email = attr.ib(type=bytes)
     fullname = attr.ib(type=bytes)
 
 
 @attr.s(frozen=True)
 class Timestamp(BaseModel):
     """Represents a naive timestamp from a VCS."""
     seconds = attr.ib(type=int)
     microseconds = attr.ib(type=int)
 
     @seconds.validator
     def check_seconds(self, attribute, value):
         """Check that seconds fit in a 64-bits signed integer."""
         if not (-2**63 <= value < 2**63):
             raise ValueError('Seconds must be a signed 64-bits integer.')
 
     @microseconds.validator
     def check_microseconds(self, attribute, value):
         """Checks that microseconds are positive and < 1000000."""
         if not (0 <= value < 10**6):
             raise ValueError('Microseconds must be in [0, 1000000[.')
 
 
 @attr.s(frozen=True)
 class TimestampWithTimezone(BaseModel):
     """Represents a TZ-aware timestamp from a VCS."""
     timestamp = attr.ib(type=Timestamp)
     offset = attr.ib(type=int)
     negative_utc = attr.ib(type=bool)
 
     @offset.validator
     def check_offset(self, attribute, value):
         """Checks the offset is a 16-bits signed integer (in theory, it
         should always be between -14 and +14 hours)."""
         if not (-2**15 <= value < 2**15):
             # max 14 hours offset in theory, but you never know what
             # you'll find in the wild...
             raise ValueError('offset too large: %d minutes' % value)
 
     @classmethod
     def from_dict(cls, d):
         """Builds a TimestampWithTimezone from any of the formats
         accepted by :py:`swh.model.normalize_timestamp`."""
         d = normalize_timestamp(d)
         return cls(
             timestamp=Timestamp.from_dict(d['timestamp']),
             offset=d['offset'],
             negative_utc=d['negative_utc'])
 
 
 @attr.s(frozen=True)
 class Origin(BaseModel):
     """Represents a software source: a VCS and an URL."""
     url = attr.ib(type=str)
     type = attr.ib(type=Optional[str], default=None)
 
     def to_dict(self):
         r = super().to_dict()
         r.pop('type', None)
         return r
 
 
 @attr.s(frozen=True)
 class OriginVisit(BaseModel):
     """Represents a visit of an origin at a given point in time, by a
     SWH loader."""
-    origin = attr.ib(type=Origin)
+    origin = attr.ib(type=str)
     date = attr.ib(type=datetime.datetime)
     status = attr.ib(
         type=str,
         validator=attr.validators.in_(['ongoing', 'full', 'partial']))
     type = attr.ib(type=str)
     snapshot = attr.ib(type=Sha1Git)
     metadata = attr.ib(type=Optional[Dict[str, object]],
                        default=None)
 
     visit = attr.ib(type=Optional[int],
                     default=None)
     """Should not be set before calling 'origin_visit_add()'."""
 
     def to_dict(self):
         """Serializes the date as a string and omits the visit id if it is
         `None`."""
         ov = super().to_dict()
         if ov['visit'] is None:
             del ov['visit']
         return ov
 
     @classmethod
     def from_dict(cls, d):
         """Parses the date from a string, and accepts missing visit ids."""
         d = d.copy()
         date = d.pop('date')
         return cls(
-            origin=Origin.from_dict(d.pop('origin')),
             date=(date
                   if isinstance(date, datetime.datetime)
                   else dateutil.parser.parse(date)),
             **d)
 
 
 class TargetType(Enum):
     """The type of content pointed to by a snapshot branch. Usually a
     revision or an alias."""
     CONTENT = 'content'
     DIRECTORY = 'directory'
     REVISION = 'revision'
     RELEASE = 'release'
     SNAPSHOT = 'snapshot'
     ALIAS = 'alias'
 
 
 class ObjectType(Enum):
     """The type of content pointed to by a release. Usually a revision"""
     CONTENT = 'content'
     DIRECTORY = 'directory'
     REVISION = 'revision'
     RELEASE = 'release'
     SNAPSHOT = 'snapshot'
 
 
 @attr.s(frozen=True)
 class SnapshotBranch(BaseModel):
     """Represents one of the branches of a snapshot."""
     target = attr.ib(type=bytes)
     target_type = attr.ib(type=TargetType)
 
     @target.validator
     def check_target(self, attribute, value):
         """Checks the target type is not an alias, checks the target is a
         valid sha1_git."""
         if self.target_type != TargetType.ALIAS:
             if len(value) != 20:
                 raise ValueError('Wrong length for bytes identifier: %d' %
                                  len(value))
 
     @classmethod
     def from_dict(cls, d):
         return cls(
             target=d['target'],
             target_type=TargetType(d['target_type']))
 
 
 @attr.s(frozen=True)
 class Snapshot(BaseModel):
     """Represents the full state of an origin at a given point in time."""
     id = attr.ib(type=Sha1Git)
     branches = attr.ib(type=Dict[bytes, Optional[SnapshotBranch]])
 
     @classmethod
     def from_dict(cls, d):
         return cls(
             id=d['id'],
             branches={
                 name: SnapshotBranch.from_dict(branch) if branch else None
                 for (name, branch) in d['branches'].items()
             })
 
 
 @attr.s(frozen=True)
 class Release(BaseModel):
     id = attr.ib(type=Sha1Git)
     name = attr.ib(type=bytes)
     message = attr.ib(type=bytes)
     target = attr.ib(type=Optional[Sha1Git])
     target_type = attr.ib(type=ObjectType)
     synthetic = attr.ib(type=bool)
     author = attr.ib(type=Optional[Person],
                      default=None)
     date = attr.ib(type=Optional[TimestampWithTimezone],
                    default=None)
     metadata = attr.ib(type=Optional[Dict[str, object]],
                        default=None)
 
     @author.validator
     def check_author(self, attribute, value):
         """If the author is `None`, checks the date is `None` too."""
         if self.author is None and self.date is not None:
             raise ValueError('release date must be None if author is None.')
 
     def to_dict(self):
         rel = super().to_dict()
         if rel['metadata'] is None:
             del rel['metadata']
         return rel
 
     @classmethod
     def from_dict(cls, d):
         d = d.copy()
         if d.get('author'):
             d['author'] = Person.from_dict(d['author'])
         if d.get('date'):
             d['date'] = TimestampWithTimezone.from_dict(d['date'])
         return cls(
             target_type=ObjectType(d.pop('target_type')),
             **d)
 
 
 class RevisionType(Enum):
     GIT = 'git'
     TAR = 'tar'
     DSC = 'dsc'
     SUBVERSION = 'svn'
     MERCURIAL = 'hg'
 
 
 @attr.s(frozen=True)
 class Revision(BaseModel):
     id = attr.ib(type=Sha1Git)
     message = attr.ib(type=bytes)
     author = attr.ib(type=Person)
     committer = attr.ib(type=Person)
     date = attr.ib(type=TimestampWithTimezone)
     committer_date = attr.ib(type=TimestampWithTimezone)
     type = attr.ib(type=RevisionType)
     directory = attr.ib(type=Sha1Git)
     synthetic = attr.ib(type=bool)
     metadata = attr.ib(type=Optional[Dict[str, object]],
                        default=None)
     parents = attr.ib(type=List[Sha1Git],
                       default=attr.Factory(list))
 
     @classmethod
     def from_dict(cls, d):
         d = d.copy()
         return cls(
             id=d.pop('id'),
             author=Person.from_dict(d.pop('author')),
             committer=Person.from_dict(d.pop('committer')),
             date=TimestampWithTimezone.from_dict(d.pop('date')),
             committer_date=TimestampWithTimezone.from_dict(
                 d.pop('committer_date')),
             type=RevisionType(d.pop('type')),
             **d)
 
 
 @attr.s(frozen=True)
 class DirectoryEntry(BaseModel):
     name = attr.ib(type=bytes)
     type = attr.ib(type=str,
                    validator=attr.validators.in_(['file', 'dir', 'rev']))
     target = attr.ib(type=Sha1Git)
     perms = attr.ib(type=int)
     """Usually one of the values of `swh.model.from_disk.DentryPerms`."""
 
 
 @attr.s(frozen=True)
 class Directory(BaseModel):
     id = attr.ib(type=Sha1Git)
     entries = attr.ib(type=List[DirectoryEntry])
 
     @classmethod
     def from_dict(cls, d):
         return cls(
             id=d['id'],
             entries=[DirectoryEntry.from_dict(entry)
                      for entry in d['entries']])
 
 
 @attr.s(frozen=True)
 class Content(BaseModel):
     sha1 = attr.ib(type=bytes)
     sha1_git = attr.ib(type=Sha1Git)
     sha256 = attr.ib(type=bytes)
     blake2s256 = attr.ib(type=bytes)
 
     length = attr.ib(type=int)
     status = attr.ib(
         type=str,
         validator=attr.validators.in_(['visible', 'absent', 'hidden']))
     reason = attr.ib(type=Optional[str],
                      default=None)
     data = attr.ib(type=Optional[bytes],
                    default=None)
 
     ctime = attr.ib(type=Optional[datetime.datetime],
                     default=None)
 
     @length.validator
     def check_length(self, attribute, value):
         """Checks the length is positive."""
         if self.status == 'absent' and value < -1:
             raise ValueError('Length must be positive or -1.')
         elif self.status != 'absent' and value < 0:
             raise ValueError('Length must be positive, unless status=absent.')
 
     @reason.validator
     def check_reason(self, attribute, value):
         """Checks the reason is full if status != absent."""
         assert self.reason == value
         if self.status == 'absent' and value is None:
             raise ValueError('Must provide a reason if content is absent.')
         elif self.status != 'absent' and value is not None:
             raise ValueError(
                 'Must not provide a reason if content is not absent.')
 
     def to_dict(self):
         content = super().to_dict()
         for field in ('data', 'reason', 'ctime'):
             if content[field] is None:
                 del content[field]
         return content
 
     def get_hash(self, hash_name):
         if hash_name not in DEFAULT_ALGORITHMS:
             raise ValueError('{} is not a valid hash name.'.format(hash_name))
         return getattr(self, hash_name)
diff --git a/swh/model/tests/test_model.py b/swh/model/tests/test_model.py
index 2900cd1..f65dd28 100644
--- a/swh/model/tests/test_model.py
+++ b/swh/model/tests/test_model.py
@@ -1,58 +1,54 @@
 # Copyright (C) 2019 The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
-import attr
 import copy
 
 from hypothesis import given
 
 from swh.model.model import Content
 from swh.model.hypothesis_strategies import objects, origins, origin_visits
 
 
 @given(objects())
 def test_todict_inverse_fromdict(objtype_and_obj):
     (obj_type, obj) = objtype_and_obj
 
     if obj_type in ('origin', 'origin_visit'):
         return
 
     obj_as_dict = obj.to_dict()
     obj_as_dict_copy = copy.deepcopy(obj_as_dict)
 
     # Check the composition of to_dict and from_dict is the identity
     assert obj == type(obj).from_dict(obj_as_dict)
 
     # Check from_dict() does not change the input dict
     assert obj_as_dict == obj_as_dict_copy
 
     # Check the composition of from_dict and to_dict is the identity
     assert obj_as_dict == type(obj).from_dict(obj_as_dict).to_dict()
 
 
 @given(origins())
 def test_todict_origins(origin):
     obj = origin.to_dict()
 
     assert 'type' not in obj
     assert type(origin)(url=origin.url) == type(origin).from_dict(obj)
 
 
 @given(origin_visits())
 def test_todict_origin_visits(origin_visit):
     obj = origin_visit.to_dict()
 
-    assert 'type' not in obj['origin']
-    origin2 = attr.evolve(origin_visit.origin, type=None)
-    origin_visit2 = attr.evolve(origin_visit, origin=origin2)
-    assert origin_visit2 == type(origin_visit).from_dict(obj)
+    assert origin_visit == type(origin_visit).from_dict(obj)
 
 
 def test_content_get_hash():
     hashes = dict(
         sha1=b'foo', sha1_git=b'bar', sha256=b'baz', blake2s256=b'qux')
     c = Content(length=42, status='visible', **hashes)
     for (hash_name, hash_) in hashes.items():
         assert c.get_hash(hash_name) == hash_