Gotham Platform SDK

Warning

This SDK is incubating and subject to change.

The Gotham Platform SDK is a Python SDK built on top of the Gotham API. Review Gotham API documentation for more details.

Note

This Python package is automatically generated based on the Gotham API specification.

Gotham Platform SDK vs. Foundry Platform SDK vs. Ontology SDK

Palantir provides two platform APIs for interacting with the Gotham and Foundry platforms. Each has a corresponding Software Development Kit (SDK). There is also the OSDK for interacting with Foundry ontologies. Make sure to choose the correct SDK for your use case. As a general rule of thumb, any applications which leverage the Ontology should use the Ontology SDK over the Foundry platform SDK for a superior development experience.

Important

Make sure to understand the difference between the Foundry, Gotham, and Ontology SDKs. Review this section before continuing with the installation of this library.

Ontology SDK

The Ontology SDK allows you to access the full power of the Ontology directly from your development environment. You can generate the Ontology SDK using the Developer Console, a portal for creating and managing applications using Palantir APIs. Review the Ontology SDK documentation for more information.

Foundry Platform SDK

The Foundry Platform Software Development Kit (SDK) is generated from the Foundry API specification file. The intention of this SDK is to encompass endpoints related to interacting with the Foundry platform itself. Although there are Ontology services included by this SDK, this SDK surfaces endpoints for interacting with Ontological resources such as object types, link types, and action types. In contrast, the OSDK allows you to interact with objects, links and Actions (for example, querying your objects, applying an action).

Gotham Platform SDK

The Gotham Platform Software Development Kit (SDK) is generated from the Gotham API specification file. The intention of this SDK is to encompass endpoints related to interacting with the Gotham platform itself. This includes Gotham apps and data, such as Gaia, Target Workbench, and geotemporal data.

Installation

You can install the Python package using pip:

pip install gotham-platform-python

API Versioning

Every endpoint of the Gotham API is versioned using a version number that appears in the URL. For example, v1 endpoints look like this:

https://<hostname>/api/v1/...

This SDK exposes several clients, one for each major version of the API. The latest major version of the SDK is v1 and is exposed using the GothamClient located in the gotham package.

from gotham import GothamClient

For other major versions, you must import that specific client from a submodule. For example, to import the v1 client from a sub-module you would import it like this:

from gotham.v1 import GothamClient

More information about how the API is versioned can be found here.

Authorization and client initalization

There are two options for authorizing the SDK.

User token

Warning

User tokens are associated with your personal user account and must not be used in production applications or committed to shared or public code repositories. We recommend you store test API tokens as environment variables during development. For authorizing production applications, you should register an OAuth2 application (see OAuth2 Client below for more details).

You can pass in a user token as an arguments when initializing the UserTokenAuth:

import gotham

client = gotham.GothamClient(
    auth=gotham.UserTokenAuth(os.environ["BEARER_TOKEN"]),
    hostname="example.palantirfoundry.com",
)

OAuth2 Client

OAuth2 clients are the recommended way to connect to Gotham in production applications. Currently, this SDK natively supports the client credentials grant flow. The token obtained by this grant can be used to access resources on behalf of the created service user. To use this authentication method, you will first need to register a third-party application in Foundry by following the guide on third-party application registration.

To use the confidential client functionality, you first need to construct a ConfidentialClientAuth object. As these service user tokens have a short lifespan (one hour), we automatically retry all operations one time if a 401 (Unauthorized) error is thrown after refreshing the token.

import gotham

auth = gotham.ConfidentialClientAuth(
    client_id=os.environ["CLIENT_ID"],
    client_secret=os.environ["CLIENT_SECRET"],
    scopes=[...],  # optional list of scopes
)

Important

Make sure to select the appropriate scopes when initializating the ConfidentialClientAuth. You can find the relevant scopes in the endpoint documentation.

After creating the ConfidentialClientAuth object, pass it in to the GothamClient,

import gotham

client = gotham.GothamClient(auth=auth, hostname="example.palantirfoundry.com")

Tip

If you want to use the ConfidentialClientAuth class independently of the GothamClient, you can use the get_token() method to get the token. You will have to provide a hostname when instantiating the ConfidentialClientAuth object, for example ConfidentialClientAuth(..., hostname="example.palantirfoundry.com").

Quickstart

Follow the installation procedure and determine which authentication method is best suited for your instance before following this example. For simplicity, the UserTokenAuth class will be used for demonstration purposes.

from gotham import GothamClient
import gotham
from pprint import pprint

client = GothamClient(auth=gotham.UserTokenAuth(...), hostname="example.palantirfoundry.com")

# ObservationSpecId | Search results will be constrained to Observations conforming to this Observation Spec.
observation_spec_id = "baz"
# ObservationQuery
query = {
    "time": {"start": "2023-01-01T12:00:00Z", "end": "2023-03-07T12:10:00Z"},
    "historyWindow": {"start": "2023-03-07T12:00:00Z", "end": "2023-03-07T12:10:00Z"},
}
# Optional[TimeQuery]
history_window = None
# Optional[PageToken]
page_token = None
# Optional[PreviewMode] | Represents a boolean value that restricts an endpoint to preview mode when set to true.
preview = True


try:
    api_response = client.geotime.Geotime.search_observation_histories(
        observation_spec_id,
        query=query,
        history_window=history_window,
        page_token=page_token,
        preview=preview,
    )
    print("The search_observation_histories response:\n")
    pprint(api_response)
except gotham.PalantirRPCException as e:
    print("HTTP error when calling Geotime.search_observation_histories: %s\n" % e)

Want to learn more about this Foundry SDK library? Review the following sections.

↳ Error handling: Learn more about HTTP & data validation error handling
↳ Pagination: Learn how to work with paginated endpoints in the SDK
↳ Streaming: Learn how to stream binary data from Foundry
↳ Static type analysis: Learn about the static type analysis capabilities of this library
↳ HTTP Session Configuration: Learn how to configure the HTTP session.

Error handling

Data validation

The SDK employs Pydantic for runtime validation of arguments. In the example below, we are passing in a number to high_priority_target_list which should actually be a string type:

client.target_workbench.TargetBoards.create(
	name=name, 
	security=security, 
	configuration=configuration, 
	description=description, 
	high_priority_target_list=123, 
	preview=preview)

If you did this, you would receive an error that looks something like:

pydantic_core._pydantic_core.ValidationError: 1 validation error for create
high_priority_target_list
  Input should be a valid string [type=string_type, input_value=123, input_type=int]
    For further information visit https://errors.pydantic.dev/2.5/v/string_type

To handle these errors, you can catch pydantic.ValidationError. To learn more, see the Pydantic error documentation.

Tip

Pydantic works with static type checkers such as pyright for an improved developer experience. See Static Type Analysis below for more information.

HTTP exceptions

Each operation includes a list of possible exceptions that can be thrown which can be thrown by the server, all of which inherit from PalantirRPCException. For example, an operation that interacts with target tracks might throw an InvalidTrackRid error, which is defined as follows:

class InvalidTrackRidParameters(typing_extensions.TypedDict):
    """The provided rid is not a valid Track rid."""

    __pydantic_config__ = {"extra": "allow"}  # type: ignore

    trackRid: geotime_models.TrackRid


@dataclass
class InvalidTrackRid(errors.BadRequestError):
    name: typing.Literal["InvalidTrackRid"]
    parameters: InvalidTrackRidParameters
    error_instance_id: str

As a user, you can catch this exception and handle it accordingly.

from gotham.v1.gotham._errors.errors import InvalidTrackRid

try:
    response = client.geotime.Geotime.link_tracks(
        other_track_rid=other_track_rid, track_rid=track_rid, preview=preview
    )
    ...
except InvalidTrackRid as e:
    print("Track rid has an incorrect format", e.parameters[...])

You can refer to the method documentation to see which exceptions can be thrown. It is also possible to catch a generic subclass of PalantirRPCException such as BadRequestError or NotFoundError.

Status Code	Error Class
400	BadRequestError
401	UnauthorizedError
403	PermissionDeniedError
404	NotFoundError
413	RequestEntityTooLargeError
422	UnprocessableEntityError
429	RateLimitError
>=500,<600	InternalServerError
Other	PalantirRPCException

from gotham._errors import PalantirRPCException
from gotham.v1.gotham.errors import BadRequestError

try:
    api_response = client.geotime.Geotime.link_tracks(
        other_track_rid=other_track_rid, track_rid=track_rid, preview=preview
    )
    ...
except BadRequestError as e:
    print("Track rid has an incorrect format", e)
except PalantirRPCException as e:
    print("Another HTTP exception occurred", e)

All HTTP exceptions will have the following properties. See the Gotham API docs for details about the Gotham error information.

Property	Type	Description
name	str	The Palantir error name. See the Gotham API docs.
error_instance_id	str	The Palantir error instance ID. See the Gotham API docs.
parameters	Dict[str, Any]	The Palantir error parameters. See the Gotham API docs.

Other exceptions

There are a handful of other exception classes that could be thrown when instantiating or using a client.

ErrorClass	Thrown Directly	Description
NotAuthenticated	Yes	You used either ConfidentialClientAuth or PublicClientAuth to make an API call without going through the OAuth process first.
ConnectionError	Yes	An issue occurred when connecting to the server. This also catches ProxyError.
ProxyError	Yes	An issue occurred when connecting to or authenticating with a proxy server.
TimeoutError	No	The request timed out. This catches both ConnectTimeout, ReadTimeout and WriteTimeout.
ConnectTimeout	Yes	The request timed out when attempting to connect to the server.
ReadTimeout	Yes	The server did not send any data in the allotted amount of time.
WriteTimeout	Yes	There was a timeout when writing data to the server.
StreamConsumedError	Yes	The content of the given stream has already been consumed.
RequestEntityTooLargeError	Yes	The request entity is too large.
ConflictError	Yes	There was a conflict with another request.
SDKInternalError	Yes	An unexpected issue occurred and should be reported.

Pagination

When calling any iterator endpoints, we return a ResourceIterator class designed to simplify the process of working with paginated API endpoints. This class provides a convenient way to fetch, iterate over, and manage pages of data, while handling the underlying pagination logic.

To iterate over all items, you can simply create a ResourceIterator instance and use it in a for loop, like this:

for item in client.geotime.Geotime.search_observation_histories(
    observation_spec_id, query=query, history_window=history_window, preview=preview
):
    print(item)

This will automatically fetch and iterate through all the pages of data from the specified API endpoint. For more granular control, you can manually fetch each page using the next_page_token.

page = client.geotime.Geotime.search_observation_histories(
    observation_spec_id, query=query, history_window=history_window, preview=preview
)

while page.next_page_token:
    for branch in page.data:
        print(branch)

    page = client.geotime.Geotime.search_observation_histories(
        observation_spec_id,
        query=query,
        history_window=history_window,
        page_token=page.next_page_token,
        preview=preview,
    )

Streaming

This SDK supports streaming binary data using a separate streaming client accessible under with_streaming_response on each Resource. To ensure the stream is closed, you need to use a context manager when making a request with this client.

# Non-streaming response
with open("result.png", "wb") as f:
    f.write(client.map_rendering.MapRendering.load_generic_symbol(id, preview=preview, size=size))

# Streaming response
with open("result.png", "wb") as f:
    with client.map_rendering.MapRendering.with_streaming_response.load_generic_symbol(
        id, preview=preview, size=size
    ) as response:
        for chunk in response.iter_bytes():
            f.write(chunk)

Static type analysis

This library uses Pydantic for creating and validating data models which you will see in the method definitions (see Documentation for Models below for a full list of models). All request parameters with nested fields are typed as a Union between a Pydantic BaseModel class and a TypedDict whereas responses use Pydantic class. For example, here is how Geotime.search_latest_observations method is defined in the Geotime namespace:

    @core.maybe_ignore_preview
    @pydantic.validate_call
    @errors.handle_unexpected
    def search_latest_observations(
        self,
        observation_spec_id: geotime_models.ObservationSpecId,
        *,
        query: typing.Union[geotime_models.ObservationQuery, geotime_models.ObservationQueryDict],
        page_token: typing.Optional[gotham_models.PageToken] = None,
        preview: typing.Optional[gotham_models.PreviewMode] = None,
        request_timeout: typing.Optional[core.Timeout] = None,
        _sdk_internal: core.SdkInternal = {},
    ) -> geotime_models.SearchLatestObservationsResponse:
        ...

In this example, ObservationQuery is a BaseModel class and ObservationQueryDict is a TypedDict class. When calling this method, you can choose whether to pass in a class instance or a dict.

import gotham
from gotham.geotime.models import ObservationQuery, PropertyValuesQuery

client = gotham.GothamClient(...)

# Class instance
result = client.geotime.Geotime.search_latest_observations(
    observation_spec_id=observationSpecId,
    query=ObservationQuery(
        property=PropertyValuesQuery(property="property1", values=["value1", "value2"])
    ),
    preview=True,
)

# Dict
result = client.geotime.Geotime.search_latest_observations(
    observation_spec_id=observationSpecId,
    query={"property": {"property": "property1", "values": ["value1", "value2"]}},
    preview=True,
)

Tip

A Pydantic model can be converted into its TypedDict representation using the to_dict method. For example, if you handle a variable of type PropertyValuesQuery and you called to_dict() on that variable you would receive a PropertyValuesQueryDict variable.

If you are using a static type checker (for example, mypy, pyright), you get static type analysis for the arguments you provide to the function and with the response. For example, if you pass an int to map_name but map_name expects a string or if you try to access mapName on the returned Map object (the property is actually called name), you will get the following errors:

maps = gotham_client.gaia.Map.search(
    # ERROR: "Literal[123]" is incompatible with "GaiaMapName"
    map_name=123,
    preview=True,
)

# ERROR: Cannot access member "mapName" for type "GaiaMapMetadata"
print(maps.results[0].mapName)

HTTP Session Configuration

You can configure various parts of the HTTP session using the Config class.

from gotham import Config
from gotham import UserTokenAuth
from gotham import GothamClient

client = GothamClient(
    auth=UserTokenAuth(...),
    hostname="example.palantirfoundry.com",
    config=Config(
        # Set the default headers for every request
        default_headers={"Foo": "Bar"},
        # Default to a 60 second timeout
        timeout=60,
        # Create a proxy for the https protocol
        proxies={"https": "https://10.10.1.10:1080"},
    ),
)

The full list of options can be found below.

• default_headers (dict[str, str]): HTTP headers to include with all requests.
• proxies (dict["http" | "https", str]): Proxies to use for HTTP and HTTPS requests.
• timeout (int | float): The default timeout for all requests in seconds.
• verify (bool | str): SSL verification, can be a boolean or a path to a CA bundle. Defaults to True.
• default_params (dict[str, Any]): URL query parameters to include with all requests.
• scheme ("http" | "https"): URL scheme to use ('http' or 'https'). Defaults to 'https'.

SSL Certificate Verification

In addition to the Config class, the SSL certificate file used for verification can be set using the following environment variables (in order of precedence):

• REQUESTS_CA_BUNDLE
• SSL_CERT_FILE

The SDK will only check for the presence of these environment variables if the verify option is set to True (the default value). If verify is set to False, the environment variables will be ignored.

Important

If you are using an HTTPS proxy server, the verify value will be passed to the proxy's SSL context as well.

Common errors

This section will document any user-related errors with information on how you may be able to resolve them.

ApiFeaturePreviewUsageOnly

This error indicates you are trying to use an endpoint in public preview and have not set preview=True when calling the endpoint. Before doing so, note that this endpoint is in preview state and breaking changes may occur at any time.

During the first phase of an endpoint's lifecycle, it may be in Public Preview state. This indicates that the endpoint is in development and is not intended for production use.

Input should have timezone info

# Example error
pydantic_core._pydantic_core.ValidationError: 1 validation error for Model
datetype
  Input should have timezone info [type=timezone_aware, input_value=datetime.datetime(2025, 2, 5, 20, 57, 57, 511182), input_type=datetime]

This error indicates that you are passing a datetime object without timezone information to an endpoint that requires it. To resolve this error, you should pass in a datetime object with timezone information. For example, you can use the timezone class in the datetime package:

from datetime import datetime
from datetime import timezone

datetime_with_tz = datetime(2025, 2, 5, 20, 57, 57, 511182, tzinfo=timezone.utc)

Documentation for V1 API endpoints

Namespace	Resource	Operation	HTTP request
FederatedSources	FederatedSource	list	GET /gotham/v1/federatedSources
Gaia	Map	add_artifacts	POST /gotham/v1/maps/{mapRid}/layers/artifacts
Gaia	Map	add_enterprise_map_layers	POST /gotham/v1/maps/{mapRid}/layers/emls
Gaia	Map	add_objects	POST /gotham/v1/maps/{mapRid}/layers/objects
Gaia	Map	export_kmz	POST /gotham/v1/maps/{mapId}/kmz
Gaia	Map	load	GET /gotham/v1/maps/load/{mapGid}
Gaia	Map	load_layers	PUT /gotham/v1/maps/load/{mapGid}/layers
Gaia	Map	render_symbol	PUT /gotham/v1/maps/rendering/symbol
Gaia	Map	search	GET /gotham/v1/maps
Geotime	Geotime	link_track_and_object	POST /gotham/v1/tracks/linkToObject
Geotime	Geotime	link_tracks	POST /gotham/v1/tracks/linkTracks
Geotime	Geotime	put_convolution_metadata	PUT /gotham/v1/convolution/metadata
Geotime	Geotime	search_latest_observations	POST /gotham/v1/observations/latest/{observationSpecId}/search
Geotime	Geotime	search_observation_histories	POST /gotham/v1/observations/history/{observationSpecId}/search
Geotime	Geotime	unlink_track_and_object	POST /gotham/v1/tracks/unlinkFromObject
Geotime	Geotime	unlink_tracks	POST /gotham/v1/tracks/unlinkTracks
Geotime	Geotime	write_observations	POST /gotham/v1/observations
Inbox	Messages	send	POST /gotham/v1/inbox/messages
MapRendering	MapRendering	load_generic_symbol	GET /gotham/v1/maprendering/symbols/generic/{id}
MapRendering	MapRendering	load_resource_tile	GET /gotham/v1/maprendering/resources/tiles/{tileset}/{zoom}/{xCoordinate}/{yCoordinate}
MapRendering	MapRendering	render_objects	PUT /gotham/v1/maprendering/render
Media	Media	get_media_content	GET /gotham/v1/media/{mediaRid}/content
Media	Media	get_object_media	GET /gotham/v1/objects/{primaryKey}/media
TargetWorkbench	HighPriorityTargetLists	create	POST /gotham/v1/twb/highPriorityTargetList
TargetWorkbench	HighPriorityTargetLists	get	GET /gotham/v1/twb/highPriorityTargetList/{rid}
TargetWorkbench	HighPriorityTargetLists	update	PUT /gotham/v1/twb/highPriorityTargetList/{rid}
TargetWorkbench	TargetBoards	create	POST /gotham/v1/twb/targetBoard
TargetWorkbench	TargetBoards	delete	PUT /gotham/v1/twb/targetBoard/{rid}/archive
TargetWorkbench	TargetBoards	get	GET /gotham/v1/twb/targetBoard/{rid}
TargetWorkbench	TargetBoards	load_target_pucks	PUT /gotham/v1/twb/board/{rid}/loadTargetPucks
TargetWorkbench	TargetBoards	update	PUT /gotham/v1/twb/targetBoard/{rid}
TargetWorkbench	TargetBoards	update_target_column	PUT /gotham/v1/twb/setTargetColumn/{targetRid}
TargetWorkbench	Targets	create	POST /gotham/v1/twb/target
TargetWorkbench	Targets	create_intel	PUT /gotham/v1/twb/createTargetIntel/{rid}
TargetWorkbench	Targets	delete	PUT /gotham/v1/twb/target/{rid}/archive
TargetWorkbench	Targets	get	GET /gotham/v1/twb/target/{rid}
TargetWorkbench	Targets	remove_intel	PUT /gotham/v1/twb/removeTargetIntel/{rid}
TargetWorkbench	Targets	update	PUT /gotham/v1/twb/target/{rid}

Documentation for V1 models

Namespace	Name	Import
Foundry	FoundryObjectPropertyTypeRid	from gotham.v1.foundry.models import FoundryObjectPropertyTypeRid
Foundry	FoundryObjectSetRid	from gotham.v1.foundry.models import FoundryObjectSetRid
Foundry	FoundryObjectTypeRid	from gotham.v1.foundry.models import FoundryObjectTypeRid
Gaia	AddArtifactsToMapResponse	from gotham.v1.gaia.models import AddArtifactsToMapResponse
Gaia	AddEnterpriseMapLayersToMapResponse	from gotham.v1.gaia.models import AddEnterpriseMapLayersToMapResponse
Gaia	AddObjectsToMapResponse	from gotham.v1.gaia.models import AddObjectsToMapResponse
Gaia	EmlId	from gotham.v1.gaia.models import EmlId
Gaia	FillStyle	from gotham.v1.gaia.models import FillStyle
Gaia	GaiaCoordinate	from gotham.v1.gaia.models import GaiaCoordinate
Gaia	GaiaElement	from gotham.v1.gaia.models import GaiaElement
Gaia	GaiaElementId	from gotham.v1.gaia.models import GaiaElementId
Gaia	GaiaFeature	from gotham.v1.gaia.models import GaiaFeature
Gaia	GaiaLayer	from gotham.v1.gaia.models import GaiaLayer
Gaia	GaiaLayerId	from gotham.v1.gaia.models import GaiaLayerId
Gaia	GaiaLayerMetadata	from gotham.v1.gaia.models import GaiaLayerMetadata
Gaia	GaiaMapGid	from gotham.v1.gaia.models import GaiaMapGid
Gaia	GaiaMapId	from gotham.v1.gaia.models import GaiaMapId
Gaia	GaiaMapMetadata	from gotham.v1.gaia.models import GaiaMapMetadata
Gaia	GaiaMapName	from gotham.v1.gaia.models import GaiaMapName
Gaia	GaiaMapRid	from gotham.v1.gaia.models import GaiaMapRid
Gaia	GaiaProperties	from gotham.v1.gaia.models import GaiaProperties
Gaia	GaiaStyle	from gotham.v1.gaia.models import GaiaStyle
Gaia	GaiaSymbol	from gotham.v1.gaia.models import GaiaSymbol
Gaia	IconFillStyle	from gotham.v1.gaia.models import IconFillStyle
Gaia	IconStrokeStyle	from gotham.v1.gaia.models import IconStrokeStyle
Gaia	IconSymbol	from gotham.v1.gaia.models import IconSymbol
Gaia	LabelStyle	from gotham.v1.gaia.models import LabelStyle
Gaia	LoadLayersResponse	from gotham.v1.gaia.models import LoadLayersResponse
Gaia	LoadMapResponse	from gotham.v1.gaia.models import LoadMapResponse
Gaia	MilSymModifiers	from gotham.v1.gaia.models import MilSymModifiers
Gaia	MilsymSymbol	from gotham.v1.gaia.models import MilsymSymbol
Gaia	SearchMapsResponse	from gotham.v1.gaia.models import SearchMapsResponse
Gaia	StrokeStyle	from gotham.v1.gaia.models import StrokeStyle
Gaia	SymbolStyle	from gotham.v1.gaia.models import SymbolStyle
Gaia	TacticalGraphicProperties	from gotham.v1.gaia.models import TacticalGraphicProperties
Gaia	TextAlignment	from gotham.v1.gaia.models import TextAlignment
Geotime	CollectionId	from gotham.v1.geotime.models import CollectionId
Geotime	ConvolvedComponentMetadata	from gotham.v1.geotime.models import ConvolvedComponentMetadata
Geotime	ConvolvedMetadata	from gotham.v1.geotime.models import ConvolvedMetadata
Geotime	GeometryStyle	from gotham.v1.geotime.models import GeometryStyle
Geotime	IconSymbologyIdentifier	from gotham.v1.geotime.models import IconSymbologyIdentifier
Geotime	InvalidObservation	from gotham.v1.geotime.models import InvalidObservation
Geotime	MilSymbologyIdentifier	from gotham.v1.geotime.models import MilSymbologyIdentifier
Geotime	ObjectRid	from gotham.v1.geotime.models import ObjectRid
Geotime	Observation	from gotham.v1.geotime.models import Observation
Geotime	ObservationField	from gotham.v1.geotime.models import ObservationField
Geotime	ObservationQuery	from gotham.v1.geotime.models import ObservationQuery
Geotime	ObservationSpecId	from gotham.v1.geotime.models import ObservationSpecId
Geotime	ObservationStyle	from gotham.v1.geotime.models import ObservationStyle
Geotime	ObservationWithinQuery	from gotham.v1.geotime.models import ObservationWithinQuery
Geotime	PropertyValuesQuery	from gotham.v1.geotime.models import PropertyValuesQuery
Geotime	SearchLatestObservationsResponse	from gotham.v1.geotime.models import SearchLatestObservationsResponse
Geotime	SearchObservationHistoryResponse	from gotham.v1.geotime.models import SearchObservationHistoryResponse
Geotime	SourceSystemId	from gotham.v1.geotime.models import SourceSystemId
Geotime	SymbologyIdentifier	from gotham.v1.geotime.models import SymbologyIdentifier
Geotime	TimeQuery	from gotham.v1.geotime.models import TimeQuery
Geotime	Track	from gotham.v1.geotime.models import Track
Geotime	TrackRid	from gotham.v1.geotime.models import TrackRid
Geotime	WriteObservationsRequest	from gotham.v1.geotime.models import WriteObservationsRequest
Geotime	WriteObservationsResponse	from gotham.v1.geotime.models import WriteObservationsResponse
Gotham	ArtifactGid	from gotham.v1.gotham.models import ArtifactGid
Gotham	ArtifactSecurity	from gotham.v1.gotham.models import ArtifactSecurity
Gotham	BBox	from gotham.v1.gotham.models import BBox
Gotham	ChatMessageId	from gotham.v1.gotham.models import ChatMessageId
Gotham	Coordinate	from gotham.v1.gotham.models import Coordinate
Gotham	CreateHighPriorityTargetListResponseV2	from gotham.v1.gotham.models import CreateHighPriorityTargetListResponseV2
Gotham	CreateTargetBoardResponseV2	from gotham.v1.gotham.models import CreateTargetBoardResponseV2
Gotham	CreateTargetResponseV2	from gotham.v1.gotham.models import CreateTargetResponseV2
Gotham	CustomTargetIdentifer	from gotham.v1.gotham.models import CustomTargetIdentifer
Gotham	ElevationWithError	from gotham.v1.gotham.models import ElevationWithError
Gotham	EmptySuccessResponse	from gotham.v1.gotham.models import EmptySuccessResponse
Gotham	Feature	from gotham.v1.gotham.models import Feature
Gotham	FeatureCollection	from gotham.v1.gotham.models import FeatureCollection
Gotham	FeatureCollectionTypes	from gotham.v1.gotham.models import FeatureCollectionTypes
Gotham	FeaturePropertyKey	from gotham.v1.gotham.models import FeaturePropertyKey
Gotham	FederatedAndQuery	from gotham.v1.gotham.models import FederatedAndQuery
Gotham	FederatedNotQuery	from gotham.v1.gotham.models import FederatedNotQuery
Gotham	FederatedOrQuery	from gotham.v1.gotham.models import FederatedOrQuery
Gotham	FederatedSearchJsonQuery	from gotham.v1.gotham.models import FederatedSearchJsonQuery
Gotham	FederatedSource	from gotham.v1.gotham.models import FederatedSource
Gotham	FederatedSourceName	from gotham.v1.gotham.models import FederatedSourceName
Gotham	FederatedTermQuery	from gotham.v1.gotham.models import FederatedTermQuery
Gotham	GeoCircle	from gotham.v1.gotham.models import GeoCircle
Gotham	GeoJsonObject	from gotham.v1.gotham.models import GeoJsonObject
Gotham	Geometry	from gotham.v1.gotham.models import Geometry
Gotham	GeometryCollection	from gotham.v1.gotham.models import GeometryCollection
Gotham	GeoPoint	from gotham.v1.gotham.models import GeoPoint
Gotham	GeoPolygon	from gotham.v1.gotham.models import GeoPolygon
Gotham	GeotimeSeriesExternalReference	from gotham.v1.gotham.models import GeotimeSeriesExternalReference
Gotham	GeotimeTrackRid	from gotham.v1.gotham.models import GeotimeTrackRid
Gotham	GetFederatedSourceResponse	from gotham.v1.gotham.models import GetFederatedSourceResponse
Gotham	GetMediaResponse	from gotham.v1.gotham.models import GetMediaResponse
Gotham	GroupName	from gotham.v1.gotham.models import GroupName
Gotham	GroupRecipient	from gotham.v1.gotham.models import GroupRecipient
Gotham	HighPriorityTargetListAgm	from gotham.v1.gotham.models import HighPriorityTargetListAgm
Gotham	HighPriorityTargetListAgmId	from gotham.v1.gotham.models import HighPriorityTargetListAgmId
Gotham	HighPriorityTargetListEffectType	from gotham.v1.gotham.models import HighPriorityTargetListEffectType
Gotham	HighPriorityTargetListRid	from gotham.v1.gotham.models import HighPriorityTargetListRid
Gotham	HighPriorityTargetListTargetId	from gotham.v1.gotham.models import HighPriorityTargetListTargetId
Gotham	HighPriorityTargetListTargetV2	from gotham.v1.gotham.models import HighPriorityTargetListTargetV2
Gotham	HighPriorityTargetListV2	from gotham.v1.gotham.models import HighPriorityTargetListV2
Gotham	HighPriorityTargetListWhen	from gotham.v1.gotham.models import HighPriorityTargetListWhen
Gotham	HptlTargetAoi	from gotham.v1.gotham.models import HptlTargetAoi
Gotham	HptlTargetAoiId	from gotham.v1.gotham.models import HptlTargetAoiId
Gotham	HptlTargetAoiUnion	from gotham.v1.gotham.models import HptlTargetAoiUnion
Gotham	HptlTargetElnot	from gotham.v1.gotham.models import HptlTargetElnot
Gotham	HptlTargetEntityAoi	from gotham.v1.gotham.models import HptlTargetEntityAoi
Gotham	HptlTargetGeoAoi	from gotham.v1.gotham.models import HptlTargetGeoAoi
Gotham	HptlTargetSubtype	from gotham.v1.gotham.models import HptlTargetSubtype
Gotham	IntelChatMessage	from gotham.v1.gotham.models import IntelChatMessage
Gotham	IntelDomain	from gotham.v1.gotham.models import IntelDomain
Gotham	IntelDossier	from gotham.v1.gotham.models import IntelDossier
Gotham	IntelFoundryObject	from gotham.v1.gotham.models import IntelFoundryObject
Gotham	IntelFreeText	from gotham.v1.gotham.models import IntelFreeText
Gotham	IntelGeotimeObservation	from gotham.v1.gotham.models import IntelGeotimeObservation
Gotham	IntelId	from gotham.v1.gotham.models import IntelId
Gotham	IntelMedia	from gotham.v1.gotham.models import IntelMedia
Gotham	IntelPgObject	from gotham.v1.gotham.models import IntelPgObject
Gotham	IntelUnion	from gotham.v1.gotham.models import IntelUnion
Gotham	JpdiId	from gotham.v1.gotham.models import JpdiId
Gotham	LinearRing	from gotham.v1.gotham.models import LinearRing
Gotham	LineString	from gotham.v1.gotham.models import LineString
Gotham	LineStringCoordinates	from gotham.v1.gotham.models import LineStringCoordinates
Gotham	LinkTypeApiName	from gotham.v1.gotham.models import LinkTypeApiName
Gotham	LoadHighPriorityTargetListResponseV2	from gotham.v1.gotham.models import LoadHighPriorityTargetListResponseV2
Gotham	LoadTargetBoardResponseV2	from gotham.v1.gotham.models import LoadTargetBoardResponseV2
Gotham	LoadTargetPuckResponse	from gotham.v1.gotham.models import LoadTargetPuckResponse
Gotham	LoadTargetPucksResponse	from gotham.v1.gotham.models import LoadTargetPucksResponse
Gotham	LoadTargetResponseV2	from gotham.v1.gotham.models import LoadTargetResponseV2
Gotham	Location3dWithError	from gotham.v1.gotham.models import Location3dWithError
Gotham	LocationSource	from gotham.v1.gotham.models import LocationSource
Gotham	Media	from gotham.v1.gotham.models import Media
Gotham	MediaRid	from gotham.v1.gotham.models import MediaRid
Gotham	MediaType	from gotham.v1.gotham.models import MediaType
Gotham	MensurationData	from gotham.v1.gotham.models import MensurationData
Gotham	MessageSecurity	from gotham.v1.gotham.models import MessageSecurity
Gotham	MessageSender	from gotham.v1.gotham.models import MessageSender
Gotham	MessageSourceId	from gotham.v1.gotham.models import MessageSourceId
Gotham	MultiLineString	from gotham.v1.gotham.models import MultiLineString
Gotham	MultiPoint	from gotham.v1.gotham.models import MultiPoint
Gotham	MultiPolygon	from gotham.v1.gotham.models import MultiPolygon
Gotham	Namespace	from gotham.v1.gotham.models import Namespace
Gotham	NamespaceName	from gotham.v1.gotham.models import NamespaceName
Gotham	ObjectComponentSecurity	from gotham.v1.gotham.models import ObjectComponentSecurity
Gotham	ObjectPrimaryKey	from gotham.v1.gotham.models import ObjectPrimaryKey
Gotham	ObjectTypeApiName	from gotham.v1.gotham.models import ObjectTypeApiName
Gotham	PageSize	from gotham.v1.gotham.models import PageSize
Gotham	PageToken	from gotham.v1.gotham.models import PageToken
Gotham	Permission	from gotham.v1.gotham.models import Permission
Gotham	PermissionItem	from gotham.v1.gotham.models import PermissionItem
Gotham	Point	from gotham.v1.gotham.models import Point
Gotham	Polygon	from gotham.v1.gotham.models import Polygon
Gotham	PortionMarking	from gotham.v1.gotham.models import PortionMarking
Gotham	Position	from gotham.v1.gotham.models import Position
Gotham	PreviewMode	from gotham.v1.gotham.models import PreviewMode
Gotham	PropertyApiName	from gotham.v1.gotham.models import PropertyApiName
Gotham	PropertyId	from gotham.v1.gotham.models import PropertyId
Gotham	PropertyValue	from gotham.v1.gotham.models import PropertyValue
Gotham	SecureTextBody	from gotham.v1.gotham.models import SecureTextBody
Gotham	SecureTextTitle	from gotham.v1.gotham.models import SecureTextTitle
Gotham	SecurityKey	from gotham.v1.gotham.models import SecurityKey
Gotham	SendMessageFailure	from gotham.v1.gotham.models import SendMessageFailure
Gotham	SendMessageFailureReason	from gotham.v1.gotham.models import SendMessageFailureReason
Gotham	SendMessageRequest	from gotham.v1.gotham.models import SendMessageRequest
Gotham	SendMessageResponse	from gotham.v1.gotham.models import SendMessageResponse
Gotham	SendMessagesResponse	from gotham.v1.gotham.models import SendMessagesResponse
Gotham	ServiceName	from gotham.v1.gotham.models import ServiceName
Gotham	SizeBytes	from gotham.v1.gotham.models import SizeBytes
Gotham	TargetAimpointId	from gotham.v1.gotham.models import TargetAimpointId
Gotham	TargetAimpointV2	from gotham.v1.gotham.models import TargetAimpointV2
Gotham	TargetBoard	from gotham.v1.gotham.models import TargetBoard
Gotham	TargetBoardColumnConfiguration	from gotham.v1.gotham.models import TargetBoardColumnConfiguration
Gotham	TargetBoardColumnConfigurationId	from gotham.v1.gotham.models import TargetBoardColumnConfigurationId
Gotham	TargetBoardColumnId	from gotham.v1.gotham.models import TargetBoardColumnId
Gotham	TargetBoardConfiguration	from gotham.v1.gotham.models import TargetBoardConfiguration
Gotham	TargetBoardRid	from gotham.v1.gotham.models import TargetBoardRid
Gotham	TargetBranchId	from gotham.v1.gotham.models import TargetBranchId
Gotham	TargetDetails	from gotham.v1.gotham.models import TargetDetails
Gotham	TargetIdentifier	from gotham.v1.gotham.models import TargetIdentifier
Gotham	TargetIdentifierEnum	from gotham.v1.gotham.models import TargetIdentifierEnum
Gotham	TargetLocation	from gotham.v1.gotham.models import TargetLocation
Gotham	TargetObservation	from gotham.v1.gotham.models import TargetObservation
Gotham	TargetPuckId	from gotham.v1.gotham.models import TargetPuckId
Gotham	TargetPuckLoadLevel	from gotham.v1.gotham.models import TargetPuckLoadLevel
Gotham	TargetPuckStatus	from gotham.v1.gotham.models import TargetPuckStatus
Gotham	TargetRid	from gotham.v1.gotham.models import TargetRid
Gotham	TargetV2	from gotham.v1.gotham.models import TargetV2
Gotham	TextFormatStyle	from gotham.v1.gotham.models import TextFormatStyle
MapRendering	ClientCapabilities	from gotham.v1.map_rendering.models import ClientCapabilities
MapRendering	FoundryObjectPropertyValueUntyped	from gotham.v1.map_rendering.models import FoundryObjectPropertyValueUntyped
MapRendering	GeometryRenderableContent	from gotham.v1.map_rendering.models import GeometryRenderableContent
MapRendering	Invocation	from gotham.v1.map_rendering.models import Invocation
MapRendering	InvocationId	from gotham.v1.map_rendering.models import InvocationId
MapRendering	MrsAlpha	from gotham.v1.map_rendering.models import MrsAlpha
MapRendering	MrsColor	from gotham.v1.map_rendering.models import MrsColor
MapRendering	MrsFillStyle	from gotham.v1.map_rendering.models import MrsFillStyle
MapRendering	MrsGenericSymbol	from gotham.v1.map_rendering.models import MrsGenericSymbol
MapRendering	MrsGenericSymbolId	from gotham.v1.map_rendering.models import MrsGenericSymbolId
MapRendering	MrsGeometryStyle	from gotham.v1.map_rendering.models import MrsGeometryStyle
MapRendering	MrsLabelStyle	from gotham.v1.map_rendering.models import MrsLabelStyle
MapRendering	MrsRasterStyle	from gotham.v1.map_rendering.models import MrsRasterStyle
MapRendering	MrsRgb	from gotham.v1.map_rendering.models import MrsRgb
MapRendering	MrsStrokeStyle	from gotham.v1.map_rendering.models import MrsStrokeStyle
MapRendering	MrsSymbol	from gotham.v1.map_rendering.models import MrsSymbol
MapRendering	MrsSymbolStyle	from gotham.v1.map_rendering.models import MrsSymbolStyle
MapRendering	MrsVirtualPixels	from gotham.v1.map_rendering.models import MrsVirtualPixels
MapRendering	ObjectSourcingContent	from gotham.v1.map_rendering.models import ObjectSourcingContent
MapRendering	ObjectsReference	from gotham.v1.map_rendering.models import ObjectsReference
MapRendering	ObjectsReferenceObjectSet	from gotham.v1.map_rendering.models import ObjectsReferenceObjectSet
MapRendering	RasterTilesRenderableContent	from gotham.v1.map_rendering.models import RasterTilesRenderableContent
MapRendering	Renderable	from gotham.v1.map_rendering.models import Renderable
MapRendering	RenderableContent	from gotham.v1.map_rendering.models import RenderableContent
MapRendering	RenderableContentType	from gotham.v1.map_rendering.models import RenderableContentType
MapRendering	RenderableId	from gotham.v1.map_rendering.models import RenderableId
MapRendering	RenderablePartId	from gotham.v1.map_rendering.models import RenderablePartId
MapRendering	RendererReference	from gotham.v1.map_rendering.models import RendererReference
MapRendering	RenderObjectsResponse	from gotham.v1.map_rendering.models import RenderObjectsResponse
MapRendering	Sourcing	from gotham.v1.map_rendering.models import Sourcing
MapRendering	SourcingContent	from gotham.v1.map_rendering.models import SourcingContent
MapRendering	SourcingId	from gotham.v1.map_rendering.models import SourcingId
MapRendering	StandardRendererReference	from gotham.v1.map_rendering.models import StandardRendererReference
MapRendering	TilesetId	from gotham.v1.map_rendering.models import TilesetId

Documentation for errors

Documentation for V1 errors

Namespace	Name	Import
Gotham	ApiFeaturePreviewUsageOnly	from gotham.v1.gotham.errors import ApiFeaturePreviewUsageOnly
Gotham	BasicLinkTypeNotFound	from gotham.v1.gotham.errors import BasicLinkTypeNotFound
Gotham	DisallowedPropertyTypes	from gotham.v1.gotham.errors import DisallowedPropertyTypes
Gotham	FederatedObjectUpdateNotAllowed	from gotham.v1.gotham.errors import FederatedObjectUpdateNotAllowed
Gotham	FederatedSourceNotFound	from gotham.v1.gotham.errors import FederatedSourceNotFound
Gotham	InvalidClassificationPortionMarkings	from gotham.v1.gotham.errors import InvalidClassificationPortionMarkings
Gotham	InvalidGeotimeObservations	from gotham.v1.gotham.errors import InvalidGeotimeObservations
Gotham	InvalidMessagePortionMarkings	from gotham.v1.gotham.errors import InvalidMessagePortionMarkings
Gotham	InvalidMessageRequests	from gotham.v1.gotham.errors import InvalidMessageRequests
Gotham	InvalidObjectRid	from gotham.v1.gotham.errors import InvalidObjectRid
Gotham	InvalidOntologyTypes	from gotham.v1.gotham.errors import InvalidOntologyTypes
Gotham	InvalidPageSize	from gotham.v1.gotham.errors import InvalidPageSize
Gotham	InvalidPageToken	from gotham.v1.gotham.errors import InvalidPageToken
Gotham	InvalidPermissions	from gotham.v1.gotham.errors import InvalidPermissions
Gotham	InvalidPropertyValue	from gotham.v1.gotham.errors import InvalidPropertyValue
Gotham	InvalidSidc	from gotham.v1.gotham.errors import InvalidSidc
Gotham	InvalidTrackRid	from gotham.v1.gotham.errors import InvalidTrackRid
Gotham	MalformedObjectPrimaryKeys	from gotham.v1.gotham.errors import MalformedObjectPrimaryKeys
Gotham	MalformedPropertyFilters	from gotham.v1.gotham.errors import MalformedPropertyFilters
Gotham	MalformedUnresolveRequest	from gotham.v1.gotham.errors import MalformedUnresolveRequest
Gotham	MediaNotFound	from gotham.v1.gotham.errors import MediaNotFound
Gotham	MissingRepresentativePropertyTypes	from gotham.v1.gotham.errors import MissingRepresentativePropertyTypes
Gotham	NamespaceNotFound	from gotham.v1.gotham.errors import NamespaceNotFound
Gotham	NoLocatorFoundForRid	from gotham.v1.gotham.errors import NoLocatorFoundForRid
Gotham	ObjectNotFound	from gotham.v1.gotham.errors import ObjectNotFound
Gotham	ObjectTypeNotFound	from gotham.v1.gotham.errors import ObjectTypeNotFound
Gotham	PropertiesNotFound	from gotham.v1.gotham.errors import PropertiesNotFound
Gotham	PropertyNotFound	from gotham.v1.gotham.errors import PropertyNotFound
Gotham	PutConvolutionMetadataError	from gotham.v1.gotham.errors import PutConvolutionMetadataError
Gotham	ResolvedObjectComponentsNotFound	from gotham.v1.gotham.errors import ResolvedObjectComponentsNotFound
Gotham	ServiceNotConfigured	from gotham.v1.gotham.errors import ServiceNotConfigured
Gotham	TargetNotOnTargetBoard	from gotham.v1.gotham.errors import TargetNotOnTargetBoard
Gotham	TrackToObjectLinkageFailure	from gotham.v1.gotham.errors import TrackToObjectLinkageFailure
Gotham	TrackToObjectUnlinkageFailure	from gotham.v1.gotham.errors import TrackToObjectUnlinkageFailure
Gotham	TrackToTrackLinkageFailure	from gotham.v1.gotham.errors import TrackToTrackLinkageFailure
Gotham	TrackToTrackUnlinkageFailure	from gotham.v1.gotham.errors import TrackToTrackUnlinkageFailure
Gotham	UnclearGeotimeSeriesReference	from gotham.v1.gotham.errors import UnclearGeotimeSeriesReference
Gotham	UnclearMultiSourcePropertyUpdateRequest	from gotham.v1.gotham.errors import UnclearMultiSourcePropertyUpdateRequest
Gotham	UnknownRecipients	from gotham.v1.gotham.errors import UnknownRecipients
Gotham	UserHasNoOwnerPerms	from gotham.v1.gotham.errors import UserHasNoOwnerPerms
Gotham	WriteGeotimeObservationSizeLimit	from gotham.v1.gotham.errors import WriteGeotimeObservationSizeLimit

Contributions

This repository does not accept code contributions.

If you have any questions, concerns, or ideas for improvements, create an issue with Palantir Support.

License

This project is made available under the Apache 2.0 License.