wandb 0.18.0__py3-none-any.whl → 0.18.1__py3-none-any.whl

wandb/env.py

@@ -62,7 +62,6 @@ SAVE_CODE = "WANDB_SAVE_CODE"
 TAGS = "WANDB_TAGS"
 IGNORE = "WANDB_IGNORE_GLOBS"
 ERROR_REPORTING = "WANDB_ERROR_REPORTING"
-CORE_ERROR_REPORTING = "WANDB_CORE_ERROR_REPORTING"
 CORE_DEBUG = "WANDB_CORE_DEBUG"
 DOCKER = "WANDB_DOCKER"
 AGENT_REPORT_INTERVAL = "WANDB_AGENT_REPORT_INTERVAL"
@@ -172,10 +171,6 @@ def error_reporting_enabled() -> bool:
     return _env_as_bool(ERROR_REPORTING, default="True")
 
 
-def core_error_reporting_enabled(default: Optional[str] = None) -> bool:
-    return _env_as_bool(CORE_ERROR_REPORTING, default=default)
-
-
 def core_debug(default: Optional[str] = None) -> bool:
     return _env_as_bool(CORE_DEBUG, default=default)
 

wandb/{sklearn → integration/sklearn}/calculate/calibration_curves.py

@@ -7,18 +7,18 @@ from sklearn.calibration import CalibratedClassifierCV
 from sklearn.linear_model import LogisticRegression
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def calibration_curves(clf, X, y, clf_name):
+def calibration_curves(clf, X, y, clf_name):  # noqa: N803
     # ComplementNB (introduced in 0.20.0) requires non-negative features
     if int(sklearn.__version__.split(".")[1]) >= 20 and isinstance(
         clf, naive_bayes.ComplementNB
     ):
-        X = X - X.min()
+        X = X - X.min()  # noqa:N806
 
     # Calibrated with isotonic calibration
     isotonic = CalibratedClassifierCV(clf, cv=2, method="isotonic")
@@ -48,7 +48,7 @@ def calibration_curves(clf, X, y, clf_name):
     frac_positives_column.append(1)
     mean_pred_value_column.append(1)
 
-    X_train, X_test, y_train, y_test = model_selection.train_test_split(
+    x_train, x_test, y_train, y_test = model_selection.train_test_split(
         X, y, test_size=0.9, random_state=42
     )
 
@@ -58,11 +58,11 @@ def calibration_curves(clf, X, y, clf_name):
     names = ["Logistic", f"{clf_name} Isotonic", f"{clf_name} Sigmoid"]
 
     for model, name in zip(models, names):
-        model.fit(X_train, y_train)
+        model.fit(x_train, y_train)
         if hasattr(model, "predict_proba"):
-            prob_pos = model.predict_proba(X_test)[:, 1]
+            prob_pos = model.predict_proba(x_test)[:, 1]
         else:  # use decision function
-            prob_pos = model.decision_function(X_test)
+            prob_pos = model.decision_function(x_test)
             prob_pos = (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())
 
         hist, edges = np.histogram(prob_pos, bins=10, density=False)

wandb/{sklearn → integration/sklearn}/calculate/class_proportions.py

@@ -4,7 +4,7 @@ import numpy as np
 from sklearn.utils.multiclass import unique_labels
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)

wandb/{sklearn → integration/sklearn}/calculate/confusion_matrix.py

@@ -6,14 +6,15 @@ from sklearn import metrics
 from sklearn.utils.multiclass import unique_labels
 
 import wandb
-from wandb.sklearn import utils
+
+from .. import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
 def validate_labels(*args, **kwargs):  # FIXME
-    assert False
+    raise AssertionError()
 
 
 def confusion_matrix(

wandb/{sklearn → integration/sklearn}/calculate/elbow_curve.py

@@ -11,7 +11,7 @@ import wandb
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def elbow_curve(clusterer, X, cluster_ranges, n_jobs, show_cluster_time):
+def elbow_curve(clusterer, X, cluster_ranges, n_jobs, show_cluster_time):  # noqa: N803
     if cluster_ranges is None:
         cluster_ranges = range(1, 10, 2)
     else:
@@ -37,19 +37,19 @@ def make_table(cluster_ranges, clfs, times):
     return table
 
 
-def _compute_results_parallel(n_jobs, clusterer, X, cluster_ranges):
+def _compute_results_parallel(n_jobs, clusterer, x, cluster_ranges):
     parallel_runner = Parallel(n_jobs=n_jobs)
     _cluster_scorer = delayed(_clone_and_score_clusterer)
-    results = parallel_runner(_cluster_scorer(clusterer, X, i) for i in cluster_ranges)
+    results = parallel_runner(_cluster_scorer(clusterer, x, i) for i in cluster_ranges)
 
     clfs, times = zip(*results)
 
     return clfs, times
 
 
-def _clone_and_score_clusterer(clusterer, X, n_clusters):
+def _clone_and_score_clusterer(clusterer, x, n_clusters):
     start = time.time()
     clusterer = clone(clusterer)
-    setattr(clusterer, "n_clusters", n_clusters)
+    clusterer.n_clusters = n_clusters
 
-    return clusterer.fit(X).score(X), time.time() - start
+    return clusterer.fit(x).score(x), time.time() - start

wandb/{sklearn → integration/sklearn}/calculate/learning_curve.py

@@ -4,7 +4,7 @@ import numpy as np
 from sklearn import model_selection
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
@@ -12,7 +12,7 @@ simplefilter(action="ignore", category=FutureWarning)
 
 def learning_curve(
     model,
-    X,
+    X,  # noqa: N803
     y,
     cv=None,
     shuffle=False,

wandb/{sklearn → integration/sklearn}/calculate/outlier_candidates.py

@@ -3,13 +3,13 @@ from warnings import simplefilter
 import numpy as np
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def outlier_candidates(regressor, X, y):
+def outlier_candidates(regressor, X, y):  # noqa: N803
     # Fit a linear model to X and y to compute MSE
     regressor.fit(X, y)
 

wandb/{sklearn → integration/sklearn}/calculate/residuals.py

@@ -3,27 +3,27 @@ from warnings import simplefilter
 from sklearn import model_selection
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def residuals(regressor, X, y):
+def residuals(regressor, X, y):  # noqa: N803
     # Create the train and test splits
-    X_train, X_test, y_train, y_test = model_selection.train_test_split(
+    x_train, x_test, y_train, y_test = model_selection.train_test_split(
         X, y, test_size=0.2
     )
 
     # Store labels and colors for the legend ordered by call
-    regressor.fit(X_train, y_train)
-    train_score_ = regressor.score(X_train, y_train)
-    test_score_ = regressor.score(X_test, y_test)
+    regressor.fit(x_train, y_train)
+    train_score_ = regressor.score(x_train, y_train)
+    test_score_ = regressor.score(x_test, y_test)
 
-    y_pred_train = regressor.predict(X_train)
+    y_pred_train = regressor.predict(x_train)
     residuals_train = y_pred_train - y_train
 
-    y_pred_test = regressor.predict(X_test)
+    y_pred_test = regressor.predict(x_test)
     residuals_test = y_pred_test - y_test
 
     table = make_table(

wandb/{sklearn → integration/sklearn}/calculate/silhouette.py

@@ -5,13 +5,13 @@ from sklearn.metrics import silhouette_samples, silhouette_score
 from sklearn.preprocessing import LabelEncoder
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def silhouette(clusterer, X, cluster_labels, labels, metric, kmeans):
+def silhouette(clusterer, X, cluster_labels, labels, metric, kmeans):  # noqa: N803
     # Run clusterer for n_clusters in range(len(cluster_ranges), get cluster labels
     # TODO - keep/delete once we decide if we should train clusterers
     # or ask for trained models

wandb/{sklearn → integration/sklearn}/calculate/summary_metrics.py

@@ -4,13 +4,13 @@ import numpy as np
 import sklearn
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
+def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):  # noqa: N803
     """Calculate summary metrics for both regressors and classifiers.
 
     Called by plot_summary_metrics to visualize metrics. Please use the function

wandb/{sklearn → integration/sklearn}/plot/classifier.py

@@ -7,7 +7,7 @@ from sklearn import naive_bayes
 
 import wandb
 import wandb.plot
-from wandb.sklearn import calculate, utils
+from wandb.integration.sklearn import calculate, utils
 
 from . import shared
 
@@ -17,8 +17,8 @@ simplefilter(action="ignore", category=FutureWarning)
 
 def classifier(
     model,
-    X_train,
-    X_test,
+    X_train,  # noqa: N803
+    X_test,  # noqa: N803
     y_train,
     y_test,
     y_pred,
@@ -77,7 +77,7 @@ def classifier(
     )
     ```
     """
-    wandb.termlog("\nPlotting %s." % model_name)
+    wandb.termlog(f"\nPlotting {model_name}.")
 
     if not isinstance(model, naive_bayes.MultinomialNB):
         feature_importances(model, feature_names)
@@ -280,7 +280,7 @@ def class_proportions(y_train=None, y_test=None, labels=None):
         wandb.log({"class_proportions": class_proportions_chart})
 
 
-def calibration_curve(clf=None, X=None, y=None, clf_name="Classifier"):
+def calibration_curve(clf=None, X=None, y=None, clf_name="Classifier"):  # noqa: N803
     """Log a plot depicting how well-calibrated the predicted probabilities of a classifier are.
 
     Also suggests how to calibrate an uncalibrated classifier. Compares estimated predicted

wandb/{sklearn → integration/sklearn}/plot/clusterer.py

@@ -6,13 +6,13 @@ import pandas as pd
 import sklearn
 
 import wandb
-from wandb.sklearn import calculate, utils
+from wandb.integration.sklearn import calculate, utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer"):
+def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer"):  # noqa: N803
     """Generates all sklearn clusterer plots supported by W&B.
 
     The following plots are generated:
@@ -40,7 +40,7 @@ def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer
     wandb.sklearn.plot_clusterer(kmeans, X, cluster_labels, labels, "KMeans")
     ```
     """
-    wandb.termlog("\nPlotting %s." % model_name)
+    wandb.termlog(f"\nPlotting {model_name}.")
     if isinstance(model, sklearn.cluster.KMeans):
         elbow_curve(model, X_train)
         wandb.termlog("Logged elbow curve.")
@@ -54,7 +54,11 @@ def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer
 
 
 def elbow_curve(
-    clusterer=None, X=None, cluster_ranges=None, n_jobs=1, show_cluster_time=True
+    clusterer=None,
+    X=None,  # noqa: N803
+    cluster_ranges=None,
+    n_jobs=1,
+    show_cluster_time=True,
 ):
     """Measures and plots variance explained as a function of the number of clusters.
 
@@ -97,7 +101,7 @@ def elbow_curve(
 
 def silhouette(
     clusterer=None,
-    X=None,
+    X=None,  # noqa: N803
     cluster_labels=None,
     labels=None,
     metric="euclidean",
@@ -135,7 +139,7 @@ def silhouette(
 
     if not_missing and correct_types and is_fitted:
         if isinstance(X, (pd.DataFrame)):
-            X = X.values
+            X = X.values  # noqa: N806
         silhouette_chart = calculate.silhouette(
             clusterer, X, cluster_labels, labels, metric, kmeans
         )

wandb/{sklearn → integration/sklearn}/plot/regressor.py

@@ -5,7 +5,7 @@ from warnings import simplefilter
 import numpy as np
 
 import wandb
-from wandb.sklearn import calculate, utils
+from wandb.integration.sklearn import calculate, utils
 
 from . import shared
 
@@ -13,7 +13,7 @@ from . import shared
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):
+def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):  # noqa: N803
     """Generates all sklearn regressor plots supported by W&B.
 
     The following plots are generated:
@@ -38,7 +38,7 @@ def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):
     wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, "Ridge")
     ```
     """
-    wandb.termlog("\nPlotting %s." % model_name)
+    wandb.termlog(f"\nPlotting {model_name}.")
 
     shared.summary_metrics(model, X_train, y_train, X_test, y_test)
     wandb.termlog("Logged summary metrics.")
@@ -53,7 +53,7 @@ def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):
     wandb.termlog("Logged residuals.")
 
 
-def outlier_candidates(regressor=None, X=None, y=None):
+def outlier_candidates(regressor=None, X=None, y=None):  # noqa: N803
     """Measures a datapoint's influence on regression model via cook's distance.
 
     Instances with high influences could potentially be outliers.
@@ -87,7 +87,7 @@ def outlier_candidates(regressor=None, X=None, y=None):
         wandb.log({"outlier_candidates": outliers_chart})
 
 
-def residuals(regressor=None, X=None, y=None):
+def residuals(regressor=None, X=None, y=None):  # noqa: N803
     """Measures and plots the regressor's predicted value against the residual.
 
     The marginal distribution of residuals is also calculated and plotted.

wandb/{sklearn → integration/sklearn}/plot/shared.py

@@ -5,13 +5,13 @@ from warnings import simplefilter
 import numpy as np
 
 import wandb
-from wandb.sklearn import calculate, utils
+from wandb.integration.sklearn import calculate, utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
+def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):  # noqa: N803
     """Logs a chart depicting summary metrics for a model.
 
     Should only be called with a fitted model (otherwise an error is thrown).
@@ -47,7 +47,7 @@ def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
 
 def learning_curve(
     model=None,
-    X=None,
+    X=None,  # noqa: N803
     y=None,
     cv=None,
     shuffle=False,

wandb/{sklearn → integration/sklearn}/utils.py

@@ -61,7 +61,7 @@ def test_types(**kwargs):
                     list,
                 ),
             ):
-                wandb.termerror("%s is not an array. Please try again." % (k))
+                wandb.termerror(f"{k} is not an array. Please try again.")
                 test_passed = False
         # check for classifier types
         if k == "model":
@@ -69,20 +69,20 @@ def test_types(**kwargs):
                 not sklearn.base.is_regressor(v)
             ):
                 wandb.termerror(
-                    "%s is not a classifier or regressor. Please try again." % (k)
+                    f"{k} is not a classifier or regressor. Please try again."
                 )
                 test_passed = False
         elif k == "clf" or k == "binary_clf":
             if not (sklearn.base.is_classifier(v)):
-                wandb.termerror("%s is not a classifier. Please try again." % (k))
+                wandb.termerror(f"{k} is not a classifier. Please try again.")
                 test_passed = False
         elif k == "regressor":
             if not sklearn.base.is_regressor(v):
-                wandb.termerror("%s is not a regressor. Please try again." % (k))
+                wandb.termerror(f"{k} is not a regressor. Please try again.")
                 test_passed = False
         elif k == "clusterer":
             if not (getattr(v, "_estimator_type", None) == "clusterer"):
-                wandb.termerror("%s is not a clusterer. Please try again." % (k))
+                wandb.termerror(f"{k} is not a clusterer. Please try again.")
                 test_passed = False
     return test_passed
 
@@ -129,7 +129,7 @@ def test_missing(**kwargs):
     for k, v in kwargs.items():
         # Missing/empty params/datapoint arrays
         if v is None:
-            wandb.termerror("%s is None. Please try again." % (k))
+            wandb.termerror(f"{k} is None. Please try again.")
             test_passed = False
         if (k == "X") or (k == "X_test"):
             if isinstance(v, scipy.sparse.csr.csr_matrix):
@@ -168,8 +168,8 @@ def test_missing(**kwargs):
                 )
             if non_nums > 0:
                 wandb.termerror(
-                    "%s contains values that are not numbers. Please vectorize, label encode or one hot encode %s and call the plotting function again."
-                    % (k, k)
+                    f"{k} contains values that are not numbers. Please vectorize, label encode or one hot encode {k} "
+                    "and call the plotting function again."
                 )
                 test_passed = False
     return test_passed

wandb/{wandb_torch.py → integration/torch/wandb_torch.py}

@@ -1,11 +1,9 @@
-#!/usr/bin/env python
-
-"""PyTorch-specific functionality"""
+"""PyTorch-specific functionality."""
 
 import itertools
 from functools import reduce
 from operator import mul
-from typing import List
+from typing import TYPE_CHECKING, List
 
 import wandb
 from wandb import util
@@ -13,13 +11,18 @@ from wandb.data_types import Node
 
 torch = None
 
+if TYPE_CHECKING:
+    from torch import Tensor
+    from torch.nn import Module
+
 
 def nested_shape(array_or_tuple, seen=None):
-    """Figure out the shape of tensors possibly embedded in tuples
-    i.e
-    [0,0] returns (2)
-    ([0,0], [0,0]) returns (2,2)
-    (([0,0], [0,0]),[0,0]) returns ((2,2),2)
+    """Figure out the shape of tensors possibly embedded in tuples.
+
+    for example:
+    - [0,0] returns (2)
+    - ([0,0], [0,0]) returns (2,2)
+    - (([0,0], [0,0]),[0,0]) returns ((2,2),2).
     """
     if seen is None:
         seen = set()
@@ -49,14 +52,14 @@ LOG_TRACK_COUNT, LOG_TRACK_THRESHOLD = range(2)
 
 
 def log_track_init(log_freq: int) -> List[int]:
-    """create tracking structure used by log_track_update"""
-    l = [0] * 2
-    l[LOG_TRACK_THRESHOLD] = log_freq
-    return l
+    """Create tracking structure used by log_track_update."""
+    log_track = [0, 0]
+    log_track[LOG_TRACK_THRESHOLD] = log_freq
+    return log_track
 
 
 def log_track_update(log_track: int) -> bool:
-    """count (log_track[0]) up to threshold (log_track[1]), reset count (log_track[0]) and return true when reached"""
+    """Count (log_track[0]) up to threshold (log_track[1]), reset count (log_track[0]) and return true when reached."""
     log_track[LOG_TRACK_COUNT] += 1
     if log_track[LOG_TRACK_COUNT] < log_track[LOG_TRACK_THRESHOLD]:
         return False
@@ -65,7 +68,7 @@ def log_track_update(log_track: int) -> bool:
 
 
 class TorchHistory:
-    """History methods specific to PyTorch"""
+    """History methods specific to PyTorch."""
 
     def __init__(self):
         global torch
@@ -77,14 +80,15 @@ class TorchHistory:
 
     def add_log_parameters_hook(
         self,
-        module: "torch.nn.Module",
+        module: "Module",
         name: str = "",
         prefix: str = "",
         log_freq: int = 0,
     ) -> None:
-        """This instruments hooks into the pytorch module
+        """This instruments hooks into the pytorch module.
+
         log parameters after a forward pass
-        log_freq - log gradients/parameters every N batches
+        log_freq - log gradients/parameters every N batches.
         """
         # if name is not None:
         prefix = prefix + name
@@ -119,16 +123,19 @@ class TorchHistory:
 
     def add_log_gradients_hook(
         self,
-        module: "torch.nn.Module",
+        module: "Module",
         name: str = "",
         prefix: str = "",
         log_freq: int = 0,
     ) -> None:
-        """This instruments hooks into the pytorch module
-        log gradients after a backward pass
-        log_freq - log gradients/parameters every N batches
-        """
+        """This instruments hooks into the PyTorch module slog gradients after a backward pass.
 
+        Args:
+            module: torch.nn.Module - the module to instrument
+            name: str - the name of the module
+            prefix: str - the prefix to add to the name
+            log_freq: log gradients/parameters every N batches
+        """
         # if name is not None:
         prefix = prefix + name
 
@@ -143,8 +150,8 @@ class TorchHistory:
                     parameter, "gradients/" + prefix + name, log_track_grad
                 )
 
-    def log_tensor_stats(self, tensor, name):
-        """Add distribution statistics on a tensor's elements to the current History entry"""
+    def log_tensor_stats(self, tensor, name):  # noqa: C901
+        """Add distribution statistics on a tensor's elements to the current History entry."""
         # TODO Handle the case of duplicate names.
         if isinstance(tensor, (tuple, list)):
             while isinstance(tensor, (tuple, list)) and isinstance(
@@ -250,9 +257,7 @@ class TorchHistory:
         )
 
     def _hook_variable_gradient_stats(self, var, name, log_track):
-        """Logs a Variable's gradient's distribution statistics next time backward()
-        is called on it.
-        """
+        """Logs a Variable's gradient's distribution statistics next time backward() is called on it."""
         if not isinstance(var, torch.autograd.Variable):
             cls = type(var)
             raise TypeError(
@@ -288,10 +293,10 @@ class TorchHistory:
         else:
             return handle.id in d
 
-    def _no_finite_values(self, tensor: "torch.Tensor") -> bool:
+    def _no_finite_values(self, tensor: "Tensor") -> bool:
         return tensor.shape == torch.Size([0]) or (~torch.isfinite(tensor)).all().item()
 
-    def _remove_infs_nans(self, tensor: "torch.Tensor") -> "torch.Tensor":
+    def _remove_infs_nans(self, tensor: "Tensor") -> "Tensor":
         if not torch.isfinite(tensor).all():
             tensor = tensor[torch.isfinite(tensor)]
 
@@ -420,8 +425,7 @@ class TorchGraph(wandb.data_types.Graph):
 
     @classmethod
     def from_torch_layers(cls, module_graph, variable):
-        """Recover something like neural net layers from PyTorch Module's and the
-        compute graph from a Variable.
+        """Recover something like neural net layers from PyTorch Module's and the compute graph from a Variable.
 
         Example output for a multi-layer RNN. We confusingly assign shared embedding values
         to the encoder, but ordered next to the decoder.

wandb/proto/v3/wandb_base_pb2.py

@@ -14,7 +14,7 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1cwandb/proto/wandb_base.proto\x12\x0ewandb_internal\"6\n\x0b_RecordInfo\x12\x11\n\tstream_id\x18\x01 \x01(\t\x12\x14\n\x0c_tracelog_id\x18\x64 \x01(\t\"!\n\x0c_RequestInfo\x12\x11\n\tstream_id\x18\x01 \x01(\t\"#\n\x0b_ResultInfo\x12\x14\n\x0c_tracelog_id\x18\x64 \x01(\tb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1cwandb/proto/wandb_base.proto\x12\x0ewandb_internal\"6\n\x0b_RecordInfo\x12\x11\n\tstream_id\x18\x01 \x01(\t\x12\x14\n\x0c_tracelog_id\x18\x64 \x01(\t\"!\n\x0c_RequestInfo\x12\x11\n\tstream_id\x18\x01 \x01(\t\"#\n\x0b_ResultInfo\x12\x14\n\x0c_tracelog_id\x18\x64 \x01(\tB\x1bZ\x19\x63ore/pkg/service_go_protob\x06proto3')
 
 
 
@@ -45,6 +45,7 @@ _sym_db.RegisterMessage(_ResultInfo)
 if _descriptor._USE_C_DESCRIPTORS == False:
 
   DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'Z\031core/pkg/service_go_proto'
   __RECORDINFO._serialized_start=48
   __RECORDINFO._serialized_end=102
   __REQUESTINFO._serialized_start=104