fix up ci

* feat: default to _public agent data
* version bump

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Installation
+
+This project uses poetry. Create a virtual environment, and run `poetry install`
+
+# Versioning (Maintainers only)
+
+Before merging your changes, make sure to bump the versions.
+
+Make a version bump to `pyproject.toml`. If the underlying dependency on the llamacloud platform OpenAPI
+sdk needs bumping, make sure to bring that in as well. If updating dependencies, run `poetry lock`.
+
+The legacy `llama_parse` package re-exports some of `llama_cloud_services` in the old namespace. The
+versions need to be kept consistent to sidecar it with `llama_cloud_services`. Bump it's version in `llama_parse/pyproject.toml`, and also bump it's dependency version of `llama-cloud-services` to match.
+
+You can also do this with `./scripts/version-bump.py set 0.x.x` if you have `uv` installed.
+
+Once the change is merged, push a tag `git tag -a v0.x.x -m 0.x.x` and `git push origin 0.x.x`.
+
+This tagging step can be done with `./scripts/version-bump tag`.

llama_cloud_services/beta/agent_data/client.py

@@ -42,7 +42,7 @@ def agent_data_retry(func: WrappedFn) -> WrappedFn:
     )(func)
 
 
-def get_default_agent_id() -> Optional[str]:
+def get_default_agent_id() -> str:
     """
     Retrieve the default agent ID from environment variables.
 
@@ -55,7 +55,7 @@ def get_default_agent_id() -> Optional[str]:
         via environment variables instead of passing it explicitly
         to each client instance.
     """
-    return os.getenv("LLAMA_DEPLOY_DEPLOYMENT_NAME")
+    return os.getenv("LLAMA_DEPLOY_DEPLOYMENT_NAME") or "_public"
 
 
 class AsyncAgentDataClient(Generic[AgentDataT]):
@@ -144,10 +144,6 @@ class AsyncAgentDataClient(Generic[AgentDataT]):
         """
 
         self.agent_url_id = agent_url_id or get_default_agent_id()
-        if not self.agent_url_id:
-            raise ValueError(
-                "Agent ID is required, or set the LLAMA_DEPLOY_DEPLOYMENT_NAME environment variable"
-            )
 
         self.collection = collection
         if not client:

llama_cloud_services/parse/base.py

@@ -381,6 +381,10 @@ class LlamaParse(BasePydanticReader):
         default=False,
         description="Preserve grid alignment across page in text mode.",
     )
+    preserve_very_small_text: Optional[bool] = Field(
+        default=False,
+        description="If set, the parser will try to preserve very small text lines. This can be useful for documents containing vector graphics with very small text lines that may not be recognized by OCR or a vision model (such as in CAD drawings).",
+    )
     replace_failed_page_mode: Optional[FailedPageMode] = Field(
         default=None,
         description="The mode to use to replace the failed page, see FailedPageMode enum for possible value. If set, the parser will replace the failed page with the specified mode. If not set, the default mode (raw_text) will be used.",
@@ -912,6 +916,9 @@ class LlamaParse(BasePydanticReader):
                 "preserve_layout_alignment_across_pages"
             ] = self.preserve_layout_alignment_across_pages
 
+        if self.preserve_very_small_text:
+            data["preserve_very_small_text"] = self.preserve_very_small_text
+
         if self.preset is not None:
             data["preset"] = self.preset
 
@@ -1697,3 +1704,79 @@ class LlamaParse(BasePydanticReader):
                 sub_docs.append(sub_doc)
 
         return sub_docs
+
+    async def aget_result(
+        self, job_id: Union[str, List[str]]
+    ) -> Union[JobResult, List[JobResult]]:
+        """
+        Return JobResult object for previously parsed job(s).
+
+        If the job is still pending, the result will not be returned until it is completed.
+
+        Args:
+            job_id: Job ID or list of multiple Job IDs to be retrieved.
+
+        Returns:
+            JobResult object or list of JobResult objects if multiple job IDs were provided.
+        """
+        if isinstance(job_id, str):
+            result = await self._get_job_result(
+                job_id, ResultType.JSON.value, verbose=self.verbose
+            )
+            return JobResult(
+                job_id=job_id,
+                file_name="",
+                job_result=result,
+                api_key=self.api_key,
+                base_url=self.base_url,
+                client=self.aclient,
+                page_separator=self.page_separator or _DEFAULT_SEPARATOR,
+            )
+        elif isinstance(job_id, list):
+            results = []
+            jobs = [
+                self._get_job_result(id_, ResultType.JSON.value, verbose=self.verbose)
+                for id_ in job_id
+            ]
+            results = await run_jobs(
+                jobs,
+                workers=self.num_workers,
+                desc="Getting job results",
+                show_progress=self.show_progress,
+            )
+            return [
+                JobResult(
+                    job_id=job_id[i],
+                    file_name="",
+                    job_result=result,
+                    api_key=self.api_key,
+                    base_url=self.base_url,
+                    client=self.aclient,
+                    page_separator=self.page_separator or _DEFAULT_SEPARATOR,
+                )
+                for i, result in enumerate(results)
+            ]
+        else:
+            raise ValueError("The input job_id must be a string or a list of strings.")
+
+    def get_result(
+        self, job_id: Union[str, List[str]]
+    ) -> Union[JobResult, List[JobResult]]:
+        """
+        Return JobResult object for previously parsed job(s).
+
+        If the job is still pending, the result will not be returned until it is completed.
+
+        Args:
+            job_id: Job ID or list of multiple Job IDs to be retrieved.
+
+        Returns:
+            JobResult object or list of JobResult objects if multiple job IDs were provided.
+        """
+        try:
+            return asyncio_run(self.aget_result(job_id))
+        except RuntimeError as e:
+            if nest_asyncio_err in str(e):
+                raise RuntimeError(nest_asyncio_msg)
+            else:
+                raise e

llama_cloud_services/parse/types.py

@@ -303,27 +303,55 @@ class JobResult(BaseModel):
 
     def get_markdown(self) -> str:
         """
-        Get the parsed markdown from the job, distinct from the markdown documents.
+        Get the raw parsed markdown from the job, distinct from the markdown documents.
         This does not include page separators, e.g. if merge_tables_across_pages_in_markdown is True
         """
         return asyncio_run(self.aget_markdown())
 
     async def aget_markdown(self) -> str:
         """
-        Get the parsed markdown from the job, distinct from the markdown documents.
+        Get the raw parsed markdown from the job, distinct from the markdown documents.
         This does not include page separators, e.g. if merge_tables_across_pages_in_markdown is True
         """
-        from llama_cloud.client import AsyncLlamaCloud
+        url = f"{self._base_url}/api/v1/parsing/job/{self.job_id}/result/raw/markdown"
+        response = await make_api_request(self._client, "GET", url)
+        return response.content.decode("utf-8")
 
-        client = AsyncLlamaCloud(
-            base_url=self._base_url,
-            token=self._api_key,
-            httpx_client=self._client,
-        )
-        result = await client.parsing.get_job_result(
-            job_id=self.job_id,
-        )
-        return result.markdown
+    def get_text(self) -> str:
+        """
+        Get the raw parsed text from the job.
+        """
+        return asyncio_run(self.aget_text())
+
+    async def aget_text(self) -> str:
+        """
+        Get the raw parsed text from the job.
+        """
+        url = f"{self._base_url}/api/v1/parsing/job/{self.job_id}/result/raw/text"
+        response = await make_api_request(self._client, "GET", url)
+        return response.content.decode("utf-8")
+
+    def get_json(self) -> Dict[str, Any]:
+        """
+        Get the full parsed JSON result from the job.
+
+        Note:
+            This is not the same as JobResult.json(), which is a
+            JSON serialized version of the JobResult Page Documents.
+        """
+        return asyncio_run(self.aget_json())
+
+    async def aget_json(self) -> Dict[str, Any]:
+        """
+        Get the full parsed JSON result from the job.
+
+        Note:
+            This is not the same as JobResult.json(), which is a
+            JSON serialized version of the JobResult Page Documents.
+        """
+        url = f"{self._base_url}/api/v1/parsing/job/{self.job_id}/result/json"
+        response = await make_api_request(self._client, "GET", url)
+        return response.json()
 
     async def _get_image_document_with_bytes(
         self, image: ImageItem, page: Page

llama_parse/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "llama-parse"
-version = "0.6.49"
+version = "0.6.51"
 description = "Parse files into RAG-Optimized formats."
 authors = ["Logan Markewich <logan@llamaindex.ai>"]
 license = "MIT"
@@ -13,7 +13,7 @@ packages = [{include = "llama_parse"}]
 
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
-llama-cloud-services = ">=0.6.49"
+llama-cloud-services = ">=0.6.51"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"

pyproject.toml

@@ -8,7 +8,7 @@ python_version = "3.10"
 
 [tool.poetry]
 name = "llama-cloud-services"
-version = "0.6.49"
+version = "0.6.51"
 description = "Tailored SDK clients for LlamaCloud services."
 authors = ["Logan Markewich <logan@runllama.ai>"]
 license = "MIT"

scripts/version-bump.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# dependencies = ["click", "tomlkit"]
+# ///
+
+import click
+import subprocess
+import sys
+import tomlkit
+from pathlib import Path
+
+
+def get_current_versions() -> tuple[str, str, str]:
+    """Get current versions from both pyproject.toml files."""
+    # Read main pyproject.toml
+    main_content = Path("pyproject.toml").read_text()
+    main_doc = tomlkit.parse(main_content)
+    main_version = main_doc["tool"]["poetry"]["version"]
+
+    # Read llama_parse/pyproject.toml
+    llama_parse_content = Path("llama_parse/pyproject.toml").read_text()
+    llama_parse_doc = tomlkit.parse(llama_parse_content)
+    llama_parse_version = llama_parse_doc["tool"]["poetry"]["version"]
+    dependency_version = llama_parse_doc["tool"]["poetry"]["dependencies"][
+        "llama-cloud-services"
+    ]
+
+    return str(main_version), str(llama_parse_version), str(dependency_version)
+
+
+def validate_versions(
+    main_version: str, llama_parse_version: str, dependency_version: str
+) -> list[str]:
+    """Validate that versions are consistent and return warnings."""
+    warnings = []
+
+    if main_version != llama_parse_version:
+        warnings.append(
+            f"Version mismatch: main={main_version}, llama_parse={llama_parse_version}"
+        )
+
+    # Extract version from dependency string (e.g., ">=0.6.51" -> "0.6.51")
+    if dependency_version and dependency_version.startswith(">="):
+        dep_ver = dependency_version[2:]
+        if dep_ver != main_version:
+            warnings.append(
+                f"Dependency version mismatch: dependency={dep_ver}, main={main_version}"
+            )
+
+    return warnings
+
+
+def set_version(version: str) -> None:
+    """Set version across all pyproject.toml files using tomlkit to preserve formatting."""
+    # Update main pyproject.toml
+    main_content = Path("pyproject.toml").read_text()
+    main_doc = tomlkit.parse(main_content)
+    main_doc["tool"]["poetry"]["version"] = version
+    Path("pyproject.toml").write_text(tomlkit.dumps(main_doc))
+
+    # Update llama_parse/pyproject.toml
+    llama_parse_content = Path("llama_parse/pyproject.toml").read_text()
+    llama_parse_doc = tomlkit.parse(llama_parse_content)
+    llama_parse_doc["tool"]["poetry"]["version"] = version
+    llama_parse_doc["tool"]["poetry"]["dependencies"][
+        "llama-cloud-services"
+    ] = f">={version}"
+    Path("llama_parse/pyproject.toml").write_text(tomlkit.dumps(llama_parse_doc))
+
+    click.echo(f"Updated all versions to {version}")
+
+
+def get_current_branch() -> str:
+    """Get the current git branch."""
+    result = subprocess.run(
+        ["git", "branch", "--show-current"], capture_output=True, text=True, check=True
+    )
+    return result.stdout.strip()
+
+
+def create_and_push_tag(version: str) -> None:
+    """Create a git tag and push it."""
+    current_branch = get_current_branch()
+    if current_branch != "main":
+        click.echo(
+            f"Error: Not on main branch (currently on {current_branch})", err=True
+        )
+        sys.exit(1)
+
+    tag_name = f"v{version}"
+
+    # Create tag
+    subprocess.run(["git", "tag", tag_name], check=True)
+    click.echo(f"Created tag {tag_name}")
+
+    # Push tag
+    subprocess.run(["git", "push", "origin", tag_name], check=True)
+    click.echo(f"Pushed tag {tag_name}")
+
+
+@click.group()
+def cli() -> None:
+    """Version management for llama-cloud-services."""
+    pass
+
+
+@cli.command()
+def get() -> None:
+    """Get current versions and show validation warnings."""
+    main_version, llama_parse_version, dependency_version = get_current_versions()
+
+    click.echo("Current versions:")
+    click.echo(f"  llama-cloud-services: {main_version}")
+    click.echo(f"  llama-parse: {llama_parse_version}")
+    click.echo(f"  dependency reference: {dependency_version}")
+
+    warnings = validate_versions(main_version, llama_parse_version, dependency_version)
+    if warnings:
+        click.echo("\nValidation warnings:")
+        for warning in warnings:
+            click.echo(f"  ⚠️  {warning}")
+    else:
+        click.echo("\n✅ All versions are consistent")
+
+
+@cli.command()
+@click.argument("version")
+def set(version: str) -> None:
+    """Set version across all pyproject.toml files."""
+    set_version(version)
+
+
+@cli.command()
+@click.option(
+    "--version", help="Version to tag (uses current version if not specified)"
+)
+def tag(version: str | None = None) -> None:
+    """Create and push a git tag for the current version."""
+    if not version:
+        main_version, _, _ = get_current_versions()
+        version = main_version
+
+    create_and_push_tag(version)
+
+
+if __name__ == "__main__":
+    cli()

tests/beta/agent_data/test_agent_data_client.py

@@ -48,8 +48,8 @@ class TestData(BaseModel):
 # Skip all tests if API key is not set
 @pytest.mark.asyncio
 @pytest.mark.skipif(
-    not LLAMA_CLOUD_API_KEY or not LLAMA_DEPLOY_DEPLOYMENT_NAME,
-    reason="LLAMA_CLOUD_API_KEY or LLAMA_DEPLOY_DEPLOYMENT_NAME not set",
+    not LLAMA_CLOUD_API_KEY,
+    reason="LLAMA_CLOUD_API_KEY not set",
 )
 async def test_agent_data_crud_operations():
     """Test basic CRUD operations for agent data with automatic cleanup"""

tests/parse/test_llama_parse.py

@@ -193,3 +193,12 @@ async def test_multiple_page_markdown(
     result = await markdown_parser.aload_data(filepath)
     assert len(result) == expected
     assert all(len(doc.text) > 0 for doc in result)
+
+
+@pytest.mark.asyncio
+async def test_get_result(markdown_parser: LlamaParse) -> None:
+    filepath = "tests/test_files/attention_is_all_you_need.pdf"
+    expected = await markdown_parser.aparse(filepath)
+    result = await markdown_parser.aget_result(expected.job_id)
+    assert result.job_id == expected.job_id
+    assert len(result.pages) == len(expected.pages)

tests/parse/test_llama_parse_result.py

@@ -83,6 +83,12 @@ async def test_basic_parse_result(file_path: str, partition_pages: Optional[int]
     assert image_documents[0].image is not None
     assert len(image_documents[0].resolve_image().getvalue()) > 0
 
+    assert len(await result.aget_text()) > 0
+    assert len(await result.aget_markdown()) > 0
+    json = await result.aget_json()
+    assert json.get("job_metadata")
+    assert len(json.get("pages", [])) == len(result.pages)
+
 
 @pytest.mark.asyncio
 @pytest.mark.skip(