agentref 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- agentref/__init__.py +24 -0
- agentref/_http.py +252 -0
- agentref/client.py +83 -0
- agentref/errors.py +62 -0
- agentref/resources/__init__.py +24 -0
- agentref/resources/affiliates.py +122 -0
- agentref/resources/billing.py +66 -0
- agentref/resources/conversions.py +124 -0
- agentref/resources/flags.py +132 -0
- agentref/resources/merchant.py +34 -0
- agentref/resources/payouts.py +150 -0
- agentref/resources/programs.py +320 -0
- agentref/types/__init__.py +39 -0
- agentref/types/models.py +210 -0
- agentref-1.0.0.dist-info/METADATA +101 -0
- agentref-1.0.0.dist-info/RECORD +17 -0
- agentref-1.0.0.dist-info/WHEEL +4 -0
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Any, Dict, List, Optional
|
|
4
|
+
|
|
5
|
+
from .._http import AsyncHttpClient, SyncHttpClient
|
|
6
|
+
from ..types.models import Conversion, ConversionStats, PaginatedResponse
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
class ConversionsResource:
|
|
10
|
+
def __init__(self, http: SyncHttpClient) -> None:
|
|
11
|
+
self._http = http
|
|
12
|
+
|
|
13
|
+
def list(
|
|
14
|
+
self,
|
|
15
|
+
*,
|
|
16
|
+
program_id: Optional[str] = None,
|
|
17
|
+
affiliate_id: Optional[str] = None,
|
|
18
|
+
status: Optional[str] = None,
|
|
19
|
+
start_date: Optional[str] = None,
|
|
20
|
+
end_date: Optional[str] = None,
|
|
21
|
+
from_: Optional[str] = None,
|
|
22
|
+
to: Optional[str] = None,
|
|
23
|
+
cursor: Optional[str] = None,
|
|
24
|
+
limit: Optional[int] = None,
|
|
25
|
+
page: Optional[int] = None,
|
|
26
|
+
page_size: Optional[int] = None,
|
|
27
|
+
offset: Optional[int] = None,
|
|
28
|
+
) -> PaginatedResponse[Conversion]:
|
|
29
|
+
envelope = self._http.request(
|
|
30
|
+
"GET",
|
|
31
|
+
"/conversions",
|
|
32
|
+
params={
|
|
33
|
+
"programId": program_id,
|
|
34
|
+
"affiliateId": affiliate_id,
|
|
35
|
+
"status": status,
|
|
36
|
+
"startDate": start_date,
|
|
37
|
+
"endDate": end_date,
|
|
38
|
+
"from": from_,
|
|
39
|
+
"to": to,
|
|
40
|
+
"cursor": cursor,
|
|
41
|
+
"limit": limit,
|
|
42
|
+
"page": page,
|
|
43
|
+
"pageSize": page_size,
|
|
44
|
+
"offset": offset,
|
|
45
|
+
},
|
|
46
|
+
)
|
|
47
|
+
return PaginatedResponse[Conversion].model_validate(envelope)
|
|
48
|
+
|
|
49
|
+
def stats(self, *, program_id: Optional[str] = None, period: Optional[str] = None) -> ConversionStats:
|
|
50
|
+
envelope = self._http.request(
|
|
51
|
+
"GET",
|
|
52
|
+
"/conversions/stats",
|
|
53
|
+
params={"programId": program_id, "period": period},
|
|
54
|
+
)
|
|
55
|
+
data = envelope.get("data", {})
|
|
56
|
+
if not isinstance(data, dict):
|
|
57
|
+
data = {}
|
|
58
|
+
return ConversionStats.model_validate(data)
|
|
59
|
+
|
|
60
|
+
def recent(self, *, limit: Optional[int] = None) -> List[Conversion]:
|
|
61
|
+
envelope = self._http.request("GET", "/conversions/recent", params={"limit": limit})
|
|
62
|
+
raw = envelope.get("data", [])
|
|
63
|
+
if not isinstance(raw, list):
|
|
64
|
+
return []
|
|
65
|
+
return [Conversion.model_validate(item) for item in raw]
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
class AsyncConversionsResource:
|
|
69
|
+
def __init__(self, http: AsyncHttpClient) -> None:
|
|
70
|
+
self._http = http
|
|
71
|
+
|
|
72
|
+
async def list(
|
|
73
|
+
self,
|
|
74
|
+
*,
|
|
75
|
+
program_id: Optional[str] = None,
|
|
76
|
+
affiliate_id: Optional[str] = None,
|
|
77
|
+
status: Optional[str] = None,
|
|
78
|
+
start_date: Optional[str] = None,
|
|
79
|
+
end_date: Optional[str] = None,
|
|
80
|
+
from_: Optional[str] = None,
|
|
81
|
+
to: Optional[str] = None,
|
|
82
|
+
cursor: Optional[str] = None,
|
|
83
|
+
limit: Optional[int] = None,
|
|
84
|
+
page: Optional[int] = None,
|
|
85
|
+
page_size: Optional[int] = None,
|
|
86
|
+
offset: Optional[int] = None,
|
|
87
|
+
) -> PaginatedResponse[Conversion]:
|
|
88
|
+
envelope = await self._http.request(
|
|
89
|
+
"GET",
|
|
90
|
+
"/conversions",
|
|
91
|
+
params={
|
|
92
|
+
"programId": program_id,
|
|
93
|
+
"affiliateId": affiliate_id,
|
|
94
|
+
"status": status,
|
|
95
|
+
"startDate": start_date,
|
|
96
|
+
"endDate": end_date,
|
|
97
|
+
"from": from_,
|
|
98
|
+
"to": to,
|
|
99
|
+
"cursor": cursor,
|
|
100
|
+
"limit": limit,
|
|
101
|
+
"page": page,
|
|
102
|
+
"pageSize": page_size,
|
|
103
|
+
"offset": offset,
|
|
104
|
+
},
|
|
105
|
+
)
|
|
106
|
+
return PaginatedResponse[Conversion].model_validate(envelope)
|
|
107
|
+
|
|
108
|
+
async def stats(self, *, program_id: Optional[str] = None, period: Optional[str] = None) -> ConversionStats:
|
|
109
|
+
envelope = await self._http.request(
|
|
110
|
+
"GET",
|
|
111
|
+
"/conversions/stats",
|
|
112
|
+
params={"programId": program_id, "period": period},
|
|
113
|
+
)
|
|
114
|
+
data = envelope.get("data", {})
|
|
115
|
+
if not isinstance(data, dict):
|
|
116
|
+
data = {}
|
|
117
|
+
return ConversionStats.model_validate(data)
|
|
118
|
+
|
|
119
|
+
async def recent(self, *, limit: Optional[int] = None) -> List[Conversion]:
|
|
120
|
+
envelope = await self._http.request("GET", "/conversions/recent", params={"limit": limit})
|
|
121
|
+
raw = envelope.get("data", [])
|
|
122
|
+
if not isinstance(raw, list):
|
|
123
|
+
return []
|
|
124
|
+
return [Conversion.model_validate(item) for item in raw]
|
|
@@ -0,0 +1,132 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Literal, Optional
|
|
4
|
+
|
|
5
|
+
from .._http import AsyncHttpClient, SyncHttpClient
|
|
6
|
+
from ..types.models import Flag, FlagStats, PaginatedResponse, ResolveFlagParams
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
class FlagsResource:
|
|
10
|
+
def __init__(self, http: SyncHttpClient) -> None:
|
|
11
|
+
self._http = http
|
|
12
|
+
|
|
13
|
+
def list(
|
|
14
|
+
self,
|
|
15
|
+
*,
|
|
16
|
+
status: Optional[str] = None,
|
|
17
|
+
type: Optional[str] = None,
|
|
18
|
+
affiliate_id: Optional[str] = None,
|
|
19
|
+
cursor: Optional[str] = None,
|
|
20
|
+
limit: Optional[int] = None,
|
|
21
|
+
page: Optional[int] = None,
|
|
22
|
+
page_size: Optional[int] = None,
|
|
23
|
+
offset: Optional[int] = None,
|
|
24
|
+
) -> PaginatedResponse[Flag]:
|
|
25
|
+
envelope = self._http.request(
|
|
26
|
+
"GET",
|
|
27
|
+
"/flags",
|
|
28
|
+
params={
|
|
29
|
+
"status": status,
|
|
30
|
+
"type": type,
|
|
31
|
+
"affiliateId": affiliate_id,
|
|
32
|
+
"cursor": cursor,
|
|
33
|
+
"limit": limit,
|
|
34
|
+
"page": page,
|
|
35
|
+
"pageSize": page_size,
|
|
36
|
+
"offset": offset,
|
|
37
|
+
},
|
|
38
|
+
)
|
|
39
|
+
return PaginatedResponse[Flag].model_validate(envelope)
|
|
40
|
+
|
|
41
|
+
def stats(self) -> FlagStats:
|
|
42
|
+
envelope = self._http.request("GET", "/flags/stats")
|
|
43
|
+
data = envelope.get("data", {})
|
|
44
|
+
if not isinstance(data, dict):
|
|
45
|
+
data = {}
|
|
46
|
+
return FlagStats.model_validate(data)
|
|
47
|
+
|
|
48
|
+
def resolve(
|
|
49
|
+
self,
|
|
50
|
+
id: str,
|
|
51
|
+
*,
|
|
52
|
+
status: Literal["reviewed", "dismissed", "confirmed"],
|
|
53
|
+
note: Optional[str] = None,
|
|
54
|
+
block_affiliate: bool = False,
|
|
55
|
+
idempotency_key: Optional[str] = None,
|
|
56
|
+
) -> Flag:
|
|
57
|
+
payload = ResolveFlagParams(
|
|
58
|
+
status=status,
|
|
59
|
+
note=note,
|
|
60
|
+
block_affiliate=block_affiliate,
|
|
61
|
+
).model_dump(by_alias=True, exclude_none=True)
|
|
62
|
+
|
|
63
|
+
envelope = self._http.request(
|
|
64
|
+
"POST",
|
|
65
|
+
f"/flags/{id}/resolve",
|
|
66
|
+
json=payload,
|
|
67
|
+
idempotency_key=idempotency_key,
|
|
68
|
+
)
|
|
69
|
+
return Flag.model_validate(envelope["data"])
|
|
70
|
+
|
|
71
|
+
|
|
72
|
+
class AsyncFlagsResource:
|
|
73
|
+
def __init__(self, http: AsyncHttpClient) -> None:
|
|
74
|
+
self._http = http
|
|
75
|
+
|
|
76
|
+
async def list(
|
|
77
|
+
self,
|
|
78
|
+
*,
|
|
79
|
+
status: Optional[str] = None,
|
|
80
|
+
type: Optional[str] = None,
|
|
81
|
+
affiliate_id: Optional[str] = None,
|
|
82
|
+
cursor: Optional[str] = None,
|
|
83
|
+
limit: Optional[int] = None,
|
|
84
|
+
page: Optional[int] = None,
|
|
85
|
+
page_size: Optional[int] = None,
|
|
86
|
+
offset: Optional[int] = None,
|
|
87
|
+
) -> PaginatedResponse[Flag]:
|
|
88
|
+
envelope = await self._http.request(
|
|
89
|
+
"GET",
|
|
90
|
+
"/flags",
|
|
91
|
+
params={
|
|
92
|
+
"status": status,
|
|
93
|
+
"type": type,
|
|
94
|
+
"affiliateId": affiliate_id,
|
|
95
|
+
"cursor": cursor,
|
|
96
|
+
"limit": limit,
|
|
97
|
+
"page": page,
|
|
98
|
+
"pageSize": page_size,
|
|
99
|
+
"offset": offset,
|
|
100
|
+
},
|
|
101
|
+
)
|
|
102
|
+
return PaginatedResponse[Flag].model_validate(envelope)
|
|
103
|
+
|
|
104
|
+
async def stats(self) -> FlagStats:
|
|
105
|
+
envelope = await self._http.request("GET", "/flags/stats")
|
|
106
|
+
data = envelope.get("data", {})
|
|
107
|
+
if not isinstance(data, dict):
|
|
108
|
+
data = {}
|
|
109
|
+
return FlagStats.model_validate(data)
|
|
110
|
+
|
|
111
|
+
async def resolve(
|
|
112
|
+
self,
|
|
113
|
+
id: str,
|
|
114
|
+
*,
|
|
115
|
+
status: Literal["reviewed", "dismissed", "confirmed"],
|
|
116
|
+
note: Optional[str] = None,
|
|
117
|
+
block_affiliate: bool = False,
|
|
118
|
+
idempotency_key: Optional[str] = None,
|
|
119
|
+
) -> Flag:
|
|
120
|
+
payload = ResolveFlagParams(
|
|
121
|
+
status=status,
|
|
122
|
+
note=note,
|
|
123
|
+
block_affiliate=block_affiliate,
|
|
124
|
+
).model_dump(by_alias=True, exclude_none=True)
|
|
125
|
+
|
|
126
|
+
envelope = await self._http.request(
|
|
127
|
+
"POST",
|
|
128
|
+
f"/flags/{id}/resolve",
|
|
129
|
+
json=payload,
|
|
130
|
+
idempotency_key=idempotency_key,
|
|
131
|
+
)
|
|
132
|
+
return Flag.model_validate(envelope["data"])
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Any, Dict
|
|
4
|
+
|
|
5
|
+
from .._http import AsyncHttpClient, SyncHttpClient
|
|
6
|
+
from ..types.models import Merchant
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
class MerchantResource:
|
|
10
|
+
def __init__(self, http: SyncHttpClient) -> None:
|
|
11
|
+
self._http = http
|
|
12
|
+
|
|
13
|
+
def get(self) -> Merchant:
|
|
14
|
+
envelope = self._http.request("GET", "/merchant")
|
|
15
|
+
return Merchant.model_validate(envelope["data"])
|
|
16
|
+
|
|
17
|
+
def domain_status(self) -> Dict[str, Any]:
|
|
18
|
+
envelope = self._http.request("GET", "/merchant/domain-status")
|
|
19
|
+
data = envelope.get("data", {})
|
|
20
|
+
return data if isinstance(data, dict) else {}
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
class AsyncMerchantResource:
|
|
24
|
+
def __init__(self, http: AsyncHttpClient) -> None:
|
|
25
|
+
self._http = http
|
|
26
|
+
|
|
27
|
+
async def get(self) -> Merchant:
|
|
28
|
+
envelope = await self._http.request("GET", "/merchant")
|
|
29
|
+
return Merchant.model_validate(envelope["data"])
|
|
30
|
+
|
|
31
|
+
async def domain_status(self) -> Dict[str, Any]:
|
|
32
|
+
envelope = await self._http.request("GET", "/merchant/domain-status")
|
|
33
|
+
data = envelope.get("data", {})
|
|
34
|
+
return data if isinstance(data, dict) else {}
|
|
@@ -0,0 +1,150 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import List, Optional
|
|
4
|
+
|
|
5
|
+
from .._http import AsyncHttpClient, SyncHttpClient
|
|
6
|
+
from ..types.models import PaginatedResponse, PendingAffiliate, Payout, PayoutStats
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
class PayoutsResource:
|
|
10
|
+
def __init__(self, http: SyncHttpClient) -> None:
|
|
11
|
+
self._http = http
|
|
12
|
+
|
|
13
|
+
def list(
|
|
14
|
+
self,
|
|
15
|
+
*,
|
|
16
|
+
program_id: Optional[str] = None,
|
|
17
|
+
affiliate_id: Optional[str] = None,
|
|
18
|
+
status: Optional[str] = None,
|
|
19
|
+
start_date: Optional[str] = None,
|
|
20
|
+
end_date: Optional[str] = None,
|
|
21
|
+
from_: Optional[str] = None,
|
|
22
|
+
to: Optional[str] = None,
|
|
23
|
+
cursor: Optional[str] = None,
|
|
24
|
+
limit: Optional[int] = None,
|
|
25
|
+
page: Optional[int] = None,
|
|
26
|
+
page_size: Optional[int] = None,
|
|
27
|
+
offset: Optional[int] = None,
|
|
28
|
+
) -> PaginatedResponse[Payout]:
|
|
29
|
+
envelope = self._http.request(
|
|
30
|
+
"GET",
|
|
31
|
+
"/payouts",
|
|
32
|
+
params={
|
|
33
|
+
"programId": program_id,
|
|
34
|
+
"affiliateId": affiliate_id,
|
|
35
|
+
"status": status,
|
|
36
|
+
"startDate": start_date,
|
|
37
|
+
"endDate": end_date,
|
|
38
|
+
"from": from_,
|
|
39
|
+
"to": to,
|
|
40
|
+
"cursor": cursor,
|
|
41
|
+
"limit": limit,
|
|
42
|
+
"page": page,
|
|
43
|
+
"pageSize": page_size,
|
|
44
|
+
"offset": offset,
|
|
45
|
+
},
|
|
46
|
+
)
|
|
47
|
+
return PaginatedResponse[Payout].model_validate(envelope)
|
|
48
|
+
|
|
49
|
+
def list_pending(
|
|
50
|
+
self,
|
|
51
|
+
*,
|
|
52
|
+
program_id: Optional[str] = None,
|
|
53
|
+
cursor: Optional[str] = None,
|
|
54
|
+
limit: Optional[int] = None,
|
|
55
|
+
page: Optional[int] = None,
|
|
56
|
+
page_size: Optional[int] = None,
|
|
57
|
+
offset: Optional[int] = None,
|
|
58
|
+
) -> PaginatedResponse[PendingAffiliate]:
|
|
59
|
+
envelope = self._http.request(
|
|
60
|
+
"GET",
|
|
61
|
+
"/payouts/pending",
|
|
62
|
+
params={
|
|
63
|
+
"programId": program_id,
|
|
64
|
+
"cursor": cursor,
|
|
65
|
+
"limit": limit,
|
|
66
|
+
"page": page,
|
|
67
|
+
"pageSize": page_size,
|
|
68
|
+
"offset": offset,
|
|
69
|
+
},
|
|
70
|
+
)
|
|
71
|
+
return PaginatedResponse[PendingAffiliate].model_validate(envelope)
|
|
72
|
+
|
|
73
|
+
def stats(self, *, program_id: Optional[str] = None, period: Optional[str] = None) -> PayoutStats:
|
|
74
|
+
envelope = self._http.request("GET", "/payouts/stats", params={"programId": program_id, "period": period})
|
|
75
|
+
data = envelope.get("data", {})
|
|
76
|
+
if not isinstance(data, dict):
|
|
77
|
+
data = {}
|
|
78
|
+
return PayoutStats.model_validate(data)
|
|
79
|
+
|
|
80
|
+
|
|
81
|
+
class AsyncPayoutsResource:
|
|
82
|
+
def __init__(self, http: AsyncHttpClient) -> None:
|
|
83
|
+
self._http = http
|
|
84
|
+
|
|
85
|
+
async def list(
|
|
86
|
+
self,
|
|
87
|
+
*,
|
|
88
|
+
program_id: Optional[str] = None,
|
|
89
|
+
affiliate_id: Optional[str] = None,
|
|
90
|
+
status: Optional[str] = None,
|
|
91
|
+
start_date: Optional[str] = None,
|
|
92
|
+
end_date: Optional[str] = None,
|
|
93
|
+
from_: Optional[str] = None,
|
|
94
|
+
to: Optional[str] = None,
|
|
95
|
+
cursor: Optional[str] = None,
|
|
96
|
+
limit: Optional[int] = None,
|
|
97
|
+
page: Optional[int] = None,
|
|
98
|
+
page_size: Optional[int] = None,
|
|
99
|
+
offset: Optional[int] = None,
|
|
100
|
+
) -> PaginatedResponse[Payout]:
|
|
101
|
+
envelope = await self._http.request(
|
|
102
|
+
"GET",
|
|
103
|
+
"/payouts",
|
|
104
|
+
params={
|
|
105
|
+
"programId": program_id,
|
|
106
|
+
"affiliateId": affiliate_id,
|
|
107
|
+
"status": status,
|
|
108
|
+
"startDate": start_date,
|
|
109
|
+
"endDate": end_date,
|
|
110
|
+
"from": from_,
|
|
111
|
+
"to": to,
|
|
112
|
+
"cursor": cursor,
|
|
113
|
+
"limit": limit,
|
|
114
|
+
"page": page,
|
|
115
|
+
"pageSize": page_size,
|
|
116
|
+
"offset": offset,
|
|
117
|
+
},
|
|
118
|
+
)
|
|
119
|
+
return PaginatedResponse[Payout].model_validate(envelope)
|
|
120
|
+
|
|
121
|
+
async def list_pending(
|
|
122
|
+
self,
|
|
123
|
+
*,
|
|
124
|
+
program_id: Optional[str] = None,
|
|
125
|
+
cursor: Optional[str] = None,
|
|
126
|
+
limit: Optional[int] = None,
|
|
127
|
+
page: Optional[int] = None,
|
|
128
|
+
page_size: Optional[int] = None,
|
|
129
|
+
offset: Optional[int] = None,
|
|
130
|
+
) -> PaginatedResponse[PendingAffiliate]:
|
|
131
|
+
envelope = await self._http.request(
|
|
132
|
+
"GET",
|
|
133
|
+
"/payouts/pending",
|
|
134
|
+
params={
|
|
135
|
+
"programId": program_id,
|
|
136
|
+
"cursor": cursor,
|
|
137
|
+
"limit": limit,
|
|
138
|
+
"page": page,
|
|
139
|
+
"pageSize": page_size,
|
|
140
|
+
"offset": offset,
|
|
141
|
+
},
|
|
142
|
+
)
|
|
143
|
+
return PaginatedResponse[PendingAffiliate].model_validate(envelope)
|
|
144
|
+
|
|
145
|
+
async def stats(self, *, program_id: Optional[str] = None, period: Optional[str] = None) -> PayoutStats:
|
|
146
|
+
envelope = await self._http.request("GET", "/payouts/stats", params={"programId": program_id, "period": period})
|
|
147
|
+
data = envelope.get("data", {})
|
|
148
|
+
if not isinstance(data, dict):
|
|
149
|
+
data = {}
|
|
150
|
+
return PayoutStats.model_validate(data)
|