liboxen 0.48.0

Oxen is a fast, unstructured data version control, to help version large machine learning datasets written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use crate::api;
use crate::core::versions::MinOxenVersion;
use crate::view::RepositoryView;
use crate::view::repository::RepositoryCreationView;
use crate::{error::OxenError, model::Remote};
use http::Uri;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct RemoteRepository {
    pub namespace: String,
    pub name: String,
    pub remote: Remote,
    pub min_version: Option<String>,
    pub is_empty: bool,
}

impl RemoteRepository {
    pub fn from_view(repository: &RepositoryView, remote: &Remote) -> RemoteRepository {
        RemoteRepository {
            namespace: repository.namespace.clone(),
            name: repository.name.clone(),
            remote: remote.clone(),
            min_version: repository.min_version.clone(),
            is_empty: repository.is_empty,
        }
    }

    pub fn from_creation_view(
        repository: &RepositoryCreationView,
        remote: &Remote,
    ) -> RemoteRepository {
        RemoteRepository {
            namespace: repository.namespace.clone(),
            name: repository.name.clone(),
            remote: remote.clone(),
            min_version: repository.min_version.clone(),
            is_empty: true,
        }
    }

    pub fn min_version(&self) -> MinOxenVersion {
        match MinOxenVersion::or_earliest(self.min_version.clone()) {
            Ok(version) => version,
            Err(err) => {
                panic!("Invalid repo version\n{err}")
            }
        }
    }

    /// User friendly url for the remote repository
    /// Ex) http://localhost:3000/namespace/name
    pub fn url(&self) -> &str {
        &self.remote.url
    }

    /// Host of the remote repository
    pub fn host(&self) -> String {
        // parse it from the url
        let uri = self.remote.url.parse::<Uri>().unwrap();
        uri.host().unwrap().to_string()
    }

    /// Scheme of the remote repository
    pub fn scheme(&self) -> String {
        // parse it from the url
        let uri = self.remote.url.parse::<Uri>().unwrap();
        uri.scheme().unwrap().to_string()
    }

    /// Underlying api url for the remote repository
    /// Ex) http://localhost:3000/api/repos/namespace/name
    pub fn api_url(&self) -> Result<String, OxenError> {
        api::endpoint::url_from_repo(self, "")
    }
}