atdata 0.3.0b1__py3-none-any.whl → 0.3.2b1__py3-none-any.whl

atdata/atmosphere/lens.py

@@ -9,18 +9,11 @@ Note:
     implementations.
 """
 
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
-from .client import AtmosphereClient
-from ._types import (
-    AtUri,
-    LensRecord,
-    CodeReference,
-    LEXICON_NAMESPACE,
-)
-
-# Import for type checking only
-from typing import TYPE_CHECKING
+from .client import Atmosphere
+from ._types import AtUri, LEXICON_NAMESPACE
+from ._lexicon_types import LexLensRecord, LexCodeReference
 
 if TYPE_CHECKING:
     from ..lens import Lens
@@ -37,14 +30,13 @@ class LensPublisher:
         ... def my_lens(source: SourceType) -> TargetType:
         ...     return TargetType(field=source.other_field)
         >>>
-        >>> client = AtmosphereClient()
-        >>> client.login("handle", "password")
+        >>> atmo = Atmosphere.login("handle", "password")
         >>>
-        >>> publisher = LensPublisher(client)
+        >>> publisher = LensPublisher(atmo)
         >>> uri = publisher.publish(
         ...     name="my_lens",
-        ...     source_schema_uri="at://did:plc:abc/ac.foundation.dataset.sampleSchema/source",
-        ...     target_schema_uri="at://did:plc:abc/ac.foundation.dataset.sampleSchema/target",
+        ...     source_schema_uri="at://did:plc:abc/ac.foundation.dataset.schema/source",
+        ...     target_schema_uri="at://did:plc:abc/ac.foundation.dataset.schema/target",
         ...     code_repository="https://github.com/user/repo",
         ...     code_commit="abc123def456",
         ...     getter_path="mymodule.lenses:my_lens",
@@ -57,11 +49,11 @@ class LensPublisher:
         records. Users must manually install and trust lens implementations.
     """
 
-    def __init__(self, client: AtmosphereClient):
+    def __init__(self, client: Atmosphere):
         """Initialize the lens publisher.
 
         Args:
-            client: Authenticated AtmosphereClient instance.
+            client: Authenticated Atmosphere instance.
         """
         self.client = client
 
@@ -71,59 +63,58 @@ class LensPublisher:
         name: str,
         source_schema_uri: str,
         target_schema_uri: str,
+        code_repository: str,
+        code_commit: str,
+        getter_path: str,
+        putter_path: str,
         description: Optional[str] = None,
-        code_repository: Optional[str] = None,
-        code_commit: Optional[str] = None,
-        getter_path: Optional[str] = None,
-        putter_path: Optional[str] = None,
+        language: Optional[str] = None,
+        metadata: Optional[dict] = None,
         rkey: Optional[str] = None,
     ) -> AtUri:
         """Publish a lens transformation record to ATProto.
 
+        Code references are required by the ATProto lexicon. Each lens must
+        point to a getter and putter implementation in a git repository.
+
         Args:
             name: Human-readable lens name.
             source_schema_uri: AT URI of the source schema.
             target_schema_uri: AT URI of the target schema.
-            description: What this transformation does.
             code_repository: Git repository URL containing the lens code.
             code_commit: Git commit hash for reproducibility.
             getter_path: Module path to the getter function
                 (e.g., 'mymodule.lenses:my_getter').
             putter_path: Module path to the putter function
                 (e.g., 'mymodule.lenses:my_putter').
+            description: What this transformation does.
+            language: Programming language (e.g., 'python').
+            metadata: Arbitrary metadata dictionary.
             rkey: Optional explicit record key.
 
         Returns:
             The AT URI of the created lens record.
-
-        Raises:
-            ValueError: If code references are incomplete.
         """
-        # Build code references if provided
-        getter_code: Optional[CodeReference] = None
-        putter_code: Optional[CodeReference] = None
-
-        if code_repository and code_commit:
-            if getter_path:
-                getter_code = CodeReference(
-                    repository=code_repository,
-                    commit=code_commit,
-                    path=getter_path,
-                )
-            if putter_path:
-                putter_code = CodeReference(
-                    repository=code_repository,
-                    commit=code_commit,
-                    path=putter_path,
-                )
-
-        lens_record = LensRecord(
+        getter_code = LexCodeReference(
+            repository=code_repository,
+            commit=code_commit,
+            path=getter_path,
+        )
+        putter_code = LexCodeReference(
+            repository=code_repository,
+            commit=code_commit,
+            path=putter_path,
+        )
+
+        lens_record = LexLensRecord(
             name=name,
             source_schema=source_schema_uri,
             target_schema=target_schema_uri,
-            description=description,
             getter_code=getter_code,
             putter_code=putter_code,
+            description=description,
+            language=language,
+            metadata=metadata,
         )
 
         return self.client.create_record(
@@ -143,6 +134,8 @@ class LensPublisher:
         code_repository: str,
         code_commit: str,
         description: Optional[str] = None,
+        language: Optional[str] = None,
+        metadata: Optional[dict] = None,
         rkey: Optional[str] = None,
     ) -> AtUri:
         """Publish a lens record from an existing Lens object.
@@ -158,16 +151,16 @@ class LensPublisher:
             code_repository: Git repository URL.
             code_commit: Git commit hash.
             description: What this transformation does.
+            language: Programming language (e.g., 'python').
+            metadata: Arbitrary metadata dictionary.
             rkey: Optional explicit record key.
 
         Returns:
             The AT URI of the created lens record.
         """
-        # Extract function names from the lens
         getter_name = lens_obj._getter.__name__
         putter_name = lens_obj._putter.__name__
 
-        # Get module info if available
         getter_module = getattr(lens_obj._getter, "__module__", "")
         putter_module = getattr(lens_obj._putter, "__module__", "")
 
@@ -178,11 +171,13 @@ class LensPublisher:
             name=name,
             source_schema_uri=source_schema_uri,
             target_schema_uri=target_schema_uri,
-            description=description,
             code_repository=code_repository,
             code_commit=code_commit,
             getter_path=getter_path,
             putter_path=putter_path,
+            description=description,
+            language=language,
+            metadata=metadata,
             rkey=rkey,
         )
 
@@ -195,8 +190,8 @@ class LensLoader:
     it manually.
 
     Examples:
-        >>> client = AtmosphereClient()
-        >>> loader = LensLoader(client)
+        >>> atmo = Atmosphere.login("handle", "password")
+        >>> loader = LensLoader(atmo)
         >>>
         >>> record = loader.get("at://did:plc:abc/ac.foundation.dataset.lens/xyz")
         >>> print(record["name"])
@@ -204,11 +199,11 @@ class LensLoader:
         >>> print(record.get("getterCode", {}).get("repository"))
     """
 
-    def __init__(self, client: AtmosphereClient):
+    def __init__(self, client: Atmosphere):
         """Initialize the lens loader.
 
         Args:
-            client: AtmosphereClient instance.
+            client: Atmosphere instance.
         """
         self.client = client
 
@@ -235,6 +230,18 @@ class LensLoader:
 
         return record
 
+    def get_typed(self, uri: str | AtUri) -> LexLensRecord:
+        """Fetch a lens record and return as a typed object.
+
+        Args:
+            uri: The AT URI of the lens record.
+
+        Returns:
+            LexLensRecord instance.
+        """
+        record = self.get(uri)
+        return LexLensRecord.from_record(record)
+
     def list_all(
         self,
         repo: Optional[str] = None,