# Neptune Fetcher
> [!NOTE]
> This package is experimental and only works with Neptune Scale, which is in beta.
>
> You can't use this package with `neptune<2.0` or the currently available Neptune app version. For the corresponding
> Python API, see [neptune-client](https://github.com/neptune-ai/neptune-client).
Neptune Fetcher is designed to separate data retrieval capabilities from the regular `neptune` package. This separation
makes data fetching more efficient and improves performance.
## Installation
```bash
pip install neptune-fetcher
```
Set your Neptune API token and project name as environment variables:
```bash
export NEPTUNE_API_TOKEN="h0dHBzOi8aHR0cHM.4kl0jvYh3Kb8...ifQ=="
```
```bash
export NEPTUNE_PROJECT="workspace-name/project-name"
```
For help, see https://docs-beta.neptune.ai/setup.
> **Note:** To change the token or project, you can [set the context](#working-with-multiple-projects) directly in the code. This way, you can work with multiple projects at the same time.
## Usage: Alpha version
To try the next major version of the Fetcher API, use the `alpha` module.
```python
import neptune_fetcher.alpha as npt
```
### Listing experiments
Filter experiments by name that match a regex:
```python
npt.list_experiments(r"exp_.*")
```
```pycon
['exp_xjjrq', 'exp_ymgun', 'exp_nmjbt', 'exp_ixgwm', 'exp_rdmuw']
```
### Listing unique attributes
Filter attributes by name and by experiment that they belong to:
```python
npt.list_attributes(
experiments=r"exp.*",
attributes=r"metrics.*|config/.*",
)
```
```pycon
['config/batch_size',
'config/epochs',
'config/last_event_time',
'config/learning_rate',
'config/optimizer',
'config/use_bias',
'metrics/accuracy',
'metrics/loss',
'metrics/val_accuracy',
'metrics/val_loss']
```
### Fetching metadata table
To fetch experiment metadata from your project, use the `fetch_experiments_table()` function.
- To filter experiments to return, use the `experiments` parameter.
- To specify attributes to include as columns, use the `attributes` parameter.
For both arguments, you can specify a simple string to match experiment or attribute names against, or you can use the Filter classes to [construct more complex filters](#constructing-filters).
> Fetching metrics this way returns an aggregation value for each attribute. The default aggregation is the last logged value.
>
> To fetch actual metric values at each step, see [`fetch_experiment_metrics()`](#fetching-metric-values).
```python
npt.fetch_experiments_table(
experiments=r"exp.*",
attributes=r".*metric.*/val_.+",
)
```
```pycon
metrics/val_accuracy metrics/val_loss
last last
experiment
exp_ergwq 0.278149 0.336344
exp_qgguv 0.160260 0.790268
exp_cnuwh 0.702490 0.366390
exp_kokxd 0.301545 0.917683
exp_gyvpp 0.999489 0.069839
```
### Fetching metric values
To fetch individual values from one or more float series attributes, use the `fetch_experiment_metrics()` function:
```python
npt.fetch_experiment_metrics(
experiments=r"exp.*",
attributes=r"metrics/.*",
)
```
```pycon
experiment step metrics/accuracy metrics/loss metrics/val_accuracy metrics/val_loss
0 exp_dczjz 0 0.819754 0.588655 0.432187 0.823375
1 exp_dczjz 1 0.347907 0.297161 0.649685 0.971732
2 exp_dczjz 2 0.858863 0.988583 0.760142 0.154741
3 exp_dczjz 3 0.217097 None 0.719508 0.504652
4 exp_dczjz 4 0.089981 0.463146 0.180321 0.503800
5 exp_hgctc 0 0.318828 0.386347 0.012390 0.171790
6 exp_hgctc 1 0.035026 0.087053 0.392041 0.768675
7 exp_hgctc 2 0.004711 0.061848 None 0.847072
8 exp_hgctc 3 0.359770 0.130022 0.479945 0.323537
9 exp_hgctc 4 0.007815 0.746344 0.102646 0.055511
```
### Working with multiple projects
To work with multiple projects simultaneously, you can use contexts. This way, you can set the scope for individual fetching calls or globally for your session.
- To set a new project or API token globally, use `set_project()` or `set_api_token()`:
```python
npt.set_project('some-workspace/another-project')
```
- To create a context object that you can pass to the `context` argument of a fetching method:
```python
another_project_context = npt.get_context().with_project('some-workspace/another-project')
npt.list_experiments(r"exp_.*", context=another_project_context)
```
Example flow:
1. `NEPTUNE_PROJECT` environment variable is read on module initialization:
```python
import neptune_fetcher.alpha as npt
```
1. Work on the default project inferred from the environment variables:
```python
npt.list_experiments(r"exp_.*")
```
```pycon
['exp_dhxxz', 'exp_saazg', 'exp_sxlrq', 'exp_vlqfe', 'exp_fpogj']
```
1. Work on another project without changing the global context:
```python
another_project_ctx = npt.get_context().with_project('some-workspace/another-project')
npt.list_experiments(r"exp_.*", context=another_project_ctx)
```
```pycon
['exp_oecez', 'exp_ytbda', 'exp_khfym']
```
1. Change the project globally:
```python
npt.set_project('some-workspace/another-project')
```
1. Do some more work on another project:
```python
npt.list_experiments(r"exp_.*")
```
```pycon
['exp_oecez', 'exp_ytbda', 'exp_khfym']
```
### Constructing filters
#### Filtering experiments
Use the Filter class to specify criteria when fetching experiments or runs.
> Examples of filters:
>
> - Name or attribute must match regular expression.
> - Attribute value must pass a condition, like "greater than 0.9".
You can negate a filter or join multiple filters with logical operators.
Methods available for attribute values:
- `eq()`: Equals
- `ne()`: Doesn't equal
- `gt()`: Greater than
- `ge()`: Greater than or equal to
- `lt()`: Less than
- `le()`: Less than or equal to
- `matches_all()`: Matches regex or all in list of regexes
- `matches_none()`: Doesn't match regex or any of list of regexes
- `contains_all()`: Tagset contains all tags, or string contains substrings
- `contains_none()`: Tagset doesn't contain any of the tags, or string doesn't contain the substrings
- `exists()`: Attribute exists
##### Examples
Import the needed classes:
```python
import neptune_fetcher.alpha as npt
from npt.filters import Attribute, Filter
```
Constructing filters:
A) Regex that the experiment or run name must match:
```python
name_filter = Filter.matches_all("sys/name", r"kittiwake$")
```
B) Don't allow the tags "test" or "val":
```python
no_test_or_val = Filter.contains_none("sys/tags", ["test", "val"])
```
C) Set a condition for the last logged value of a metric:
```python
loss_filter = Filter.lt("validation/loss", 0.1)
```
For more control over the selected metric, use the `Attribute()` helper class.
D) Negate a filter: Call `negate()` or prepend with `~`:
```python
not_loss_filter = ~loss_filter
# equivalent to
not_loss_filter = Filter.negate(loss_filter)
```
E) Combining filters:
- To join with AND: Use `&` or pass the filters to the `all()` method.
- To join with OR: Use `|` or pass the filters to the `any()` method.
```python
name_and_loss_filter = name_filter & loss_filter
# equivalent to
name_and_loss_filter = Filter.all(name_filter, loss_filter)
```
To use a filter in a query, pass it as the argument to a fetching or listing method:
```python
npt.fetch_experiments_table(experiments=name_and_loss_filter)
```
#### Filtering attributes
When fetching metadata with the `fetch_experiments_table()` function, in the returned table, each column represents an attribute.
To select specific metrics or other attributes based on various criteria, use the `AttributeFilter` class.
##### Examples
Select attribute by exact name:
```python
AttributeFilter(name_eq="config/optimizer")
```
Select metrics that don't match regexes `^test` or `loss$` and pick the "average" and "variance" aggregations:
```python
AttributeFilter(
type_in=["float_series"],
name_matches_none=[r"^test", r"loss$"],
aggregations=["average", "variance"],
)
```
In this case, the returned table includes "average" and "variance" columns for each metric:
```pycon
attribute train/accuracy validation/accuracy
aggregation average variance average variance
experiment
exp-1738662528 0.000000 0.000273 0.0 0.000269
exp-1738325381 0.000000 0.594614 0.0 0.595119
...
```
> For the types reference, see: https://docs-beta.neptune.ai/attribute_types
Combine multiple filters with the pipe character:
```python
filter_1 = AttributeFilter(...)
filter_2 = AttributeFilter(...)
filter_3 = AttributeFilter(...)
alternatives = filter_1 | filter_2 | filter_3
```
To use a filter, pass it to the `attributes` argument of the `fetch_experiments_table()` function:
```python
npt.fetch_experiments_table(
experiments=...,
attributes=AttributeFilter(...),
)
```
#### `Attribute` helper class
Used for specifying a single attribute and picking a metric aggregation function.
When fetching experiments or runs, use this class to filter and sort the returned entries.
##### Examples
Select a metric and pick variance as the aggregation:
```python
import neptune_fetcher.alpha as npt
from npt.filters import Attribute, Filter
val_loss_variance = Attribute(
name="val/loss",
aggregation="variance",
)
```
Construct a filter around the attribute, then pass it to a fetching or listing method:
```python
tiny_val_loss_variance = Filter.lt(val_loss_variance, 0.01)
npt.fetch_experiments_table(experiments=tiny_val_loss_variance)
```
### Working with runs
Experiments consist of runs. By default, the Fetcher API returns metadata only from experiment head runs, not all individual runs.
To work with runs, you can use the corresponding run methods:
```python
from neptune_fetcher.alpha.runs import (
fetch_run_metrics,
fetch_runs_table,
list_run_attributes,
list_runs,
)
```
Note the difference in specifying runs versus experiments:
- Experiments are characterized by name (`sys/name`). This is the string passed to the `name` argument at creation.
- Runs are characterized by ID (`sys/custom_run_id`). This is the string passed to the `run_id` argument at creation.
---
## Usage: Fetcher `0.x`
> [!NOTE]
> We're redesigning the Fetcher API.
>
> To try the new version, see [Usage: Alpha version](#usage-alpha-version).
In your Python code, create a [`ReadOnlyProject`](#readonlyproject) instance:
```python
from neptune_fetcher import ReadOnlyProject
my_project = ReadOnlyProject()
```
Now you have a Neptune project to operate on.
> If you don't set the Neptune environment variables, you can pass your credentials through arguments when creating a project or run object.
To fetch experiments in bulk, call a fetching method on the project:
```python
experiments_df = my_project.fetch_experiments_df(
names_regex="tree/.*",
columns=["sys/custom_run_id", "sys/modification_time"],
query='(last(`accuracy`:floatSeries) > 0.88) AND (`learning_rate`:float < 0.01)',
)
```
To fetch metadata from an individual experiment or run, create and use a [`ReadOnlyRun`](#readonlyrun) object:
```python
from neptune_fetcher import ReadOnlyRun
run = ReadOnlyRun(
read_only_project=my_project,
experiment_name="seagull-flying-skills",
)
# Fetch value
print(run["parameters/optimizer"].fetch())
# Fecth last value of metric
print(run["metrics/loss"].fetch_last())
# Fetch all metric values, with optional pre-fetching to speed up subsequent access to the field
run.prefetch_series_values(["metrics/accuracy"])
print(run["metrics/accuracy"].fetch_values())
```
For details, see the Neptune documentation:
- [Fetch runs or experiments](https://docs-beta.neptune.ai/fetch_runs)
- [Fetch metadata from a run or experiment](https://docs-beta.neptune.ai/fetch_run_data)
- [Neptune Query Language (NQL)](https://docs-beta.neptune.ai/nql)
### Examples
#### Listing runs of a project
```python
from neptune_fetcher import ReadOnlyProject
project = ReadOnlyProject("workspace/project")
for run in project.list_runs():
print(run) # dicts with identifiers
```
#### Listing experiments of a project
```python
from neptune_fetcher import ReadOnlyProject
project = ReadOnlyProject("workspace/project")
for experiment in project.list_experiments():
print(experiment) # dicts with identifiers
```
#### Fetching runs data frame with specific columns
```python
from neptune_fetcher import ReadOnlyProject
project = ReadOnlyProject("workspace/project")
runs_df = project.fetch_runs_df(
columns=["sys/custom_run_id", "sys/modification_time"],
columns_regex="tree/.*", # added to columns specified with the "columns" parameter
)
```
#### Fetching data from specified runs
```python
from neptune_fetcher import ReadOnlyProject
project = ReadOnlyProject("workspace/project")
for run in project.fetch_read_only_runs(with_ids=["RUN-1", "RUN-2"]):
run.prefetch(["parameters/optimizer", "parameters/init_lr"])
print(run["parameters/optimizer"].fetch())
print(run["parameters/init_lr"].fetch())
```
#### Fetching data from a single run
```python
from neptune_fetcher import ReadOnlyProject, ReadOnlyRun
project = ReadOnlyProject("workspace/project")
run = ReadOnlyRun(project, with_id="TES-1")
run.prefetch(["parameters/optimizer", "parameters/init_lr"])
run.prefetch_series_values(["metrics/loss", "metrics/accuracy"], use_threads=True)
print(run["parameters/optimizer"].fetch())
print(run["parameters/init_lr"].fetch())
print(run["metrics/loss"].fetch_values())
print(run["metrics/accuracy"].fetch_values())
```
### API reference
#### Supported regular expressions
Neptune uses the [RE2](https://github.com/google/re2) regular expression library. For supported regex features and limitations, see the official [syntax guide](https://github.com/google/re2/wiki/syntax).
#### `ReadOnlyProject`
Representation of a Neptune project in a limited read-only mode.
##### Initialization
Initialize with the ReadOnlyProject class constructor:
```python
project = ReadOnlyProject("workspace/project", api_token="...")
```
> [!TIP]
> Find your API token in your user menu, in the bottom-left corner of the Neptune app.
__Parameters:__
| Name | Type | Default | Description |
|-------------|------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `project` | `str`, optional | `None` | Name of a project in the form `workspace-name/project-name`. If `None`, the value of the `NEPTUNE_PROJECT` environment variable is used. |
| `api_token` | `str`, optional | `None` | Your Neptune API token (or a service account's API token). If `None`, the value of the `NEPTUNE_API_TOKEN` environment variable is used. To keep your token secure, avoid placing it in source code. Instead, save it as an environment variable. |
| `proxies` | `dict`, optional | `None` | Dictionary of proxy settings, if needed. This argument is passed to HTTP calls made via the Requests library. For details on proxies, see the [Requests documentation](https://requests.readthedocs.io/). |
---
##### `list_runs()`
Lists all runs of a project.
Each run is identified by Neptune ID (`sys/id`), custom ID (`sys/custom_run_id`) and, if set, name (`sys/name`).
__Returns:__ `Iterator` of dictionaries with Neptune run identifiers, custom identifiers and names.
__Example:__
```python
project = ReadOnlyProject()
for run in project.list_runs():
print(run)
```
---
##### `list_experiments()`
Lists all experiments of a project.
Each experiment is identified by:
- Neptune ID: `sys/id`
- (If set) Custom ID: `sys/custom_run_id`
- Name: `sys/name`
__Example:__
```python
for experiment in project.list_experiments():
print(experiment)
```
__Returns:__ `Iterator` of dictionaries with Neptune experiment identifiers, custom identifiers and names.
---
##### `fetch_runs()`
Fetches a table containing Neptune IDs, custom run IDs and names of runs in the project.
__Returns:__ `pandas.DataFrame` `pandas.DataFrame` with three columns (`sys/id`, `sys/name` and `sys/custom_run_id`)
and one row for each run.
__Example:__
```python
project = ReadOnlyProject()
df = project.fetch_runs()
```
---
##### `fetch_experiments()`
Fetches a table containing Neptune IDs, custom IDs and names of experiments in the project.
__Example__:
```python
df = project.fetch_experiments()
```
__Returns__:
`pandas.DataFrame` with three columns (`sys/id`, `sys/custom_run_id`, `sys/name`) and one row for each experiment.
---
##### `fetch_runs_df()`
Fetches the runs' metadata and returns them as a pandas DataFrame.
__Parameters:__
| Name | Type | Default | Description |
|-------------------|-----------------------|---------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `columns` | `List[str]`, optional | `None` | Names of columns to include in the table, as a list of field names. The sorting column, custom run identifier (`sys/custom_run_id`), and experiment name (`sys/name`) are always included. `None` results in returning only the default columns.
| `columns_regex` | `str`, optional | `None` | A regex pattern to filter columns by name. Use this parameter to include columns in addition to the ones specified by the `columns` parameter.
| `names_regex` | `str`, optional | `None` | A regex pattern to filter the runs by name. |
| `custom_id_regex` | `str`, optional | `None` | A regex pattern to filter the runs by custom ID. |
| `with_ids` | `List[str]`, optional | `None` | List of multiple Neptune IDs. Example: `["NLU-1", "NLU-2"]`. Matching any element of the list is sufficient to pass the criterion. |
| `custom_ids` | `List[str]`, optional | `None` | List of multiple custom IDs. Example: `["nostalgic_shockley", "high_albattani"]`. Matching any element of the list is sufficient to pass the criterion. |
| `states` | `List[str]`, optional | `None` | List of states. Possible values: `"inactive"`, `"active"`. "Active" means that at least one process is connected to the run. Matching any element of the list is sufficient to pass the criterion. |
| `owners` | `List[str]`, optional | `None` | List of multiple owners. Example: `["frederic", "josh"]`. The owner is the user who created the run. Matching any element of the list is sufficient to pass the criterion. |
| `tags` | `List[str]`, optional | `None` | A list of tags. Example: `"lightGBM"` or `["pytorch", "cycleLR"]`. **Note:** Only runs that have all specified tags will pass this criterion. |
| `trashed` | `bool`, optional | `False` | Whether to retrieve trashed runs. If `True`, only trashed runs are retrieved. If `False`, only non-trashed runs are retrieved. If `None` or left empty, all run objects are retrieved, including trashed ones. |
| `limit` | `int`, optional | `None` | Maximum number of runs to fetch. If `None`, all runs are fetched. |
| `sort_by` | `str`, optional | `sys/creation_time` | Name of the field to sort the results by. The field must represent a simple type (string, float, integer). |
| `ascending` | `bool`, optional | `False` | Whether to sort the entries in ascending order of the sorting column values. |
| `progress_bar` | `bool` | `True` | Set to `False `to disable the download progress bar. |
| `query` | `str`, optional | `None` | NQL query string. Example: `"(accuracy: float > 0.88) AND (loss: float < 0.2)"`. The query is applied on top of other criteria like, `custom_ids`, `tags` etc, using the logical AND operator. See examples below. For syntax, see [Neptune Query Language](https://docs.neptune.ai/usage/nql/) in the Neptune docs. |
__Returns:__ `pandas.DataFrame`: A pandas DataFrame containing metadata of the fetched runs.
> [!IMPORTANT]
> The following fields are always included:
>
> - `sys/custom_run_id`: the custom run identifier.
> - The field to sort by. That is, the field name passed to the `sort_by` argument.
>
> The maximum number of runs that can be returned is 5000.
__Examples:__
Fetch all runs, with specific columns:
```python
project = ReadOnlyProject()
runs_df = project.fetch_runs_df(
columns=["sys/modification_time", "training/lr"]
)
```
Fetch all runs, with specific columns and extra columns that match a regex pattern:
```python
runs_df = project.fetch_runs_df(
columns=["sys/modification_time"],
columns_regex="tree/.*",
)
```
Fetch runs by specific ID:
```python
specific_runs_df = my_project.fetch_runs_df(custom_ids=["nostalgic_shockley", "high_albattani"])
```
Fetch runs by names that match a regex pattern:
```python
specific_runs_df = my_project.fetch_runs_df(
names_regex="tree_3[2-4]+"
)
```
Fetch runs with a complex query using NQL.
```python
runs_df = my_project.fetch_runs_df(
query='(last(`accuracy`:floatSeries) > 0.88) AND (`learning_rate`:float < 0.01)'
)
```
---
##### `fetch_experiments_df()`
Fetches the experiments' metadata and returns them as a pandas DataFrame.
__Parameters__:
| Name | Type | Default | Description |
|-----------------------|-----------------------|---------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `columns` | `List[str]`, optional | `None` | Names of columns to include in the table, as a list of field names. The sorting column, custom run identifier (`sys/custom_run_id`), and experiment name (`sys/name`) are always included. `None` results in returning only the default columns.
| `columns_regex` | `str`, optional | `None` | A regex pattern to filter columns by name. Use this parameter to include columns in addition to the ones specified by the `columns` parameter.
| `names_regex` | `str`, optional | `None` | A regex pattern to filter the experiments by name. |
| `names_regex` | `str`, optional | `None` | A regex pattern or a list of regex patterns to filter the experiments by name. Multiple patterns will be connected by AND logic. |
| `names_exclude_regex` | `str`, optional | `None` | A regex pattern or a list of regex patterns to exclude experiments by name. Multiple patterns will be connected by AND logic. |
| `custom_id_regex` | `str`, optional | `None` | A regex pattern to filter the experiments by custom ID. |
| `with_ids` | `List[str]`, optional | `None` | List of multiple Neptune IDs. Example: `["NLU-1", "NLU-2"]`. Matching any element of the list is sufficient to pass the criterion. |
| `custom_ids` | `List[str]`, optional | `None` | List of multiple custom IDs. Example: `["nostalgic_shockley", "high_albattani"]`. Matching any element of the list is sufficient to pass the criterion. |
| `states` | `List[str]`, optional | `None` | List of states. Possible values: `"inactive"`, `"active"`. "Active" means that at least one process is connected to the experiment. Matching any element of the list is sufficient to pass the criterion. |
| `owners` | `List[str]`, optional | `None` | List of multiple owners. Example: `["frederic", "josh"]`. The owner is the user who created the experiement. Matching any element of the list is sufficient to pass the criterion. |
| `tags` | `List[str]`, optional | `None` | A list of tags. Example: `"lightGBM"` or `["pytorch", "cycleLR"]`. **Note:** Only experiments that have all specified tags will pass this criterion. |
| `trashed` | `bool`, optional | `False` | Whether to retrieve trashed experiments. If `True`, only trashed experiments are retrieved. If `False`, only non-trashed experiments are retrieved. If `None` or left empty, all experiment objects are retrieved, including trashed ones. |
| `limit` | `int`, optional | `None` | Maximum number of experiments to fetch. If `None`, all experiments are fetched. |
| `sort_by` | `str`, optional | `sys/creation_time` | Name of the field to sort the results by. The field must represent a simple type (string, float, integer). |
| `ascending` | `bool`, optional | `False` | Whether to sort the entries in ascending order of the sorting column values. |
| `progress_bar` | `bool` | `True` | Set to `False `to disable the download progress bar. |
| `query` | `str`, optional | `None` | NQL query string. Example: `"(accuracy: float > 0.88) AND (loss: float < 0.2)"`. The query is applied on top of other criteria like, `custom_ids`, `tags` etc, using the logical AND operator. See examples below. For syntax, see [Neptune Query Language](https://docs.neptune.ai/usage/nql/) in the Neptune docs. |
__Returns:__ `pandas.DataFrame`: A pandas DataFrame containing metadata of the fetched experiments.
> [!IMPORTANT]
> The following fields are always included:
>
> - `sys/custom_run_id`: the custom run identifier.
> - `sys/name`: the experiment name.
> - The field to sort by. That is, the field name passed to the `sort_by` argument.
>
> The maximum number of runs that can be returned is 5000.
__Examples:__
Fetch all experiments with specific columns:
```python
experiments_df = project.fetch_experiments_df(
columns=["sys/custom_run_id", "sys/modification_time", "training/lr"]
)
```
Fetch all experiments with specific columns and extra columns that match a regex pattern:
```python
experiments_df = project.fetch_experiments_df(
columns=["sys/custom_run_id", "sys/modification_time"],
columns_regex="tree/.*",
)
```
Fetch experiments by specific IDs:
```python
specific_experiments_df = my_project.fetch_experiments_df(
custom_ids=["nostalgic_shockley", "high_albattani"]
)
```
Use the Neptune Query Language to fetch experiments with a complex query. Note that for regular strings, the `\` character needs to be escaped:
```python
experiments_df = my_project.fetch_experiments_df(
query='(`learning_rate`:float < 0.01) AND (`sys/name`:string MATCHES "experiment-\\\\d+")'
)
```
As a less cluttered alternative, pass a raw Python string to the `query` argument:
```python
experiments_df = my_project.fetch_experiments_df(
query=r'(`learning_rate`:float < 0.01) AND (`sys/name`:string MATCHES "experiment-\\d+")'
)
```
---
##### `fetch_read_only_runs()`
List runs of the project in the form of ReadOnlyRun.
__Parameters:__
| Name | Type | Default | Description |
|--------------|-----------------------|---------|-----------------------------------|
| `with_ids` | `Optional[List[str]]` | `None` | List of Neptune run IDs to fetch. |
| `custom_ids` | `Optional[List[str]]` | `None` | List of custom run IDs to fetch. |
__Returns:__ Iterator of ReadOnlyRun objects.
__Example:__
```python
project = ReadOnlyProject()
for run in project.fetch_read_only_runs(custom_ids=["nostalgic_shockley", "high_albattani"]):
...
```
---
##### `fetch_read_only_experiments()`
Lists experiments of the project in the form of ReadOnlyRun.
__Parameters:__
| Name | Type | Default | Description |
|---------|-----------------------|---------|------------------------------------|
| `names` | `Optional[List[str]]` | `None` | List of experiment names to fetch. |
__Returns:__ Iterator of ReadOnlyRun objects.
__Example:__
```python
project = ReadOnlyProject()
for run in project.fetch_read_only_experiments(names=["yolo-v2", "yolo-v3"]):
...
```
---
#### `ReadOnlyRun`
Representation of a Neptune run in a limited read-only mode.
##### Initialization
Can be created
- with the class constructor:
```python
project = ReadOnlyProject()
run = ReadOnlyRun(project, with_id="TES-1")
```
- or as a result of the [`fetch_read_only_runs()`](#fetch_read_only_runs) method of the `ReadOnlyProject` class:
```python
for run in project.fetch_read_only_runs(
custom_ids=["nostalgic_shockley", "high_albattani"]):
...
```
__Parameters:__
| Name | Type | Default | Description |
|------------------------------------|-------------------|---------|------------------------------------------------------------------------------------------------------------------------------------|
| `read_only_project` | `ReadOnlyProject` | - | Project from which the run is fetched. |
| `with_id` | `Optional[str]` | `None` | ID of the Neptune run to fetch. Example: `RUN-1`. Exclusive with the `custom_id` and `experiment_name` parameters. |
| `custom_id` | `Optional[str]` | `None` | Custom ID of the Neptune run to fetch. Example: `high_albattani`. Exclusive with the `with_id` and `experiment_name` parameters. |
| `experiment_name` | `Optional[str]` | `None` | Name of the Neptune experiment to fetch. Example: `high_albattani`. Exclusive with the `with_id` and `custom_id` parameters. |
| `eager_load_fields` | `Optional[bool]` | `True` | Whether to eagerly load the run fields definitions. If `False`, individual fields are loaded only when accessed. Default is `True`. |
__Example:__
```python
from neptune_fetcher import ReadOnlyProject, ReadOnlyRun
project = ReadOnlyProject("workspace-name/project-name", api_token="...")
run = ReadOnlyRun(project, custom_id="high_albattani")
```
---
##### `.field_names`
List of run field names.
A _field_ is the location where a piece of metadata is stored in the run.
__Returns:__ Iterator of run fields as strings.
__Example:__
```python
for run in project.fetch_read_only_runs(custom_ids=["nostalgic_shockley", ...]):
print(list(run.field_names))
```
---
##### Field lookup: `run[field_name]`
Used to access a specific field of a run. See [Available types](#available-types).
__Returns:__ An internal object used to operate on a specific field.
__Example:__
```python
run = ReadOnlyRun(...)
custom_id = run["sys/custom_run_id"].fetch()
```
---
##### `prefetch()`
Pre-fetches a batch of fields to the internal cache.
Improves the performance of access to consecutive field values.
Supported Neptune field types:
- [`Boolean`](#boolean)
- [`Datetime`](#datetime)
- [`Float`](#float)
- [`FloatSeries`](#floatseries)
- [`Integer`](#integer)
- [`ObjectState`](#objectstate)
- [`String`](#string)
- [`StringSet`](#stringset)
__Parameters:__
| Name | Type | Default | Description |
|---------|-------------|---------|--------------------------------------------|
| `paths` | `List[str]` | - | List of field paths to fetch to the cache. |
__Example:__
```python
run = ReadOnlyRun(...)
run.prefetch(["parameters/optimizer", "parameter/init_lr"])
# No more calls to the API
print(run["parameters/optimizer"].fetch())
print(run["parameter/init_lr"].fetch())
```
#### `prefetch_series_values()`
Prefetches a batch of series to the internal cache. This method skips the non-existing attributes.
Improves the performance of access to consecutive field values. Works only for series ([`FloatSeries`](#floatseries)).
To speed up the fetching process, this method can use multithreading.
To enable it, set the `use_threads` parameter to `True`.
By default, the maximum number of workers is 10. You can change this number by setting the `NEPTUNE_FETCHER_MAX_WORKERS`
environment variable.
__Parameters__:
| Name | Type | Default | Description |
|---------------------|-----------------------|--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `paths` | `List[str]`, required | `None` | List of paths to prefetch to the internal cache. |
| `use_threads` | `bool`, optional | `False` | Whether to use threads to fetch the data. |
| `progress_bar` | `bool` | `True` | Set to False to disable the download progress bar. |
| `include_inherited` | `bool`, optional | `True` | If True (default), values inherited from ancestor runs are included. To only fetch values from the current run, set to False. |
| `step_range` | `tuple[float, float]` | (None, None) | Limits the range of steps to fetch. This must be a 2-tuple: <br> - `left`: The left boundary of the range (inclusive). If `None`, the range extends indefinitely on the left.<br>- `right`: The right boundary of the range (inclusive). If `None`, the range extends indefinitely on the right. |
__Example__:
```python
run.prefetch_series_values(["metrics/loss", "metrics/accuracy"])
# No more calls to the API
print(run["metrics/loss"].fetch_values())
print(run["metrics/accuracy"].fetch_values())
```
### Available types
This section lists the available field types and data retrieval operations.
---
#### `Boolean`
##### `fetch()`
Retrieves a `bool` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.
__Example:__
```python
status = run["sys/failed"].fetch()
```
---
#### `Datetime`
##### `fetch()`
Retrieves a `datetime.datetime` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.
__Example:__
```python
created_at = run["sys/creation_time"].fetch()
```
---
#### `Float`
##### `fetch()`
Retrieves a `float` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.
__Example:__
```python
f1 = run["scores/f1"].fetch()
```
---
#### `FloatSeries`
##### `fetch()` or `fetch_last()`
Retrieves the last value of a series, either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.
__Returns:__ `Optional[float]`
__Example:__
```python
loss = run["loss"].fetch_last()
```
##### `fetch_values()`
Retrieves all series values either from the internal cache (see [`prefetch_series_values()`](#prefetch_series_values))
or from the API.
__Parameters:__
| Name | Type | Default | Description |
|---------------------|-----------------------|--------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `include_timestamp` | `bool` | `True` | Whether the fetched data should include the timestamp field. |
| `include_inherited` | `bool` | `True` | If True (default), values inherited from ancestor runs are included. To only fetch values from the current run, set to False. |
| `progress_bar` | `bool` | `True` | Set to False to disable the download progress bar. |
| `step_range` | `tuple[float, float]` | (None, None) | - left: left boundary of the range (inclusive). If None, it\'s open on the left. <br> - right: right boundary of the range (inclusive). If None, it\'s open on the right. |
__Returns:__ `pandas.DataFrame`
__Example:__
```python
values = run["loss"].fetch_values()
```
---
#### `Integer`
##### `fetch()`
Retrieves an `int` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.
__Example:__
```python
batch_size = run["batch_size"].fetch()
```
---
#### `ObjectState`
##### `fetch()`
Retrieves the state of a run either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.
__Returns:__ `str`
> [!NOTE]
> The state can be **active** or **inactive**. It refers to whether new data was recently logged to the run.
> To learn more about this field, see [System namespace: State](https://docs.neptune.ai/api/sys/#state) in the Neptune
> docs.
__Example:__
```python
state = run["sys/state"].fetch()
```
---
#### `String`
##### `fetch()`
Retrieves a `str` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.
__Example:__
```python
token = run["token"].fetch()
```
---
#### `StringSet`
##### `fetch()`
Retrieves a `dict` of `str` values either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.
__Example:__
```python
groups = run["sys/group_tags"].fetch()
```
---
## License
This project is licensed under the Apache License Version 2.0. For more details,
see [Apache License Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).
Raw data
{
"_id": null,
"home_page": null,
"name": "neptune-fetcher",
"maintainer": null,
"docs_url": null,
"requires_python": "<4.0,>=3.9",
"maintainer_email": null,
"keywords": "MLOps, ML Experiment Tracking, ML Model Registry, ML Model Store, ML Metadata Store",
"author": "neptune.ai",
"author_email": "contact@neptune.ai",
"download_url": "https://files.pythonhosted.org/packages/69/3c/34451a434b6c94b8c40adbbc3996e598b73eb6d8d012c92497a75673c3c8/neptune_fetcher-0.13.0.tar.gz",
"platform": null,
"description": "# Neptune Fetcher\n\n> [!NOTE]\n> This package is experimental and only works with Neptune Scale, which is in beta.\n>\n> You can't use this package with `neptune<2.0` or the currently available Neptune app version. For the corresponding\n> Python API, see [neptune-client](https://github.com/neptune-ai/neptune-client).\n\nNeptune Fetcher is designed to separate data retrieval capabilities from the regular `neptune` package. This separation\nmakes data fetching more efficient and improves performance.\n\n## Installation\n\n```bash\npip install neptune-fetcher\n```\n\nSet your Neptune API token and project name as environment variables:\n\n```bash\nexport NEPTUNE_API_TOKEN=\"h0dHBzOi8aHR0cHM.4kl0jvYh3Kb8...ifQ==\"\n```\n\n```bash\nexport NEPTUNE_PROJECT=\"workspace-name/project-name\"\n```\n\nFor help, see https://docs-beta.neptune.ai/setup.\n\n> **Note:** To change the token or project, you can [set the context](#working-with-multiple-projects) directly in the code. This way, you can work with multiple projects at the same time.\n\n## Usage: Alpha version\n\nTo try the next major version of the Fetcher API, use the `alpha` module.\n\n```python\nimport neptune_fetcher.alpha as npt\n```\n\n### Listing experiments\n\nFilter experiments by name that match a regex:\n\n```python\nnpt.list_experiments(r\"exp_.*\")\n```\n\n```pycon\n['exp_xjjrq', 'exp_ymgun', 'exp_nmjbt', 'exp_ixgwm', 'exp_rdmuw']\n```\n\n### Listing unique attributes\n\nFilter attributes by name and by experiment that they belong to:\n\n```python\nnpt.list_attributes(\n experiments=r\"exp.*\",\n attributes=r\"metrics.*|config/.*\",\n)\n```\n\n```pycon\n['config/batch_size',\n 'config/epochs',\n 'config/last_event_time',\n 'config/learning_rate',\n 'config/optimizer',\n 'config/use_bias',\n 'metrics/accuracy',\n 'metrics/loss',\n 'metrics/val_accuracy',\n 'metrics/val_loss']\n```\n\n### Fetching metadata table\n\nTo fetch experiment metadata from your project, use the `fetch_experiments_table()` function.\n\n- To filter experiments to return, use the `experiments` parameter.\n- To specify attributes to include as columns, use the `attributes` parameter.\n\nFor both arguments, you can specify a simple string to match experiment or attribute names against, or you can use the Filter classes to [construct more complex filters](#constructing-filters).\n\n> Fetching metrics this way returns an aggregation value for each attribute. The default aggregation is the last logged value.\n>\n> To fetch actual metric values at each step, see [`fetch_experiment_metrics()`](#fetching-metric-values).\n\n```python\nnpt.fetch_experiments_table(\n experiments=r\"exp.*\",\n attributes=r\".*metric.*/val_.+\",\n)\n```\n\n```pycon\n metrics/val_accuracy metrics/val_loss\n last last\nexperiment\nexp_ergwq 0.278149 0.336344\nexp_qgguv 0.160260 0.790268\nexp_cnuwh 0.702490 0.366390\nexp_kokxd 0.301545 0.917683\nexp_gyvpp 0.999489 0.069839\n```\n\n### Fetching metric values\n\nTo fetch individual values from one or more float series attributes, use the `fetch_experiment_metrics()` function:\n\n```python\nnpt.fetch_experiment_metrics(\n experiments=r\"exp.*\",\n attributes=r\"metrics/.*\",\n)\n```\n\n```pycon\n experiment step metrics/accuracy metrics/loss metrics/val_accuracy metrics/val_loss\n0 exp_dczjz 0 0.819754 0.588655 0.432187 0.823375\n1 exp_dczjz 1 0.347907 0.297161 0.649685 0.971732\n2 exp_dczjz 2 0.858863 0.988583 0.760142 0.154741\n3 exp_dczjz 3 0.217097 None 0.719508 0.504652\n4 exp_dczjz 4 0.089981 0.463146 0.180321 0.503800\n5 exp_hgctc 0 0.318828 0.386347 0.012390 0.171790\n6 exp_hgctc 1 0.035026 0.087053 0.392041 0.768675\n7 exp_hgctc 2 0.004711 0.061848 None 0.847072\n8 exp_hgctc 3 0.359770 0.130022 0.479945 0.323537\n9 exp_hgctc 4 0.007815 0.746344 0.102646 0.055511\n```\n\n### Working with multiple projects\n\nTo work with multiple projects simultaneously, you can use contexts. This way, you can set the scope for individual fetching calls or globally for your session.\n\n- To set a new project or API token globally, use `set_project()` or `set_api_token()`:\n\n ```python\n npt.set_project('some-workspace/another-project')\n ```\n\n- To create a context object that you can pass to the `context` argument of a fetching method:\n\n ```python\n another_project_context = npt.get_context().with_project('some-workspace/another-project')\n npt.list_experiments(r\"exp_.*\", context=another_project_context)\n ```\n\nExample flow:\n\n1. `NEPTUNE_PROJECT` environment variable is read on module initialization:\n\n ```python\n import neptune_fetcher.alpha as npt\n ```\n\n1. Work on the default project inferred from the environment variables:\n\n ```python\n npt.list_experiments(r\"exp_.*\")\n ```\n\n ```pycon\n ['exp_dhxxz', 'exp_saazg', 'exp_sxlrq', 'exp_vlqfe', 'exp_fpogj']\n ```\n\n1. Work on another project without changing the global context:\n\n ```python\n another_project_ctx = npt.get_context().with_project('some-workspace/another-project')\n npt.list_experiments(r\"exp_.*\", context=another_project_ctx)\n ```\n\n ```pycon\n ['exp_oecez', 'exp_ytbda', 'exp_khfym']\n ```\n\n1. Change the project globally:\n\n ```python\n npt.set_project('some-workspace/another-project')\n ```\n\n1. Do some more work on another project:\n\n ```python\n npt.list_experiments(r\"exp_.*\")\n ```\n\n ```pycon\n ['exp_oecez', 'exp_ytbda', 'exp_khfym']\n ```\n\n### Constructing filters\n\n#### Filtering experiments\n\nUse the Filter class to specify criteria when fetching experiments or runs.\n\n> Examples of filters:\n>\n> - Name or attribute must match regular expression.\n> - Attribute value must pass a condition, like \"greater than 0.9\".\n\nYou can negate a filter or join multiple filters with logical operators.\n\nMethods available for attribute values:\n- `eq()`: Equals\n- `ne()`: Doesn't equal\n- `gt()`: Greater than\n- `ge()`: Greater than or equal to\n- `lt()`: Less than\n- `le()`: Less than or equal to\n- `matches_all()`: Matches regex or all in list of regexes\n- `matches_none()`: Doesn't match regex or any of list of regexes\n- `contains_all()`: Tagset contains all tags, or string contains substrings\n- `contains_none()`: Tagset doesn't contain any of the tags, or string doesn't contain the substrings\n- `exists()`: Attribute exists\n\n##### Examples\n\nImport the needed classes:\n\n```python\nimport neptune_fetcher.alpha as npt\nfrom npt.filters import Attribute, Filter\n```\n\nConstructing filters:\n\nA) Regex that the experiment or run name must match:\n\n```python\nname_filter = Filter.matches_all(\"sys/name\", r\"kittiwake$\")\n```\n\nB) Don't allow the tags \"test\" or \"val\":\n\n```python\nno_test_or_val = Filter.contains_none(\"sys/tags\", [\"test\", \"val\"])\n```\n\nC) Set a condition for the last logged value of a metric:\n\n```python\nloss_filter = Filter.lt(\"validation/loss\", 0.1)\n```\n\nFor more control over the selected metric, use the `Attribute()` helper class.\n\nD) Negate a filter: Call `negate()` or prepend with `~`:\n\n```python\nnot_loss_filter = ~loss_filter\n# equivalent to\nnot_loss_filter = Filter.negate(loss_filter)\n```\n\nE) Combining filters:\n\n- To join with AND: Use `&` or pass the filters to the `all()` method.\n- To join with OR: Use `|` or pass the filters to the `any()` method.\n\n```python\nname_and_loss_filter = name_filter & loss_filter\n# equivalent to\nname_and_loss_filter = Filter.all(name_filter, loss_filter)\n```\n\nTo use a filter in a query, pass it as the argument to a fetching or listing method:\n\n```python\nnpt.fetch_experiments_table(experiments=name_and_loss_filter)\n```\n\n#### Filtering attributes\n\nWhen fetching metadata with the `fetch_experiments_table()` function, in the returned table, each column represents an attribute.\n\nTo select specific metrics or other attributes based on various criteria, use the `AttributeFilter` class.\n\n##### Examples\n\nSelect attribute by exact name:\n\n```python\nAttributeFilter(name_eq=\"config/optimizer\")\n```\n\nSelect metrics that don't match regexes `^test` or `loss$` and pick the \"average\" and \"variance\" aggregations:\n\n```python\nAttributeFilter(\n type_in=[\"float_series\"],\n name_matches_none=[r\"^test\", r\"loss$\"],\n aggregations=[\"average\", \"variance\"],\n)\n```\n\nIn this case, the returned table includes \"average\" and \"variance\" columns for each metric:\n\n```pycon\nattribute train/accuracy validation/accuracy\naggregation average variance average variance\nexperiment\nexp-1738662528 0.000000 0.000273 0.0 0.000269\nexp-1738325381 0.000000 0.594614 0.0 0.595119\n...\n```\n\n> For the types reference, see: https://docs-beta.neptune.ai/attribute_types\n\nCombine multiple filters with the pipe character:\n\n```python\nfilter_1 = AttributeFilter(...)\nfilter_2 = AttributeFilter(...)\nfilter_3 = AttributeFilter(...)\nalternatives = filter_1 | filter_2 | filter_3\n```\n\nTo use a filter, pass it to the `attributes` argument of the `fetch_experiments_table()` function:\n\n```python\nnpt.fetch_experiments_table(\n experiments=...,\n attributes=AttributeFilter(...),\n)\n```\n\n#### `Attribute` helper class\n\nUsed for specifying a single attribute and picking a metric aggregation function.\n\nWhen fetching experiments or runs, use this class to filter and sort the returned entries.\n\n##### Examples\n\nSelect a metric and pick variance as the aggregation:\n\n```python\nimport neptune_fetcher.alpha as npt\nfrom npt.filters import Attribute, Filter\n\n\nval_loss_variance = Attribute(\n name=\"val/loss\",\n aggregation=\"variance\",\n)\n```\n\nConstruct a filter around the attribute, then pass it to a fetching or listing method:\n\n```python\ntiny_val_loss_variance = Filter.lt(val_loss_variance, 0.01)\nnpt.fetch_experiments_table(experiments=tiny_val_loss_variance)\n```\n\n### Working with runs\n\nExperiments consist of runs. By default, the Fetcher API returns metadata only from experiment head runs, not all individual runs.\n\nTo work with runs, you can use the corresponding run methods:\n\n```python\nfrom neptune_fetcher.alpha.runs import (\n fetch_run_metrics,\n fetch_runs_table,\n list_run_attributes,\n list_runs,\n)\n```\n\nNote the difference in specifying runs versus experiments:\n\n- Experiments are characterized by name (`sys/name`). This is the string passed to the `name` argument at creation.\n- Runs are characterized by ID (`sys/custom_run_id`). This is the string passed to the `run_id` argument at creation.\n\n---\n\n## Usage: Fetcher `0.x`\n\n> [!NOTE]\n> We're redesigning the Fetcher API.\n>\n> To try the new version, see [Usage: Alpha version](#usage-alpha-version).\n\nIn your Python code, create a [`ReadOnlyProject`](#readonlyproject) instance:\n\n```python\nfrom neptune_fetcher import ReadOnlyProject\n\nmy_project = ReadOnlyProject()\n```\n\nNow you have a Neptune project to operate on.\n\n> If you don't set the Neptune environment variables, you can pass your credentials through arguments when creating a project or run object.\n\nTo fetch experiments in bulk, call a fetching method on the project:\n\n```python\nexperiments_df = my_project.fetch_experiments_df(\n names_regex=\"tree/.*\",\n columns=[\"sys/custom_run_id\", \"sys/modification_time\"],\n query='(last(`accuracy`:floatSeries) > 0.88) AND (`learning_rate`:float < 0.01)',\n)\n```\n\nTo fetch metadata from an individual experiment or run, create and use a [`ReadOnlyRun`](#readonlyrun) object:\n\n```python\nfrom neptune_fetcher import ReadOnlyRun\n\nrun = ReadOnlyRun(\n read_only_project=my_project,\n experiment_name=\"seagull-flying-skills\",\n)\n\n# Fetch value\nprint(run[\"parameters/optimizer\"].fetch())\n\n# Fecth last value of metric\nprint(run[\"metrics/loss\"].fetch_last())\n\n# Fetch all metric values, with optional pre-fetching to speed up subsequent access to the field\nrun.prefetch_series_values([\"metrics/accuracy\"])\nprint(run[\"metrics/accuracy\"].fetch_values())\n```\n\nFor details, see the Neptune documentation:\n\n- [Fetch runs or experiments](https://docs-beta.neptune.ai/fetch_runs)\n- [Fetch metadata from a run or experiment](https://docs-beta.neptune.ai/fetch_run_data)\n- [Neptune Query Language (NQL)](https://docs-beta.neptune.ai/nql)\n\n\n### Examples\n\n#### Listing runs of a project\n\n```python\nfrom neptune_fetcher import ReadOnlyProject\n\nproject = ReadOnlyProject(\"workspace/project\")\n\nfor run in project.list_runs():\n print(run) # dicts with identifiers\n```\n\n#### Listing experiments of a project\n\n```python\nfrom neptune_fetcher import ReadOnlyProject\n\nproject = ReadOnlyProject(\"workspace/project\")\n\nfor experiment in project.list_experiments():\n print(experiment) # dicts with identifiers\n```\n\n#### Fetching runs data frame with specific columns\n\n```python\nfrom neptune_fetcher import ReadOnlyProject\n\nproject = ReadOnlyProject(\"workspace/project\")\n\nruns_df = project.fetch_runs_df(\n columns=[\"sys/custom_run_id\", \"sys/modification_time\"],\n columns_regex=\"tree/.*\", # added to columns specified with the \"columns\" parameter\n)\n```\n\n#### Fetching data from specified runs\n\n```python\nfrom neptune_fetcher import ReadOnlyProject\n\nproject = ReadOnlyProject(\"workspace/project\")\n\nfor run in project.fetch_read_only_runs(with_ids=[\"RUN-1\", \"RUN-2\"]):\n run.prefetch([\"parameters/optimizer\", \"parameters/init_lr\"])\n\n print(run[\"parameters/optimizer\"].fetch())\n print(run[\"parameters/init_lr\"].fetch())\n```\n\n#### Fetching data from a single run\n\n```python\nfrom neptune_fetcher import ReadOnlyProject, ReadOnlyRun\n\nproject = ReadOnlyProject(\"workspace/project\")\nrun = ReadOnlyRun(project, with_id=\"TES-1\")\n\nrun.prefetch([\"parameters/optimizer\", \"parameters/init_lr\"])\nrun.prefetch_series_values([\"metrics/loss\", \"metrics/accuracy\"], use_threads=True)\n\nprint(run[\"parameters/optimizer\"].fetch())\nprint(run[\"parameters/init_lr\"].fetch())\nprint(run[\"metrics/loss\"].fetch_values())\nprint(run[\"metrics/accuracy\"].fetch_values())\n```\n\n### API reference\n\n#### Supported regular expressions\n\nNeptune uses the [RE2](https://github.com/google/re2) regular expression library. For supported regex features and limitations, see the official [syntax guide](https://github.com/google/re2/wiki/syntax).\n\n\n#### `ReadOnlyProject`\n\nRepresentation of a Neptune project in a limited read-only mode.\n\n##### Initialization\n\nInitialize with the ReadOnlyProject class constructor:\n\n```python\nproject = ReadOnlyProject(\"workspace/project\", api_token=\"...\")\n```\n\n> [!TIP]\n> Find your API token in your user menu, in the bottom-left corner of the Neptune app.\n\n__Parameters:__\n\n| Name | Type | Default | Description |\n|-------------|------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `project` | `str`, optional | `None` | Name of a project in the form `workspace-name/project-name`. If `None`, the value of the `NEPTUNE_PROJECT` environment variable is used. |\n| `api_token` | `str`, optional | `None` | Your Neptune API token (or a service account's API token). If `None`, the value of the `NEPTUNE_API_TOKEN` environment variable is used. To keep your token secure, avoid placing it in source code. Instead, save it as an environment variable. |\n| `proxies` | `dict`, optional | `None` | Dictionary of proxy settings, if needed. This argument is passed to HTTP calls made via the Requests library. For details on proxies, see the [Requests documentation](https://requests.readthedocs.io/). |\n\n---\n\n##### `list_runs()`\n\nLists all runs of a project.\n\nEach run is identified by Neptune ID (`sys/id`), custom ID (`sys/custom_run_id`) and, if set, name (`sys/name`).\n\n__Returns:__ `Iterator` of dictionaries with Neptune run identifiers, custom identifiers and names.\n\n__Example:__\n\n```python\nproject = ReadOnlyProject()\n\nfor run in project.list_runs():\n print(run)\n```\n\n---\n\n##### `list_experiments()`\n\nLists all experiments of a project.\n\nEach experiment is identified by:\n\n- Neptune ID: `sys/id`\n- (If set) Custom ID: `sys/custom_run_id`\n- Name: `sys/name`\n\n__Example:__\n\n```python\nfor experiment in project.list_experiments():\n print(experiment)\n```\n\n__Returns:__ `Iterator` of dictionaries with Neptune experiment identifiers, custom identifiers and names.\n\n---\n\n##### `fetch_runs()`\n\nFetches a table containing Neptune IDs, custom run IDs and names of runs in the project.\n\n__Returns:__ `pandas.DataFrame` `pandas.DataFrame` with three columns (`sys/id`, `sys/name` and `sys/custom_run_id`)\nand one row for each run.\n\n__Example:__\n\n```python\nproject = ReadOnlyProject()\ndf = project.fetch_runs()\n```\n\n---\n\n##### `fetch_experiments()`\n\nFetches a table containing Neptune IDs, custom IDs and names of experiments in the project.\n\n__Example__:\n\n```python\ndf = project.fetch_experiments()\n```\n\n__Returns__:\n`pandas.DataFrame` with three columns (`sys/id`, `sys/custom_run_id`, `sys/name`) and one row for each experiment.\n\n---\n\n##### `fetch_runs_df()`\n\nFetches the runs' metadata and returns them as a pandas DataFrame.\n\n__Parameters:__\n\n| Name | Type | Default | Description |\n|-------------------|-----------------------|---------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `columns` | `List[str]`, optional | `None` | Names of columns to include in the table, as a list of field names. The sorting column, custom run identifier (`sys/custom_run_id`), and experiment name (`sys/name`) are always included. `None` results in returning only the default columns.\n| `columns_regex` | `str`, optional | `None` | A regex pattern to filter columns by name. Use this parameter to include columns in addition to the ones specified by the `columns` parameter.\n| `names_regex` | `str`, optional | `None` | A regex pattern to filter the runs by name. |\n| `custom_id_regex` | `str`, optional | `None` | A regex pattern to filter the runs by custom ID. |\n| `with_ids` | `List[str]`, optional | `None` | List of multiple Neptune IDs. Example: `[\"NLU-1\", \"NLU-2\"]`. Matching any element of the list is sufficient to pass the criterion. |\n| `custom_ids` | `List[str]`, optional | `None` | List of multiple custom IDs. Example: `[\"nostalgic_shockley\", \"high_albattani\"]`. Matching any element of the list is sufficient to pass the criterion. |\n| `states` | `List[str]`, optional | `None` | List of states. Possible values: `\"inactive\"`, `\"active\"`. \"Active\" means that at least one process is connected to the run. Matching any element of the list is sufficient to pass the criterion. |\n| `owners` | `List[str]`, optional | `None` | List of multiple owners. Example: `[\"frederic\", \"josh\"]`. The owner is the user who created the run. Matching any element of the list is sufficient to pass the criterion. |\n| `tags` | `List[str]`, optional | `None` | A list of tags. Example: `\"lightGBM\"` or `[\"pytorch\", \"cycleLR\"]`. **Note:** Only runs that have all specified tags will pass this criterion. |\n| `trashed` | `bool`, optional | `False` | Whether to retrieve trashed runs. If `True`, only trashed runs are retrieved. If `False`, only non-trashed runs are retrieved. If `None` or left empty, all run objects are retrieved, including trashed ones. |\n| `limit` | `int`, optional | `None` | Maximum number of runs to fetch. If `None`, all runs are fetched. |\n| `sort_by` | `str`, optional | `sys/creation_time` | Name of the field to sort the results by. The field must represent a simple type (string, float, integer). |\n| `ascending` | `bool`, optional | `False` | Whether to sort the entries in ascending order of the sorting column values. |\n| `progress_bar` | `bool` | `True` | Set to `False `to disable the download progress bar. |\n| `query` | `str`, optional | `None` | NQL query string. Example: `\"(accuracy: float > 0.88) AND (loss: float < 0.2)\"`. The query is applied on top of other criteria like, `custom_ids`, `tags` etc, using the logical AND operator. See examples below. For syntax, see [Neptune Query Language](https://docs.neptune.ai/usage/nql/) in the Neptune docs. |\n\n__Returns:__ `pandas.DataFrame`: A pandas DataFrame containing metadata of the fetched runs.\n\n> [!IMPORTANT]\n> The following fields are always included:\n>\n> - `sys/custom_run_id`: the custom run identifier.\n> - The field to sort by. That is, the field name passed to the `sort_by` argument.\n>\n> The maximum number of runs that can be returned is 5000.\n\n\n__Examples:__\n\nFetch all runs, with specific columns:\n\n```python\nproject = ReadOnlyProject()\n\nruns_df = project.fetch_runs_df(\n columns=[\"sys/modification_time\", \"training/lr\"]\n)\n```\n\nFetch all runs, with specific columns and extra columns that match a regex pattern:\n\n```python\nruns_df = project.fetch_runs_df(\n columns=[\"sys/modification_time\"],\n columns_regex=\"tree/.*\",\n)\n```\n\nFetch runs by specific ID:\n\n```python\nspecific_runs_df = my_project.fetch_runs_df(custom_ids=[\"nostalgic_shockley\", \"high_albattani\"])\n```\n\nFetch runs by names that match a regex pattern:\n\n```python\nspecific_runs_df = my_project.fetch_runs_df(\n names_regex=\"tree_3[2-4]+\"\n)\n```\n\nFetch runs with a complex query using NQL.\n\n```python\nruns_df = my_project.fetch_runs_df(\n query='(last(`accuracy`:floatSeries) > 0.88) AND (`learning_rate`:float < 0.01)'\n)\n```\n\n---\n\n##### `fetch_experiments_df()`\n\nFetches the experiments' metadata and returns them as a pandas DataFrame.\n\n__Parameters__:\n\n| Name | Type | Default | Description |\n|-----------------------|-----------------------|---------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `columns` | `List[str]`, optional | `None` | Names of columns to include in the table, as a list of field names. The sorting column, custom run identifier (`sys/custom_run_id`), and experiment name (`sys/name`) are always included. `None` results in returning only the default columns.\n| `columns_regex` | `str`, optional | `None` | A regex pattern to filter columns by name. Use this parameter to include columns in addition to the ones specified by the `columns` parameter.\n| `names_regex` | `str`, optional | `None` | A regex pattern to filter the experiments by name. |\n| `names_regex` | `str`, optional | `None` | A regex pattern or a list of regex patterns to filter the experiments by name. Multiple patterns will be connected by AND logic. |\n| `names_exclude_regex` | `str`, optional | `None` | A regex pattern or a list of regex patterns to exclude experiments by name. Multiple patterns will be connected by AND logic. |\n| `custom_id_regex` | `str`, optional | `None` | A regex pattern to filter the experiments by custom ID. |\n| `with_ids` | `List[str]`, optional | `None` | List of multiple Neptune IDs. Example: `[\"NLU-1\", \"NLU-2\"]`. Matching any element of the list is sufficient to pass the criterion. |\n| `custom_ids` | `List[str]`, optional | `None` | List of multiple custom IDs. Example: `[\"nostalgic_shockley\", \"high_albattani\"]`. Matching any element of the list is sufficient to pass the criterion. |\n| `states` | `List[str]`, optional | `None` | List of states. Possible values: `\"inactive\"`, `\"active\"`. \"Active\" means that at least one process is connected to the experiment. Matching any element of the list is sufficient to pass the criterion. |\n| `owners` | `List[str]`, optional | `None` | List of multiple owners. Example: `[\"frederic\", \"josh\"]`. The owner is the user who created the experiement. Matching any element of the list is sufficient to pass the criterion. |\n| `tags` | `List[str]`, optional | `None` | A list of tags. Example: `\"lightGBM\"` or `[\"pytorch\", \"cycleLR\"]`. **Note:** Only experiments that have all specified tags will pass this criterion. |\n| `trashed` | `bool`, optional | `False` | Whether to retrieve trashed experiments. If `True`, only trashed experiments are retrieved. If `False`, only non-trashed experiments are retrieved. If `None` or left empty, all experiment objects are retrieved, including trashed ones. |\n| `limit` | `int`, optional | `None` | Maximum number of experiments to fetch. If `None`, all experiments are fetched. |\n| `sort_by` | `str`, optional | `sys/creation_time` | Name of the field to sort the results by. The field must represent a simple type (string, float, integer). |\n| `ascending` | `bool`, optional | `False` | Whether to sort the entries in ascending order of the sorting column values. |\n| `progress_bar` | `bool` | `True` | Set to `False `to disable the download progress bar. |\n| `query` | `str`, optional | `None` | NQL query string. Example: `\"(accuracy: float > 0.88) AND (loss: float < 0.2)\"`. The query is applied on top of other criteria like, `custom_ids`, `tags` etc, using the logical AND operator. See examples below. For syntax, see [Neptune Query Language](https://docs.neptune.ai/usage/nql/) in the Neptune docs. |\n\n__Returns:__ `pandas.DataFrame`: A pandas DataFrame containing metadata of the fetched experiments.\n\n> [!IMPORTANT]\n> The following fields are always included:\n>\n> - `sys/custom_run_id`: the custom run identifier.\n> - `sys/name`: the experiment name.\n> - The field to sort by. That is, the field name passed to the `sort_by` argument.\n>\n> The maximum number of runs that can be returned is 5000.\n\n__Examples:__\n\nFetch all experiments with specific columns:\n\n```python\nexperiments_df = project.fetch_experiments_df(\n columns=[\"sys/custom_run_id\", \"sys/modification_time\", \"training/lr\"]\n)\n```\n\nFetch all experiments with specific columns and extra columns that match a regex pattern:\n\n```python\nexperiments_df = project.fetch_experiments_df(\n columns=[\"sys/custom_run_id\", \"sys/modification_time\"],\n columns_regex=\"tree/.*\",\n)\n```\n\nFetch experiments by specific IDs:\n\n```python\nspecific_experiments_df = my_project.fetch_experiments_df(\n custom_ids=[\"nostalgic_shockley\", \"high_albattani\"]\n)\n```\n\nUse the Neptune Query Language to fetch experiments with a complex query. Note that for regular strings, the `\\` character needs to be escaped:\n\n```python\nexperiments_df = my_project.fetch_experiments_df(\n query='(`learning_rate`:float < 0.01) AND (`sys/name`:string MATCHES \"experiment-\\\\\\\\d+\")'\n)\n```\n\nAs a less cluttered alternative, pass a raw Python string to the `query` argument:\n\n```python\nexperiments_df = my_project.fetch_experiments_df(\n query=r'(`learning_rate`:float < 0.01) AND (`sys/name`:string MATCHES \"experiment-\\\\d+\")'\n)\n```\n\n---\n\n##### `fetch_read_only_runs()`\n\nList runs of the project in the form of ReadOnlyRun.\n\n__Parameters:__\n\n| Name | Type | Default | Description |\n|--------------|-----------------------|---------|-----------------------------------|\n| `with_ids` | `Optional[List[str]]` | `None` | List of Neptune run IDs to fetch. |\n| `custom_ids` | `Optional[List[str]]` | `None` | List of custom run IDs to fetch. |\n\n__Returns:__ Iterator of ReadOnlyRun objects.\n\n__Example:__\n\n```python\nproject = ReadOnlyProject()\n\nfor run in project.fetch_read_only_runs(custom_ids=[\"nostalgic_shockley\", \"high_albattani\"]):\n ...\n```\n\n---\n\n##### `fetch_read_only_experiments()`\n\nLists experiments of the project in the form of ReadOnlyRun.\n\n__Parameters:__\n\n| Name | Type | Default | Description |\n|---------|-----------------------|---------|------------------------------------|\n| `names` | `Optional[List[str]]` | `None` | List of experiment names to fetch. |\n\n__Returns:__ Iterator of ReadOnlyRun objects.\n\n__Example:__\n\n```python\nproject = ReadOnlyProject()\n\nfor run in project.fetch_read_only_experiments(names=[\"yolo-v2\", \"yolo-v3\"]):\n ...\n```\n\n---\n\n#### `ReadOnlyRun`\n\nRepresentation of a Neptune run in a limited read-only mode.\n\n##### Initialization\n\nCan be created\n\n- with the class constructor:\n\n ```python\n project = ReadOnlyProject()\n run = ReadOnlyRun(project, with_id=\"TES-1\")\n ```\n\n- or as a result of the [`fetch_read_only_runs()`](#fetch_read_only_runs) method of the `ReadOnlyProject` class:\n\n ```python\n for run in project.fetch_read_only_runs(\n custom_ids=[\"nostalgic_shockley\", \"high_albattani\"]):\n ...\n ```\n\n__Parameters:__\n\n| Name | Type | Default | Description |\n|------------------------------------|-------------------|---------|------------------------------------------------------------------------------------------------------------------------------------|\n| `read_only_project` | `ReadOnlyProject` | - | Project from which the run is fetched. |\n| `with_id` | `Optional[str]` | `None` | ID of the Neptune run to fetch. Example: `RUN-1`. Exclusive with the `custom_id` and `experiment_name` parameters. |\n| `custom_id` | `Optional[str]` | `None` | Custom ID of the Neptune run to fetch. Example: `high_albattani`. Exclusive with the `with_id` and `experiment_name` parameters. |\n| `experiment_name` | `Optional[str]` | `None` | Name of the Neptune experiment to fetch. Example: `high_albattani`. Exclusive with the `with_id` and `custom_id` parameters. |\n| `eager_load_fields` | `Optional[bool]` | `True` | Whether to eagerly load the run fields definitions. If `False`, individual fields are loaded only when accessed. Default is `True`. |\n\n__Example:__\n\n```python\nfrom neptune_fetcher import ReadOnlyProject, ReadOnlyRun\n\nproject = ReadOnlyProject(\"workspace-name/project-name\", api_token=\"...\")\nrun = ReadOnlyRun(project, custom_id=\"high_albattani\")\n```\n\n---\n\n##### `.field_names`\n\nList of run field names.\n\nA _field_ is the location where a piece of metadata is stored in the run.\n\n__Returns:__ Iterator of run fields as strings.\n\n__Example:__\n\n```python\nfor run in project.fetch_read_only_runs(custom_ids=[\"nostalgic_shockley\", ...]):\n print(list(run.field_names))\n```\n\n---\n\n##### Field lookup: `run[field_name]`\n\nUsed to access a specific field of a run. See [Available types](#available-types).\n\n__Returns:__ An internal object used to operate on a specific field.\n\n__Example:__\n\n```python\nrun = ReadOnlyRun(...)\ncustom_id = run[\"sys/custom_run_id\"].fetch()\n```\n\n---\n\n##### `prefetch()`\n\nPre-fetches a batch of fields to the internal cache.\n\nImproves the performance of access to consecutive field values.\n\nSupported Neptune field types:\n\n- [`Boolean`](#boolean)\n- [`Datetime`](#datetime)\n- [`Float`](#float)\n- [`FloatSeries`](#floatseries)\n- [`Integer`](#integer)\n- [`ObjectState`](#objectstate)\n- [`String`](#string)\n- [`StringSet`](#stringset)\n\n__Parameters:__\n\n| Name | Type | Default | Description |\n|---------|-------------|---------|--------------------------------------------|\n| `paths` | `List[str]` | - | List of field paths to fetch to the cache. |\n\n__Example:__\n\n```python\nrun = ReadOnlyRun(...)\nrun.prefetch([\"parameters/optimizer\", \"parameter/init_lr\"])\n# No more calls to the API\nprint(run[\"parameters/optimizer\"].fetch())\nprint(run[\"parameter/init_lr\"].fetch())\n```\n\n#### `prefetch_series_values()`\n\nPrefetches a batch of series to the internal cache. This method skips the non-existing attributes.\n\nImproves the performance of access to consecutive field values. Works only for series ([`FloatSeries`](#floatseries)).\n\nTo speed up the fetching process, this method can use multithreading.\nTo enable it, set the `use_threads` parameter to `True`.\n\nBy default, the maximum number of workers is 10. You can change this number by setting the `NEPTUNE_FETCHER_MAX_WORKERS`\nenvironment variable.\n\n__Parameters__:\n\n| Name | Type | Default | Description |\n|---------------------|-----------------------|--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `paths` | `List[str]`, required | `None` | List of paths to prefetch to the internal cache. |\n| `use_threads` | `bool`, optional | `False` | Whether to use threads to fetch the data. |\n| `progress_bar` | `bool` | `True` | Set to False to disable the download progress bar. |\n| `include_inherited` | `bool`, optional | `True` | If True (default), values inherited from ancestor runs are included. To only fetch values from the current run, set to False. |\n| `step_range` | `tuple[float, float]` | (None, None) | Limits the range of steps to fetch. This must be a 2-tuple: <br> - `left`: The left boundary of the range (inclusive). If `None`, the range extends indefinitely on the left.<br>- `right`: The right boundary of the range (inclusive). If `None`, the range extends indefinitely on the right. |\n\n__Example__:\n\n```python\nrun.prefetch_series_values([\"metrics/loss\", \"metrics/accuracy\"])\n# No more calls to the API\nprint(run[\"metrics/loss\"].fetch_values())\nprint(run[\"metrics/accuracy\"].fetch_values())\n```\n\n### Available types\n\nThis section lists the available field types and data retrieval operations.\n\n---\n\n#### `Boolean`\n\n##### `fetch()`\n\nRetrieves a `bool` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.\n\n__Example:__\n\n```python\nstatus = run[\"sys/failed\"].fetch()\n```\n\n---\n\n#### `Datetime`\n\n##### `fetch()`\n\nRetrieves a `datetime.datetime` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.\n\n__Example:__\n\n```python\ncreated_at = run[\"sys/creation_time\"].fetch()\n```\n\n---\n\n#### `Float`\n\n##### `fetch()`\n\nRetrieves a `float` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.\n\n__Example:__\n\n```python\nf1 = run[\"scores/f1\"].fetch()\n```\n\n---\n\n#### `FloatSeries`\n\n##### `fetch()` or `fetch_last()`\n\nRetrieves the last value of a series, either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.\n\n__Returns:__ `Optional[float]`\n\n__Example:__\n\n```python\nloss = run[\"loss\"].fetch_last()\n```\n\n##### `fetch_values()`\n\nRetrieves all series values either from the internal cache (see [`prefetch_series_values()`](#prefetch_series_values))\nor from the API.\n\n__Parameters:__\n\n| Name | Type | Default | Description |\n|---------------------|-----------------------|--------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `include_timestamp` | `bool` | `True` | Whether the fetched data should include the timestamp field. |\n| `include_inherited` | `bool` | `True` | If True (default), values inherited from ancestor runs are included. To only fetch values from the current run, set to False. |\n| `progress_bar` | `bool` | `True` | Set to False to disable the download progress bar. |\n| `step_range` | `tuple[float, float]` | (None, None) | - left: left boundary of the range (inclusive). If None, it\\'s open on the left. <br> - right: right boundary of the range (inclusive). If None, it\\'s open on the right. |\n\n__Returns:__ `pandas.DataFrame`\n\n__Example:__\n\n```python\nvalues = run[\"loss\"].fetch_values()\n```\n\n---\n\n#### `Integer`\n\n##### `fetch()`\n\nRetrieves an `int` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.\n\n__Example:__\n\n```python\nbatch_size = run[\"batch_size\"].fetch()\n```\n\n---\n\n#### `ObjectState`\n\n##### `fetch()`\n\nRetrieves the state of a run either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.\n\n__Returns:__ `str`\n\n> [!NOTE]\n> The state can be **active** or **inactive**. It refers to whether new data was recently logged to the run.\n> To learn more about this field, see [System namespace: State](https://docs.neptune.ai/api/sys/#state) in the Neptune\n> docs.\n\n__Example:__\n\n```python\nstate = run[\"sys/state\"].fetch()\n```\n\n---\n\n#### `String`\n\n##### `fetch()`\n\nRetrieves a `str` value either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.\n\n__Example:__\n\n```python\ntoken = run[\"token\"].fetch()\n```\n\n---\n\n#### `StringSet`\n\n##### `fetch()`\n\nRetrieves a `dict` of `str` values either from the internal cache (see [`prefetch()`](#prefetch)) or from the API.\n\n__Example:__\n\n```python\ngroups = run[\"sys/group_tags\"].fetch()\n```\n\n---\n\n## License\n\nThis project is licensed under the Apache License Version 2.0. For more details,\nsee [Apache License Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).\n\n",
"bugtrack_url": null,
"license": "Apache-2.0",
"summary": "Neptune Fetcher",
"version": "0.13.0",
"project_urls": {
"Documentation": "https://docs.neptune.ai/",
"Homepage": "https://neptune.ai/",
"Repository": "https://github.com/neptune-ai/neptune-fetcher",
"Tracker": "https://github.com/neptune-ai/neptune-fetcher/issues"
},
"split_keywords": [
"mlops",
" ml experiment tracking",
" ml model registry",
" ml model store",
" ml metadata store"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "1d13ff5744981d7b5dbfc278896ecbc5562644cf4e15bcec0bd172a2d73e34bd",
"md5": "6f5c47594f2ba0b1a8934366b3019b26",
"sha256": "07f907998833dcc25719f00f7bb208e9c3f2202944632aaeb3c60b21f2f4da34"
},
"downloads": -1,
"filename": "neptune_fetcher-0.13.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "6f5c47594f2ba0b1a8934366b3019b26",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": "<4.0,>=3.9",
"size": 88562,
"upload_time": "2025-02-11T15:51:56",
"upload_time_iso_8601": "2025-02-11T15:51:56.866352Z",
"url": "https://files.pythonhosted.org/packages/1d/13/ff5744981d7b5dbfc278896ecbc5562644cf4e15bcec0bd172a2d73e34bd/neptune_fetcher-0.13.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "693c34451a434b6c94b8c40adbbc3996e598b73eb6d8d012c92497a75673c3c8",
"md5": "9dabf0571ee5374b3a5af1b3a6b23b6e",
"sha256": "0c6e216bd19e9ede96a1cb001a96266b3de7059def3c2ae0cb28e2c3b1dca2ee"
},
"downloads": -1,
"filename": "neptune_fetcher-0.13.0.tar.gz",
"has_sig": false,
"md5_digest": "9dabf0571ee5374b3a5af1b3a6b23b6e",
"packagetype": "sdist",
"python_version": "source",
"requires_python": "<4.0,>=3.9",
"size": 64865,
"upload_time": "2025-02-11T15:51:58",
"upload_time_iso_8601": "2025-02-11T15:51:58.119070Z",
"url": "https://files.pythonhosted.org/packages/69/3c/34451a434b6c94b8c40adbbc3996e598b73eb6d8d012c92497a75673c3c8/neptune_fetcher-0.13.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-02-11 15:51:58",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "neptune-ai",
"github_project": "neptune-fetcher",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "neptune-fetcher"
}
JSON
