o wiN@sdZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZmZmZddlmZddlZddlmmmZddlmZmZddlmZdd lmZdd lmZdd lm Z!dd l"m#Z#dd l$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2ddl3m4Z4ddl5m6Z6erddl7Z8ddl9Z:ddl;mZ>ddl?m@Z@ddlAmBZBddhZCdZDdZEdZFdZGd6d%d&ZHe#d7d)d*ZIe#d7d+d,ZJe#d8d0d1ZKGd2d3d3e%d4ZLGd5d4d4eZMdS)9aIW&B Public API for Runs. This module provides classes for interacting with W&B runs and their associated data. Example: ```python from wandb.apis.public import Api # Get runs matching filters runs = Api().runs( path="entity/project", filters={"state": "finished", "config.batch_size": 32} ) # Access run data for run in runs: print(f"Run: {run.name}") print(f"Config: {run.config}") print(f"Metrics: {run.summary}") # Get history with pandas history_df = run.history(keys=["loss", "accuracy"], pandas=True) # Work with artifacts for artifact in run.logged_artifacts(): print(f"Artifact: {artifact.name}") ``` Note: This module is part of the W&B Public API and provides read/write access to run data. For logging new runs, use the wandb.init() function from the main wandb package. ) annotationsN) CollectionIteratorMapping) TYPE_CHECKINGAnyLiteral)gql)envutil)nameof)public)Attrs)Api)normalize_exceptions)SizedPaginator)RETRY_TIMEDELTA) ServiceApi) wandb_api_pb2) wandb_setup)ipython json_utilrunid) LogicalPath)WandbApiFailedError)Self)Document)RetryingClient HTTPSummary_wandb wandb_versionaJfragment RunFragment on Run { id tags name displayName sweepName state config group jobType commit readOnly createdAt heartbeatAt description notes systemMetrics summaryMetrics historyLineCount user { name username } historyKeys }afragment LightweightRunFragment on Run { id tags name displayName sweepName state group jobType commit readOnly createdAt heartbeatAt description notes historyLineCount user { name username } } RunFragmentLightweightRunFragmentlazyboolwith_internal_idwith_project_idreturnr c CsJ|rtnt}|r tnt}td|rdndd|rdndd|d|d S) z8Create GraphQL query for runs with appropriate fragment.z#graphql query Runs($project: String!, $entity: String!, $cursor: String, $perPage: Int = 50, $order: String, $filters: JSONString) { project(name: $project, entityName: $entity) { internalIdz runCount(filters: $filters) readOnly runs(filters: $filters, after: $cursor, first: $perPage, order: $order) { edges { node { projectIdz ...z } cursor } pageInfo { endCursor hasNextPage } } } } )LIGHTWEIGHT_RUN_FRAGMENT RUN_FRAGMENTLIGHTWEIGHT_RUN_FRAGMENT_NAMERUN_FRAGMENT_NAMEr )r$r&r'fragment fragment_namer3J/home/ubuntu/.local/lib/python3.10/site-packages/wandb/apis/public/runs.py_create_runs_querys     r5clientrcC:d}t|}||}ddd|didigDvS)zQReturns True if the server allows us to query the internalId field for a project.z query ProbeProjectInput { ProjectType: __type(name:"Project") { fields { name } } } r)cSg|]}|dqSnamer3.0xr3r3r4 z<_server_provides_internal_id_for_project.. ProjectTypefieldsr executegetr6 query_stringqueryresr3r3r4(_server_provides_internal_id_for_project  rIcCr7)zLReturns True if the server allows us to query the projectId field for a run.z query ProbeRunInput { RunType: __type(name:"Run") { fields { name } } } r+cSr8r9r3r;r3r3r4r>r?z7_server_provides_project_id_for_run..RunTyperArBrEr3r3r4#_server_provides_project_id_for_runrJrLvaluerdict[str, Any]cCsl|duriSt|tr |St|tttfr.zt|WStjjy-tj|ddYSwt d|d)zConverts a value to a dictionary. If the value is already a dictionary, the value is returned unchanged. If the value is a string, bytes, or bytearray, it is parsed as JSON. For any other type, a TypeError is raised. NF)strictzUnable to convert z to a dict) isinstancedictstrbytes bytearrayjsonloadsdecoderJSONDecodeError TypeError)rMr3r3r4_convert_to_dicts  rZcseZdZdZ      d4d5fdd Zed6ddZed7ddZeddZd8dd Z e !  " # #d9d:d-d.Z d;d/d0Z d r_runCount) last_response _load_pagerrr3r3r4_length#sz Runs._lengthcCs$|jrt|jddddSdS)zaReturns whether there are more runs to fetch. r_runspageInfo hasNextPageT)rwr%ryr3r3r4more-s z Runs.morecCs$|jr|jdddddSdS)zoReturns the cursor position for pagination of runs results. r_r{edgescursorN)rwryr3r3r4r:sz Runs.cursor list[Run]c Csg}|jdus|jddurtd|j|jdddD]O}t|j|j|j|dd|d|j|j |j d}| ||jro|j ro|j |j vrR|j |j }ntjj|j|j|j|j d d }||j |j <|durlq ||_q |S) z[Converts GraphQL edges to Runs objects. Nr_zCould not find project {}r{rnoder:)rer$rfFwithRuns)rwrD ValueErrorformatr_Runr6r^rlrmrnappend sweep_namerkr Sweepsweep)rrobjs run_responserunrr3r3r4convert_objectsEs>    zRuns.convert_objects_stepdefaultsampleskeyslist[str] | Nonex_axisr&Literal['default', 'pandas', 'polars']streamLiteral['default', 'system']2list[dict[str, Any]] | pd.DataFrame | pl.DataFramecCs|dvr td|dg}|dkr5|D]}|j|||d|d}|s#q|D]} |j| d<q%||q|S|dkr}tjdd d } |D]}|j|||d|d}|sQqB| j|} |j| d<|| qB|sh| S| |} | j d d d | t | j } | S|d krtjd dd } |D]%}|j|||d|d}|sq| |} | | |jd} || q|s| S| j |dd} | t | j } | SdS)aQReturn sampled history metrics for all runs that fit the filters conditions. Args: samples: The number of samples to return per run keys: Only return metrics for specific keys x_axis: Use this metric as the xAxis defaults to _step format: Format to return data in, options are "default", "pandas", "polars" stream: "default" for metrics, "system" for machine metrics Returns: pandas.DataFrame: If `format="pandas"`, returns a `pandas.DataFrame` of history metrics. polars.DataFrame: If `format="polars"`, returns a `polars.DataFrame` of history metrics. list of dicts: If `format="default"`, returns a list of dicts containing history metrics with a `run_id` key. )rpandaspolarszInvalid format: z.. Must be one of 'default', 'pandas', 'polars'rF)rrrrrrun_idrz*Exporting pandas DataFrame requires pandas)requiredT)dropinplacerz*Exporting polars DataFrame requires polarsvertical)howN)rhistoryidextendr get_module DataFrame from_recordsrconcat reset_indexsortedcolumns with_columnslitaliasselect)rrrrrrr historiesr history_dataentrypddf combined_dfplr3r3r4rms         zRuns.historiescCs$dtt|d|jd|jdS)N< />)r typer^r_ryr3r3r4__repr__s$z Runs.__repr__Nonecs|jsdSd|_tdt|jt|jd|_dd|jD}|rWddlm}t t |d}||d fd d|D}|D]}| q>WddS1sPwYdSdS) aUpgrade this Runs collection from lazy to full mode. This switches to fetching full run data and upgrades any already-loaded Run objects to have full data. Uses parallel loading for better performance when upgrading multiple runs. NFrhcSsg|]}|jr|qSr3)rmr<rr3r3r4r>z(Runs.upgrade_to_full..r)ThreadPoolExecutor ) max_workerscsg|]}|jqSr3)submitload_full_datarexecutorr3r4r>s) rmr5rIr6rLriobjectsconcurrent.futuresrminlenresult)rr lazy_runsrrfuturesfuturer3rr4upgrade_to_fulls&   "zRuns.upgrade_to_full)Nr\r]TTN)r6rr^rRr_rRr`rarbrRrcrdrer%r$r%rfrgr(rd)r(r%)r(r)rNrrr) rrdrrrrRrrrrr(rr(rRr(r)__name__ __module__ __qualname____doc__rqpropertyrzr~rrrrrr __classcell__r3r3rtr4r[s2&    ( dr[rcseZdZdZ    ddfdd ZedddZedddZedddZedddZ edddZ e j dd dZ edd"d#Z e j dd%d#Z e    &ddd,d-Z .ddd3d4Zdd5d6Zddd7d8Zedd9d:Zedd;d<Zeddd>d?Zdd@dAZeddCdDZeddEdFZddKdLZ M NdddUdVZ N WdddZd[Ze   \dddbdcZeddfdgZedddkdlZe N  M  WdddodpZe  q  dddwdxZ eddd{d|Z!eddd}d~Z"e ddddZ#e  ddddZ$ddddZ%edddZ&edddZ'edddZ(edddZ)edddZ*edddZ+edddZ,edddZ-edddZ.edddZ/ddddZ0dddZ1dddZ2dddZ3  q  ddddZ4 ddddZ5Z6S)rabA single run associated with an entity and project. Args: client: The W&B API client. entity: The entity associated with the run. project: The project associated with the run. run_id: The unique identifier for the run. attrs: The attributes of the run. include_sweeps: Whether to include sweeps in the run. Attributes: tags ([str]): a list of tags associated with the run url (str): the url of this run id (str): unique identifier for the run (defaults to eight characters) name (str): the name of the run state (str): one of: running, finished, crashed, killed, preempting, preempted config (dict): a dict of hyperparameters associated with the run created_at (str): ISO timestamp when the run was started system_metrics (dict): the latest system metrics recorded for the run summary (dict): A mutable dict-like property that holds the current summary. Calling update will persist any changes. project (str): the project associated with the run entity (str): the name of the entity associated with the run project_internal_id (int): the internal id of the project user (str): the name of the user who created the run path (str): Unique identifier [entity]/[project]/[run_id] notes (str): Notes about the run read_only (boolean): Whether the run is editable history_keys (str): History metric keys logged with `wandb.Run.log({"key": "value"})` metadata (str): Metadata about the run from wandb-metadata.json NTr6rr^rRr_rattrsMapping | Nonerer%r$rfrgc s|pi} tt| ||_||_||_i|_tt |_ ||_ d|_ ||_||_d|_tjj|j g|jR|_zt|jWn tyMYnwd|_d|_| dd|_d|_d|_d|_||_|j| ddS)zInitialize a Run object. Run is always initialized by calling api.runs() where api is an instance of wandb.Api. NFstatez not foundforce) rprqrQr6_entityr__filesr get_dirtempfile gettempdir _base_dirrrrlrm_full_data_loadedospathjoindirmakedirsOSError_summary _metadatarD_state!server_provides_internal_id_field!_server_provides_project_id_field _is_loadedrnload) rrr6r^r_rrrer$rf_attrsrtr3r4rqs4 z Run.__init__r(cC|jS)zKThe state of the run. Can be one of: Finished, Failed, Crashed, or Running.)rryr3r3r4rCz Run.statecCr)z#The entity associated with the run.)rryr3r3r4r^Hrz Run.entitycCstd|jS)z-This API is deprecated. Use `entity` instead.z:Run.username is deprecated. Please use Run.entity instead.)wandbtermwarnrryr3r3r4usernameMs z Run.usernamecC |jdS)z*The unique storage identifier for the run.rrrDryr3r3r4 storage_idSs zRun.storage_idcCr)z"The unique identifier for the run.r:rryr3r3r4r[ zRun.idnew_idrcC||jd<dS)z&Set the unique identifier for the run.r:Nr)rrrr3r3r4r` str | NonecCr)zThe name of the run. displayNamerryr3r3r4r:erzRun.namenew_namecCr)zSet the name of the run.rNr)rrrr3r3r4r:jrrunningapi public.ApirLiteral['running', 'pending']rc Cs|jjddd|p t}|p|jdpd}td}||||d}|jj||d}|d d }||j|dd d |dd |d |d dddgdd|dddS)aCreate a run for the given project. For most use cases, use `wandb.init()`. `wandb.init()` provides more robust logic for creating and updating runs. `wandb.apis.public.Run.create` is intended for specific scenarios such as creating runs in a "pending" state for jobs that may be unschedulable (for example, in a Kubernetes cluster with insufficient GPUs or high contention). These pending runs can later be resumed and tracked by W&B. Runs created with this method have limited functionality. Calling `update()` on a run created this way may not work as expected. Args: api: The W&B API instance. run_id: Optional run ID. If not provided, a random ID will be generated. project: Optional project name. Defaults to the project in API settings or "uncategorized". entity: Optional entity (user or team) name. state: Initial state of the run. Use "pending" for runs that will be resumed later, or "running" for immediate execution. Returns: A Run object representing the created run. Example: Creating a pending run for later execution ```python import wandb api = wandb.Api() run_name = "my-pending-run" run = Run.create( api=api, project="project", entity="entity", state="pending", run_id=run_name, ) ``` zInvoking Run.createinfo)levelr_ uncategorizeda mutation UpsertBucket($project: String, $entity: String, $name: String!, $state: String) { upsertBucket(input: {modelName: $project, entityName: $entity, name: $name, state: $state}) { bucket { project { name entity { name } } id name } inserted } } )r^r_r:rvariable_values upsertBucketbucketr^r:rz{}N)rconfig systemMetricssummaryMetricstags descriptionnotesrF)r$) _sentrymessager generate_idsettingsrDr r6rC) clsrrr_r^rmutationrsrHr3r3r4createos:4    z Run.createFr1r2rrNcCsb|jdur t|j|_td|jrdndd|d|d}|s#|jsz||}|dus<|ddus<|dd durCtd ||dd |_|jd |_ |jd rat |j|jd |_ |j rz|jrz|jszt jj|j|j|j|jd d|_|jr|rd|jvrt|jd|_nd|_|tksd|jvsd|jvsd|jvr||tkrd|_|jS)z/Load run data using specified GraphQL fragment.Nz#graphql query Run($project: String!, $entity: String!, $name: String!) { project(name: $project, entityName: $entity) { run(name: $name) { r+r*z ...z3 } } } r,r_rzCould not find run {}ruserFrrrrT)rrLr6r r_execrDrrrr Userrrlrrrr^r_rrdrjr0_load_from_attrsr/)rrr1r2rrGresponser3r3r4_load_with_fragmentsT            zRun._load_with_fragmentc Csv|jdd|_d|jvrt|jd|jd<d|jvr(t|jd|jd<d|jvr8t|jd|jd<|jrV|jdrV|jsVtjj|j|j |j |jddd|_ii}}|jdrz,|jdi D] \}}|t vru|n|}t |trd|vr|d||<qk|||<qkWn ttfyYnw||||jd<||jd <d |jvrt|j|jd |_|jS) Nrrrr sweepNameFrrM rawconfigr)rrDrrZrlrr rr6r^r_itemsWANDB_INTERNAL_KEYSrPrQrYAttributeErrorupdaterr)rr config_user config_rawkeyrMrr3r3r4r sJ             zRun._load_from_attrscCs0|jr||jr|tt|S|tt|S)z r N)rMdesc)r$rr%rUro)rrrkvr3r3r4r6s   zRun.json_configrGrkwargsrcKs,|j|j|jd}|||jj||dS)z*Execute a query against the cloud backend.)r^r_r:r )r^r_rr(r6rC)rrrGrMrsr3r3r4rs z Run._execrrr list[str]rrrdlist[dict[str, Any]]cCsB|g||d}td}|j|t|gd}|ddddS)N)rra query RunSampledHistory($project: String!, $entity: String!, $name: String!, $specs: [JSONString!]!) { project(name: $project, entityName: $entity) { run(name: $name) { sampledHistory(specs: $specs) } } } )specsr_rsampledHistoryr)r rrUro)rrrrrspecrGr!r3r3r4_sampled_historys  zRun._sampled_historyrrrcCsF|dkrdnd}td|}|j||d}dd|dd |DS) Nrreventsa query RunFullHistory($project: String!, $entity: String!, $name: String!, $samples: Int) {{ project(name: $project, entityName: $entity) {{ run(name: $name) {{ {}(samples: $samples) }} }} }} )rcSsg|]}t|qSr3)rUrV)r<liner3r3r4r>"rz%Run._full_history..r_r)r rr)rrrrrrGr!r3r3r4 _full_historys zRun._full_historyr]namesrpatternrc public.FilescCstj|j||pg||dS)aReturns a `Files` object for all files in the run which match the given criteria. You can specify a list of exact file names to match, or a pattern to match against. If both are provided, the pattern will be ignored. Args: names (list): names of the requested files, if empty returns all files pattern (str, optional): Pattern to match when returning files from W&B. This pattern uses mySQL's LIKE syntax, so matching all files that end with .json would be "%.json". If both names and pattern are provided, a ValueError will be raised. per_page (int): number of results per page. Returns: A `Files` object, which is an iterator over `File` objects. )rXrcr Filesr6)rrrWrXrcr3r3r4files$sz Run.filesr: public.FilecCst|j||gdS)zReturn the path of a file with a given name in the artifact. Args: name (str): name of requested file. Returns: A `File` matching the name argument. rrZ)rrr:r3r3r4fileCs zRun.file.rrootcCst|j|jdtd}||jtj|}tj ||}t |}t tj ||d}|t||iWdn1sAwYt|j||gdS)aUpload a local file to W&B, associating it with this run. Args: path (str): Path to the file to upload. Can be absolute or relative. root (str): The root path to save the file relative to. For example, if you want to have the file saved in the run as "my_dir/file.txt" and you're currently in "my_dir" you would set root to "../". Defaults to current directory ("."). Returns: A `File` object representing the uploaded file. r^r_default_settingsretry_timedeltarbNr) InternalApir^r_rset_current_run_idrrrabspathrelpathr make_file_path_upload_safeopenrpushrr r[r6)rrrr`rr: upload_pathfr3r3r4 upload_fileOs    zRun.upload_filer#list[dict[str, Any]] | pd.DataFramecCs|durt|tstdgS|dur(t|dkr(t|dts(tdgS|r5|dkr5tdgS|r@|j|||d}n|j||d}|r]t d }|rX|j |}|St d |S) aReturn sampled history metrics for a run. This is simpler and faster if you are ok with the history records being sampled. Args: samples : (int, optional) The number of samples to return pandas : (bool, optional) Return a pandas dataframe keys : (list, optional) Only return metrics for specific keys x_axis : (str, optional) Use this metric as the xAxis defaults to _step stream : (str, optional) "default" for metrics, "system" for machine metrics Returns: pandas.DataFrame: If pandas=True returns a `pandas.DataFrame` of history metrics. list of dicts: If pandas=False returns a list of dicts of history metrics. N keys must be specified in a listr'keys argument must be a list of stringsrz+stream must be default when specifying keys)rrr)rrrz5Unable to load pandas, call history with pandas=False) rPlistr termerrorrrRrSrVr rrrr)rrrrrrrlinesrr3r3r4ris& "      z Run.history page_sizemin_step int | Nonemax_stepIterator[dict[str, Any]]cCs|durt|tstdgS|dur(t|dkr(t|dts(tdgS|j}|dur1d}|dur9|d}||krA|d}|durPtj||j |||dStj ||j ||||dS)a Returns an iterable collection of all history records for a run. Args: keys ([str], optional): only fetch these keys, and only fetch rows that have all of keys defined. page_size (int, optional): size of pages to fetch from the api. min_step (int, optional): the minimum number of pages to scan at a time. max_step (int, optional): the maximum number of pages to scan at a time. Returns: An iterable collection over history records (dict). Example: Export all the loss values for an example run ```python run = api.run("entity/project-name/run-id") history = run.scan_history(keys=["Loss"]) losses = [row["Loss"] for row in history] ``` Nrqrrr)rr6rwrxrz)rr6rrwrxrz) rPrsrrtrrRlastHistoryStepr HistoryScanr6SampledHistoryScan)rrrrwrxrz last_stepr3r3r4 scan_historys: " zRun.scan_historydpublic.RunArtifactscCtj|j|d|dS)aDFetches all artifacts logged by this run. Retrieves all output artifacts that were logged during the run. Returns a paginated result that can be iterated over or collected into a single list. Args: per_page: Number of artifacts to fetch per API request. Returns: An iterable collection of all Artifact objects logged as outputs during this run. Example: ```python import wandb import tempfile with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as tmp: tmp.write("This is a test artifact") tmp_path = tmp.name run = wandb.init(project="artifact-example") artifact = wandb.Artifact("test_artifact", type="dataset") artifact.add_file(tmp_path) run.log_artifact(artifact) run.finish() api = wandb.Api() finished_run = api.run(f"{run.entity}/{run.project}/{run.id}") for logged_artifact in finished_run.logged_artifacts(): print(logged_artifact.name) ``` loggedmodercr RunArtifactsr6rrrcr3r3r4logged_artifactss$zRun.logged_artifactscCr)aFetches artifacts explicitly used by this run. Retrieves only the input artifacts that were explicitly declared as used during the run, typically via `run.use_artifact()`. Returns a paginated result that can be iterated over or collected into a single list. Args: per_page: Number of artifacts to fetch per API request. Returns: An iterable collection of Artifact objects explicitly used as inputs in this run. Example: ```python import wandb run = wandb.init(project="artifact-example") run.use_artifact("test_artifact:latest") run.finish() api = wandb.Api() finished_run = api.run(f"{run.entity}/{run.project}/{run.id}") for used_artifact in finished_run.used_artifacts(): print(used_artifact.name) test_artifact ``` usedrrrr3r3r4used_artifactsszRun.used_artifactsartifactwandb.Artifactuse_ascCs|t|j|jdtd}||jt|tjr,| s,|j |j|p#|j |j|jd|St|tjr:| r:t dt d)aDeclare an artifact as an input to a run. Args: artifact (`Artifact`): An artifact returned from `wandb.Api().artifact(name)` use_as (string, optional): A string identifying how the artifact is used in the script. Used to easily differentiate artifacts used in a run, when using the beta wandb launch feature's artifact swapping functionality. Returns: An `Artifact` object. rarb)rartifact_entity_nameartifact_project_name_Only existing artifacts are accepted by this api. Manually create one with `wandb artifact put`6You must pass a wandb.Api().artifact() to use_artifact) rfr^r_rrgrrPrArtifactis_draft use_artifactr:r)rrrrrr3r3r4rs$  zRun.use_artifactaliasesCollection[str] | Nonerc Cst|j|jdtd}||jt|tjst d| r#t d|j|j ks/|j|j kr3t d|jdd}|j|j||j|j|j||d|S) aqDeclare an artifact as output of a run. Args: artifact (`Artifact`): An artifact returned from `wandb.Api().artifact(name)`. aliases (list, optional): Aliases to apply to this artifact. tags: (list, optional) Tags to apply to this artifact, if any. Returns: A `Artifact` object. rarbrrz3A run can't log an artifact to a different project.:r) entity_name project_namerr)rfr^r_rrgrrPrrrYrr source_entitysource_project source_namesplitcreate_artifactrdigest)rrrrrrartifact_collection_namer3r3r4 log_artifactEs2      zRun.log_artifactcCs*|js|s|jS|jttdd}d|_|S)asLoad full run data including heavy fields like config, systemMetrics, summaryMetrics. This method is useful when you initially used lazy=True for listing runs, but need access to the full data for specific runs. Args: force: Force reload even if data is already loaded Returns: The loaded run attributes Tr)rmrr"r.r0r)rrrrr3r3r4rvs zRun.load_full_datacCB|jr|jsd|jvr||jdi}t|}||jd<|S)z5Get run config. Auto-loads full data if in lazy mode.rrmrrrrDrZ)rr config_valuer3r3r4rs  z Run.configrcCsN|jr|jsd|jvr||jdur$ddlm}|||j|jd|_|jS)>Get run summary metrics. Auto-loads full data if in lazy mode.rNrr)r9) rmrrrrwandb.old.summaryrr6summary_metrics)rrrr3r3r4r9s   z Run.summarycCr)z=Get run system metrics. Auto-loads full data if in lazy mode.rr)rrsystem_metrics_valuer3r3r4system_metrics  zRun.system_metricscCr)rrr)rrsummary_metrics_valuer3r3r4rrzRun.summary_metricscCs,|jr|jsd|jvr||jdiS)zQGet raw run config including internal keys. Auto-loads full data if in lazy mode.r$)rmrrrrDryr3r3r4r$sz Run.rawconfigcCr)zLGet sweep name. Always available since sweepName is in lightweight fragment.r#rryr3r3r4rs zRun.sweep_namecCs4tjt|jtjt|jtjt|jgS)zSThe path of the run. The path is a list containing the entity, project, and run_id.)urllibparse quote_plusrRr^r_rryr3r3r4rszRun.pathcCs$|j}|dd|jjd|S)zThe URL of the run. The run URL is generated from the entity, project, and run_id. For SaaS users, it takes the form of `https://wandb.ai/entity/project/run_id`. r{r)rinsertr6app_urlr)rrrr3r3r4urls zRun.urlracCsh|jdur1z$|d}|jjjj}|j|jdd}||j }t ||_W|jSY|jS|jS)zMetadata about the run from wandb-metadata.json. Metadata includes the run's description, tags, start time, memory usage and more. Nzwandb-metadata.jsonr/)timeout) rr^r6_client transportsessionrDrraise_for_statuscontentrrV)rrrnrr!contentsr3r3r4metadatas    z Run.metadatacCsptd}||}|dus(|ddus(|dddus(|ddddur*dS|ddd}|ddS)z2Returns the last step logged in the run's history.z query RunHistoryKeys($project: String!, $entity: String!, $name: String!) { project(name: $project, entityName: $entity) { run(name: $name) { historyKeys } } } Nr_r historyKeysrlastStep)r rrD)rrrGr! history_keysr3r3r4r}s  zRun.lastHistoryStepheighthiddencCsD|jd}d|d}d}|r|d7}t}|d|d|dS) z7Generate HTML containing an iframe displaying this run.z ?jupyter=truezborder:none;width:100%;height:zpx;r*z display:none;z )rr toggle_button)rrrrrstyleprefixr3r3r4to_htmls  z Run.to_htmlcCs&trddl}||S|S)Nr)rin_vscode_notebookhtmlescape_string_representationr)rrrr3r3r4 _repr_html_ szRun._repr_html_cCs|SN)rryr3r3r4r(sz Run.__repr__cCs*dtt|dd|jd|jdS)Nrrrz (z)>)r rrrrryr3r3r4r+s*zRun._string_representationr use_cachepublic.BetaHistoryScanc CsL|jdurtj}t|d|_tj|j|||p|jd|||d}|S)aReturns an iterable collection of all history records for a run. This function is still in development and may not work as expected. It uses wandb-core to read history from a run's exported parquet history locally. Args: keys: list of metrics to read from the run's history. if no keys are provided then all metrics will be returned. page_size: the number of history records to read at a time. min_step: The minimum step to start reading history from (inclusive). max_step: The maximum step to read history up to (exclusive). use_cache: When set to True, checks the WANDB_CACHE_DIR for a run history. If the run history is not found in the cache, it will be downloaded from the server. If set to False, the run history will be downloaded every time. Returns: A BetaHistoryScan object, which can be iterator over to get history records. Nrr|)rfrrxrzrrwr) rnr singletonr model_copyrr BetaHistoryScanr})rrrrwrxrzrrbeta_history_scanr3r3r4beta_scan_history.s    zRun.beta_scan_history download_dirpathlib.Path | strrequire_complete_history runhistory.DownloadHistoryResultc stjjjjt||d}tjtj|dd}jdur+t j }t |d_zj|}Wn#tyV}z|jdurM|jjtjjkrMtdtd|d}~ww|jjj|jjjt jfddS) aDownload any parquet history files for the run to the provided directory. Args: download_dir: The directory to download the history files to. require_complete_history: Whether to require the complete history to be downloaded. If true, and the run contains data that has not been exported to parquet files yet, an IncompleteRunHistoryError will be raised. Returns: A DownloadHistoryResult. Raises: IncompleteRunHistoryError: If require_complete_history is True and the run contains data not yet exported to parquet files. WandbApiFailedError: If the API request fails for reasons other than incomplete history. )r^r_rrr)download_run_history_init)read_run_history_requestNrzFailed to download historycstjSr) runhistorywait_for_download_with_progressrnr3contains_live_data request_idrrr3r4s z.Run.download_history_exports..)apbDownloadRunHistoryInitr^r_rrR ApiRequestReadRunHistoryRequestrnrrrrrsend_api_requestrr! error_type ErrorTypeINCOMPLETE_RUN_HISTORY_ERRORrIncompleteRunHistoryErrorread_run_history_responserrrasyncerr)rrrrinit_download_request api_requestrr!rGr3rr4download_history_exportsYs<       zRun.download_history_exports)NTTN)r6rr^rRr_rRrrRrrrer%r$r%rfrgr)rrRr(r)r(r)rrRr(r)NNNr) rrrrr_rr^rrrr(r)F)r1rRr2rRrr%r(rN)r(rN)rr%r(rNr)r;r%r(r)rr?r(r%)rGrrMrr(rN)rr)rrNrrRrrdr(rO)rr)rrdrrr(rO)NNr])rWrrXrrcrdr(rY)r:rRr(r])r_)rrRr`rRr(r])rNrTr) rrdrrrrRrr%rrr(rp)NrvNN) rrrwrdrxryrzryr(r{)r)rcrdr(rr)rrrrr(r)NN)rrrrrrr(r)r(r)r(rN)r(rar)rF)rrdrr%r(rR)NrvrNT) rrrwrdrxrdrzryrr%r(r)T)rrrr%r(r)7rrrrrqrrr^rrrsetterr: classmethodrr"r rrr2r(r=r>rIr6rrSrVr\r^rorrrrrrrrr9rrr$rrrrr}rrrrrrrr3r3rtr4rs&+        b F 1   " 9       .=%) 0              .)r$r%r&r%r'r%r(r )r6rr(r%)rMrr(rN)Nr __future__rrUrpathlibrr0rcollections.abcrrrtypingrrr wandb_gqlr rwandb.apis.public.runhistoryapisr rr r wandb._strutilsr wandb.apiswandb.apis.attrsrwandb.apis.internalrrfwandb.apis.normalizerwandb.apis.paginatorrwandb.apis.public.constrwandb.apis.public.service_apir wandb.protorr wandb.sdkr wandb.sdk.librrrwandb.sdk.lib.pathsr(wandb.sdk.lib.service.service_connectionrrrrrtyping_extensionsrwandb_graphql.language.astrwandb.apis.publicrrrr&r.r-r0r/r5rIrLrZr[rr3r3r3r4sd "                  "