def __init__(self,
cid: Union[py_cid.CIDv0, py_cid.CIDv1],
priority: int = 1):
if not py_cid.is_cid(str(cid)):
raise ValueError(f"{cid} is not a valid cid")
self._ref_count: int = 1
self.cid = cid
self.priority = priority
def __init__(self,
cid: Union[py_cid.CIDv0, py_cid.CIDv1],
cancel: bool,
priority: int = 1):
if not py_cid.is_cid(str(cid)):
raise ValueError(f"{cid} is not a valid cid")
self.entry = WantListEntry(cid, priority)
self.cancel = bool(cancel)
def add_entry(self,
cid: Union[py_cid.CIDv0, py_cid.CIDv1],
cancel: bool,
priority: int = 1):
cid_str = str(cid)
if not py_cid.is_cid(cid_str):
raise ValueError(f"{cid} is not a valid cid")
entry = self.want_list.get(cid_str)
if entry is not None:
entry.priority = priority # TODO: why
entry.cancel = cancel # TODO: why
else:
self.want_list[cid_str] = MessageEntry(cid, cancel, priority)
def __init__(self, data, cid: Union[py_cid.CIDv0, py_cid.CIDv1]):
"""
Represents an immutable block of data that is uniquely referenced with a cid.
:param data: An object supporting the
:param cid: A cid
"""
try:
memoryview(data)
except TypeError:
raise ValueError("Data must be an object supporting the buffer protocol.")
if not py_cid.is_cid(str(cid)):
raise ValueError(f"{cid} is not a valid cid")
self._data = data
self._cid = cid
def fetch_resources(resource, get_dir=lambda x: '', get_index=lambda x: 'index'):
"""
Generic fetch process for resources
:param resource:
:param get_dir:
:param get_index:
:return:
"""
if cid.is_cid(resource['route']):
resource['abs'] = True
return resource
# If index defined keep using it else get index from param function
resource['index'] = resource['index'] if 'index' in resource else get_index(resource)
resource_dir = get_dir(resource) # Process dir from param function
download_file(resource['route'], resource_dir)
def fetch_movie_resources(mv, current_dir) -> dict:
"""
Check if resources need to be downloaded and download it
:param mv: MovieSchema dict
:param current_dir: Storage dir
:return: MovieSchema dict
"""
for video in mv['resource']['videos']:
if cid.is_cid(video['route']):
video['abs'] = True
continue
video['index'] = video['index'] if 'index' in video else 'index'
resource_dir = '%s/%s/%s' % (current_dir, video['quality'],
video['index'])
download_file(video['route'], resource_dir)
return mv
def fetch_images_resources(mv, current_dir) -> dict:
"""
Check if images need to be downloaded and download it
:param mv: MovieSchema dict
:param current_dir: Storage dir
:return: MovieScheme dict
"""
for _, image in mv['resource']['images'].items():
# Check for valid cid
if cid.is_cid(image['route']):
image['abs'] = True
continue
image['index'] = image[
'index'] if 'index' in image else os.path.basename(image['route'])
download_file(image['route'], "%s/%s" % (current_dir, image['index']))
return mv
def is_valid_ipfs(self):
"""
Returns true if the URI is a valid IPFS address.
i.e. '/ipfs/{some valid multihash}'
https://docs.ipfs.io/guides/concepts/cid/
only string (ASCII/UTF-8) CIDs are supported
https://github.com/ipld/py-cid is required library
"""
# CIDv0 - multihash
if not isinstance(self.value, str):
return False
if self.value.startswith('/ipfs/'):
normalized_value = self.value[len('/ipfs/'):]
else:
normalized_value = self.value
try:
return is_cid(normalized_value)
except Exception:
return False
def test_is_cid_valid(self, test_hash):
assert is_cid(CIDv0(test_hash).encode())
def test_is_cid_invalid(self, test_data):
assert not is_cid(test_data)
def test_is_cidv1_valid(self, test_cidv1):
assert is_cid(test_cidv1)
assert is_cid(make_cid(test_cidv1).encode())
def test_make_cid(self, hash):
is_cid(hash)
def test_is_cidv0_valid(self, test_cidv0):
assert is_cid(test_cidv0)
assert is_cid(make_cid(test_cidv0).encode())
def validate_route(self, value):
if not cid.is_cid(value) and not validators.url(value):
raise ValidationError('Route must be a CID or URI')
def cancel(self, cid: Union[py_cid.CIDv0, py_cid.CIDv1]):
cid_str = str(cid)
if not py_cid.is_cid(cid_str):
raise ValueError(f"{cid} is not a valid cid")
del self.want_list[cid_str]
self.add_entry(cid, cancel=True, priority=0)
