Merge pull request #11 from BlockScience/dev

Merging updates

Author: lukvmil

README.md

@@ -97,7 +97,7 @@ orn:slack.message:TA2E6KPK3/C07BKQX0EVC/1721669683.087619
 
 By representing Slack messages through ORNs, a stable identifier can be assigned to a resource which can be mapped to existing locators for different use cases. For example, a Slack message can be represented as a shareable link which redirects to the Slack app or in browser app: 
 ```
-https://blockscienceteam.slack.com/archives/C07BKQX0EVC/p1721669683087619`
+https://blockscienceteam.slack.com/archives/C07BKQX0EVC/p1721669683087619
 ```
 There's also a "deep link" which can open the Slack app directly (but only to a channel):
 ```
@@ -118,13 +118,13 @@ The RID class provides a template for all RID types and access to a global const
 class RID:
 	scheme: str
 
-	# defined for ORNs only
+	# defined for namespaces schemes (ORN, URN, ...) only
 	namespace: str | None 
 
-	# "orn:<namespace>" for ORNs, otherwise equal to 'scheme'
+	# "<scheme>:<namespace>" for namespaces schemes, otherwise equal to scheme component
 	context: str
 
-	# the component after namespace component for ORNs, otherwise after the scheme component
+	# the component after the context component
 	reference: str
 
 	@classmethod
@@ -177,10 +177,10 @@ assert SlackMessage == RIDType.from_string("orn:slack.message")
 
 In order to create an RID type, follow this minimal implementation:
 ```python
-class MyRIDType(RID): # inherit from `RID` OR `ORN` base classes
+class MyRIDType(RID): # inherit from `RID` or namespace scheme (`ORN`, `URN`, ...) base classes
 	# define scheme for a generic URI type
 	scheme = "scheme"
-	# OR a namespace for a ORN type
+	# OR a namespace if using a namespace scheme
 	namespace = "namespace"
 
 	# instantiates a new RID from internal components
@@ -247,13 +247,14 @@ print(rid_obj1.scheme, rid_obj1.context, rid_obj1.reference)
 print(rid_obj1.team_id, rid_obj1.channel_id, rid_obj1.ts)
 ```
 
-If an RID type hasn't been implemented as a class, it can still be parsed by the general constructor if provisional contexts are allowed (enabled by default). In this case a provisional context class is generated on the fly providing the minimal RID type implementation (`reference` property, `from_reference` class method, `__init__` function).
+If an RID type doesn't have a class implementation, it can still be parsed by both the RID and RIDType constructors. A default type implementation will be generated on the fly with a minimal implementation (`reference` property, `from_reference` class method, `__init__` function).
 
 ```python
 test_obj1 = RID.from_string("test:one")
 test_obj2 = RID.from_string("test:one")
 
 assert test_obj1 == test_obj2
+assert type(test_obj1) == RIDType.from_string("test")
 ```
 
 ## Development
@@ -305,7 +306,7 @@ class Bundle(BaseModel):
     manifest: Manifest
     contents: dict
 
-	@classmethod
+    @classmethod
     def generate(cls, rid: RID, contents: dict) -> Bundle: ...
 ```
 

src/rid_lib/core.py

@@ -42,7 +42,7 @@ def __new__(mcls, name, bases, dct):
 
         # check for abstract method implementation
         if getattr(cls, "__abstractmethods__", None):
-            raise TypeError(f"RID type '{name}' is missing implemenation(s) for abstract method(s) {set(cls.__abstractmethods__)}")
+            raise TypeError(f"RID type '{name}' is missing implementation(s) for abstract method(s) {set(cls.__abstractmethods__)}")
 
         # save RID type to lookup table
         mcls.type_table[str(cls)] = cls

src/rid_lib/ext/__init__.py

@@ -1,4 +1,3 @@
 from .manifest import Manifest
 from .bundle import Bundle
-from .cache import Cache
-from .effector import ActionType, Effector
+from .cache import Cache

src/rid_lib/ext/cache.py

@@ -13,19 +13,19 @@ def file_path_to(self, rid: RID) -> str:
         encoded_rid_str = b64_encode(str(rid))
         return f"{self.directory_path}/{encoded_rid_str}.json"
 
-    def write(self, cache_bundle: Bundle) -> Bundle:
+    def write(self, bundle: Bundle) -> Bundle:
         """Writes bundle to cache, returns a Bundle."""
         if not os.path.exists(self.directory_path):
             os.makedirs(self.directory_path)
 
         with open(
-            file=self.file_path_to(cache_bundle.manifest.rid), 
+            file=self.file_path_to(bundle.manifest.rid), 
             mode="w", 
             encoding="utf-8"
         ) as f:
-            f.write(cache_bundle.model_dump_json(indent=2))
+            f.write(bundle.model_dump_json(indent=2))
 
-        return cache_bundle
+        return bundle
 
     def exists(self, rid: RID) -> bool:
         return os.path.exists(

src/rid_lib/ext/effector.py

@@ -1,39 +1,24 @@
-import json
 import hashlib
 from base64 import urlsafe_b64encode, urlsafe_b64decode
-from dataclasses import asdict, is_dataclass
-from datetime import datetime
 from pydantic import BaseModel
-from rid_lib import RID
+from vendor.org.webpki.json.Canonicalize import canonicalize
 
 
-def sha256_hash_json(data: dict | BaseModel):
-    if isinstance(data, BaseModel):
-        data = json.loads(data.model_dump_json())
-    json_str = json.dumps(data, separators=(',', ':'), sort_keys=True)
-    json_bytes = json_str.encode()
+def sha256_hash(data: str) -> str:
     hash = hashlib.sha256()
-    hash.update(json_bytes)
+    hash.update(data.encode())
     return hash.hexdigest()
 
+def sha256_hash_json(data: dict | BaseModel):
+    if isinstance(data, BaseModel):
+        data = data.model_dump(mode="json")
+    canonicalized_data = canonicalize(data, utf8=False)
+    return sha256_hash(canonicalized_data)
+    
 def b64_encode(string: str):
     return urlsafe_b64encode(
         string.encode()).decode().rstrip("=")
 
 def b64_decode(string: str):
     return urlsafe_b64decode(
-        (string + "=" * (-len(string) % 4)).encode()).decode()
-
-def json_serialize(obj):
-    if isinstance(obj, RID):
-        return str(obj)
-    elif is_dataclass(obj) and not isinstance(obj, type):
-        return json_serialize(asdict(obj))
-    elif isinstance(obj, datetime):
-        return obj.isoformat()
-    elif isinstance(obj, (list, tuple)):
-        return [json_serialize(item) for item in obj]
-    elif isinstance(obj, dict):
-        return {key: json_serialize(value) for key, value in obj.items()}
-    else:
-        return obj
+        (string + "=" * (-len(string) % 4)).encode()).decode()

src/rid_lib/ext/utils.py

@@ -0,0 +1 @@
+

src/vendor/org/__init__.py

@@ -0,0 +1 @@
+