devlio 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.
devlio/__init__.py ADDED
@@ -0,0 +1,54 @@
1
+ """
2
+ Devlio Official Python SDK.
3
+ High-performance developer toolkit for Devlio software licensing and creator marketplace APIs.
4
+ """
5
+
6
+ from .license import DevlioLicense
7
+ from .client import DevlioClient
8
+ from .exceptions import (
9
+ DevlioError,
10
+ AuthenticationError,
11
+ LicenseError,
12
+ LicenseInvalidError,
13
+ LicenseExpiredError,
14
+ ActivationLimitReachedError,
15
+ NetworkError,
16
+ )
17
+
18
+ __version__ = "1.0.0"
19
+ __author__ = "Devlio Team"
20
+
21
+
22
+ class Devlio(DevlioClient):
23
+ """
24
+ Unified entry point for the Devlio SDK.
25
+
26
+ Usage as Client:
27
+ client = Devlio(api_token="your_token")
28
+ profile = client.me()
29
+
30
+ Usage for Licensing:
31
+ lic = Devlio.license("my-project")
32
+ if lic.verify("DEV-XXXX-XXXX"):
33
+ ...
34
+ """
35
+
36
+ @staticmethod
37
+ def license(project_slug: str, **kwargs) -> DevlioLicense:
38
+ """Create a standalone DevlioLicense manager for software protection."""
39
+ return DevlioLicense(project_slug, **kwargs)
40
+
41
+
42
+ __all__ = [
43
+ "Devlio",
44
+ "DevlioClient",
45
+ "DevlioLicense",
46
+ "DevlioError",
47
+ "AuthenticationError",
48
+ "LicenseError",
49
+ "LicenseInvalidError",
50
+ "LicenseExpiredError",
51
+ "ActivationLimitReachedError",
52
+ "NetworkError",
53
+ "__version__",
54
+ ]
devlio/client.py ADDED
@@ -0,0 +1,166 @@
1
+ """
2
+ Devlio Personal & Store API Client.
3
+
4
+ Allows creators, sellers, and buyers to interact with their Devlio account
5
+ programmatically using an API Token.
6
+ """
7
+
8
+ import sys
9
+ import json
10
+ import urllib.request
11
+ import urllib.error
12
+ from typing import Optional, Dict, Any, List
13
+
14
+ from .exceptions import DevlioError, AuthenticationError, NetworkError
15
+ from .license import DevlioLicense
16
+
17
+
18
+ class DevlioClient:
19
+ """
20
+ Authenticated client for Devlio Personal API v2.
21
+
22
+ Usage:
23
+ client = DevlioClient(api_token="devlio_tok_...")
24
+ me = client.me()
25
+ print(f"Logged in as: {me['username']}")
26
+ """
27
+
28
+ def __init__(
29
+ self,
30
+ api_token: str,
31
+ base_url: str = "https://devlio.store",
32
+ timeout: int = 10,
33
+ ):
34
+ """
35
+ :param api_token: Your Personal API Token from Devlio Profile -> Personal API.
36
+ :param base_url: Base Devlio store URL. Defaults to 'https://devlio.store'.
37
+ :param timeout: Request timeout in seconds.
38
+ """
39
+ if not api_token:
40
+ raise AuthenticationError("API token is required to initialize DevlioClient.")
41
+ self.api_token = api_token.strip()
42
+ self.base_url = base_url.rstrip("/")
43
+ self.timeout = timeout
44
+
45
+ def _request(
46
+ self,
47
+ method: str,
48
+ path: str,
49
+ params: Optional[Dict[str, Any]] = None,
50
+ data: Optional[Dict[str, Any]] = None,
51
+ ) -> Dict[str, Any]:
52
+ url = f"{self.base_url}/api/v2{path}"
53
+ if params:
54
+ query = urllib.parse.urlencode({k: v for k, v in params.items() if v is not None})
55
+ url = f"{url}?{query}"
56
+
57
+ body = json.dumps(data).encode("utf-8") if data is not None else None
58
+ headers = {
59
+ "Authorization": f"Bearer {self.api_token}",
60
+ "Content-Type": "application/json",
61
+ "Accept": "application/json",
62
+ "User-Agent": f"Devlio-Python-SDK/1.0.0 ({sys.platform})",
63
+ }
64
+
65
+ req = urllib.request.Request(url, data=body, headers=headers, method=method.upper())
66
+ try:
67
+ with urllib.request.urlopen(req, timeout=self.timeout) as resp:
68
+ raw = resp.read().decode("utf-8")
69
+ return json.loads(raw)
70
+ except urllib.error.HTTPError as e:
71
+ raw_err = e.read().decode("utf-8", errors="ignore")
72
+ try:
73
+ err_json = json.loads(raw_err)
74
+ msg = err_json.get("message") or err_json.get("error") or f"HTTP {e.code}"
75
+ except Exception:
76
+ msg = f"HTTP {e.code}: {e.reason}"
77
+
78
+ if e.code in (401, 403):
79
+ raise AuthenticationError(msg)
80
+ raise DevlioError(msg)
81
+ except Exception as e:
82
+ raise NetworkError(f"Network request to {url} failed: {e}")
83
+
84
+ # --- Profile & Account ---
85
+
86
+ def me(self) -> Dict[str, Any]:
87
+ """Fetch authenticated user profile details, roles, and balances."""
88
+ return self._request("GET", "/me")
89
+
90
+ def health(self) -> Dict[str, Any]:
91
+ """Check API service status and connectivity."""
92
+ return self._request("GET", "/health")
93
+
94
+ # --- Projects & Creator Studio ---
95
+
96
+ def my_projects(self) -> List[Dict[str, Any]]:
97
+ """List all projects created or published by the authenticated user."""
98
+ res = self._request("GET", "/projects/mine")
99
+ return res.get("projects", [])
100
+
101
+ def project_sales(self, project_id: int, page: int = 1) -> Dict[str, Any]:
102
+ """Get sales history and orders for a specific project."""
103
+ return self._request("GET", f"/projects/{project_id}/sales", params={"page": page})
104
+
105
+ def earnings_summary(self) -> Dict[str, Any]:
106
+ """Get creator earnings breakdown (lifetime, pending, cleared balances)."""
107
+ return self._request("GET", "/earnings/summary")
108
+
109
+ # --- Customer Purchases & Vault ---
110
+
111
+ def my_licenses(self) -> List[Dict[str, Any]]:
112
+ """List all software licenses owned by this account."""
113
+ res = self._request("GET", "/licenses")
114
+ return res.get("licenses", [])
115
+
116
+ def my_downloads(self) -> List[Dict[str, Any]]:
117
+ """List active digital project downloads available in user vault."""
118
+ res = self._request("GET", "/downloads")
119
+ return res.get("downloads", [])
120
+
121
+ # --- Support Tickets ---
122
+
123
+ def tickets(self, status: Optional[str] = None) -> List[Dict[str, Any]]:
124
+ """List support tickets (as customer or project creator)."""
125
+ params = {"status": status} if status else {}
126
+ res = self._request("GET", "/tickets", params=params)
127
+ return res.get("tickets", [])
128
+
129
+ def ticket(self, ticket_id: int) -> Dict[str, Any]:
130
+ """Get full thread and messages for a specific support ticket."""
131
+ return self._request("GET", f"/tickets/{ticket_id}")
132
+
133
+ def reply_ticket(self, ticket_id: int, message: str) -> Dict[str, Any]:
134
+ """Post a reply to an existing support ticket."""
135
+ return self._request("POST", f"/tickets/{ticket_id}/reply", data={"message": message})
136
+
137
+ # --- Coupons ---
138
+
139
+ def coupons(self) -> List[Dict[str, Any]]:
140
+ """List discount coupons created for your projects."""
141
+ res = self._request("GET", "/coupons")
142
+ return res.get("coupons", [])
143
+
144
+ def create_coupon(
145
+ self,
146
+ code: str,
147
+ discount_percent: int,
148
+ project_id: Optional[int] = None,
149
+ max_uses: Optional[int] = None,
150
+ expires_at: Optional[str] = None,
151
+ ) -> Dict[str, Any]:
152
+ """Create a new promotional discount coupon."""
153
+ data = {
154
+ "code": code.strip().upper(),
155
+ "discount_percent": discount_percent,
156
+ "project_id": project_id,
157
+ "max_uses": max_uses,
158
+ "expires_at": expires_at,
159
+ }
160
+ return self._request("POST", "/coupons", data=data)
161
+
162
+ # --- Helper to create a license manager ---
163
+
164
+ def license(self, project_slug: str, **kwargs) -> DevlioLicense:
165
+ """Create a DevlioLicense manager instance configured with this client's base_url."""
166
+ return DevlioLicense(project_slug, base_url=self.base_url, **kwargs)
devlio/exceptions.py ADDED
@@ -0,0 +1,42 @@
1
+ """
2
+ Devlio SDK Exceptions.
3
+ """
4
+
5
+
6
+ class DevlioError(Exception):
7
+ """Base exception for all Devlio SDK errors."""
8
+ pass
9
+
10
+
11
+ class AuthenticationError(DevlioError):
12
+ """Raised when an API request fails due to invalid or missing credentials."""
13
+ pass
14
+
15
+
16
+ class LicenseError(DevlioError):
17
+ """Base exception for license-related operations."""
18
+ def __init__(self, message, code=None, status=None, details=None):
19
+ super().__init__(message)
20
+ self.code = code
21
+ self.status = status
22
+ self.details = details or {}
23
+
24
+
25
+ class LicenseInvalidError(LicenseError):
26
+ """Raised when a license key is invalid or not found."""
27
+ pass
28
+
29
+
30
+ class LicenseExpiredError(LicenseError):
31
+ """Raised when a license key has expired."""
32
+ pass
33
+
34
+
35
+ class ActivationLimitReachedError(LicenseError):
36
+ """Raised when the maximum activation limit for a license key is reached."""
37
+ pass
38
+
39
+
40
+ class NetworkError(DevlioError):
41
+ """Raised when an HTTP or network timeout error occurs."""
42
+ pass
devlio/license.py ADDED
@@ -0,0 +1,296 @@
1
+ """
2
+ Devlio License Manager.
3
+
4
+ Provides high-level helpers to activate, verify, and deactivate project licenses
5
+ with automatic caching, machine HWID / domain detection, and offline grace periods.
6
+ """
7
+
8
+ import os
9
+ import sys
10
+ import json
11
+ import time
12
+ import socket
13
+ import hashlib
14
+ import tempfile
15
+ import urllib.request
16
+ import urllib.error
17
+ from typing import Optional, Dict, Any, Union
18
+
19
+ from .exceptions import (
20
+ DevlioError,
21
+ LicenseError,
22
+ LicenseInvalidError,
23
+ LicenseExpiredError,
24
+ ActivationLimitReachedError,
25
+ NetworkError,
26
+ )
27
+
28
+
29
+ class DevlioLicense:
30
+ """
31
+ Manager for interacting with Devlio's native licensing system.
32
+
33
+ Usage:
34
+ license_mgr = DevlioLicense("my-project-slug")
35
+ is_valid = license_mgr.verify("DEV-XXXX-XXXX-XXXX")
36
+ if not is_valid:
37
+ sys.exit("License check failed!")
38
+ """
39
+
40
+ def __init__(
41
+ self,
42
+ project_slug: str,
43
+ base_url: str = "https://devlio.store",
44
+ cache_ttl: int = 86400,
45
+ grace_period: int = 172800,
46
+ cache_dir: Optional[str] = None,
47
+ timeout: int = 8,
48
+ ):
49
+ """
50
+ :param project_slug: The unique project slug on Devlio (e.g., 'fast-cms').
51
+ :param base_url: The Devlio site base URL. Defaults to 'https://devlio.store'.
52
+ :param cache_ttl: Cache verification results in seconds (default: 24h = 86400s). Set to 0 to disable.
53
+ :param grace_period: Offline grace period in seconds if server cannot be reached (default: 48h = 172800s).
54
+ :param cache_dir: Optional directory to store license cache files. Defaults to system temp.
55
+ :param timeout: HTTP request timeout in seconds.
56
+ """
57
+ self.project_slug = project_slug.strip()
58
+ self.base_url = base_url.rstrip("/")
59
+ self.cache_ttl = cache_ttl
60
+ self.grace_period = grace_period
61
+ self.timeout = timeout
62
+ self.cache_dir = cache_dir or os.path.join(tempfile.gettempdir(), "devlio_cache")
63
+ if not os.path.exists(self.cache_dir):
64
+ try:
65
+ os.makedirs(self.cache_dir, exist_ok=True)
66
+ except OSError:
67
+ self.cache_dir = tempfile.gettempdir()
68
+
69
+ def _get_cache_path(self, license_key: str, domain: Optional[str] = None) -> str:
70
+ ident = f"{self.project_slug}:{license_key.strip()}:{domain or ''}"
71
+ h = hashlib.sha256(ident.encode("utf-8")).hexdigest()[:24]
72
+ return os.path.join(self.cache_dir, f"devlio_lic_{h}.json")
73
+
74
+ def _read_cache(self, license_key: str, domain: Optional[str] = None) -> Optional[Dict[str, Any]]:
75
+ path = self._get_cache_path(license_key, domain)
76
+ if not os.path.exists(path):
77
+ return None
78
+ try:
79
+ with open(path, "r", encoding="utf-8") as f:
80
+ data = json.load(f)
81
+ cached_at = data.get("_cached_at", 0)
82
+ now = time.time()
83
+ # If still within normal TTL
84
+ if (now - cached_at) < self.cache_ttl:
85
+ return data
86
+ # If expired but within grace period
87
+ data["_in_grace_period"] = (now - cached_at) < (self.cache_ttl + self.grace_period)
88
+ return data
89
+ except Exception:
90
+ return None
91
+
92
+ def _write_cache(self, license_key: str, domain: Optional[str], data: Dict[str, Any]) -> None:
93
+ if self.cache_ttl <= 0:
94
+ return
95
+ path = self._get_cache_path(license_key, domain)
96
+ try:
97
+ to_save = dict(data)
98
+ to_save["_cached_at"] = time.time()
99
+ with open(path, "w", encoding="utf-8") as f:
100
+ json.dump(to_save, f)
101
+ except Exception:
102
+ pass
103
+
104
+ def _clear_cache(self, license_key: str, domain: Optional[str] = None) -> None:
105
+ path = self._get_cache_path(license_key, domain)
106
+ if os.path.exists(path):
107
+ try:
108
+ os.remove(path)
109
+ except OSError:
110
+ pass
111
+
112
+ @staticmethod
113
+ def detect_domain() -> str:
114
+ """Auto-detect hostname or machine name."""
115
+ try:
116
+ return socket.gethostname() or "localhost"
117
+ except Exception:
118
+ return "localhost"
119
+
120
+ @staticmethod
121
+ def detect_hwid() -> str:
122
+ """Generate a basic stable machine hardware identifier."""
123
+ parts = [socket.gethostname(), sys.platform]
124
+ try:
125
+ import uuid
126
+ parts.append(str(uuid.getnode()))
127
+ except Exception:
128
+ pass
129
+ return hashlib.sha256(":".join(parts).encode("utf-8")).hexdigest()[:32]
130
+
131
+ def _http_post(self, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
132
+ url = f"{self.base_url}{endpoint}"
133
+ body = json.dumps(payload).encode("utf-8")
134
+ req = urllib.request.Request(
135
+ url,
136
+ data=body,
137
+ headers={
138
+ "Content-Type": "application/json",
139
+ "Accept": "application/json",
140
+ "User-Agent": f"Devlio-Python-SDK/1.0.0 ({sys.platform})",
141
+ },
142
+ method="POST",
143
+ )
144
+ try:
145
+ with urllib.request.urlopen(req, timeout=self.timeout) as resp:
146
+ resp_body = resp.read().decode("utf-8")
147
+ return json.loads(resp_body)
148
+ except urllib.error.HTTPError as e:
149
+ err_body = e.read().decode("utf-8", errors="ignore")
150
+ try:
151
+ parsed = json.loads(err_body)
152
+ return parsed
153
+ except Exception:
154
+ raise DevlioError(f"HTTP {e.code}: {e.reason}")
155
+ except (urllib.error.URLError, TimeoutError, socket.timeout) as e:
156
+ raise NetworkError(f"Network error connecting to {url}: {e}")
157
+
158
+ def verify(
159
+ self,
160
+ license_key: str,
161
+ domain: Optional[str] = None,
162
+ hwid: Optional[str] = None,
163
+ raise_on_invalid: bool = False,
164
+ ) -> bool:
165
+ """
166
+ Verify if a license key is valid and active for this project instance.
167
+
168
+ :param license_key: The license key string (e.g. DEV-XXXX-XXXX-XXXX).
169
+ :param domain: Optional domain or hostname. Defaults to detected hostname.
170
+ :param hwid: Optional machine hardware identifier. Defaults to detected HWID.
171
+ :param raise_on_invalid: If True, raises LicenseError on invalid/expired status.
172
+ :return: True if valid, False otherwise.
173
+ """
174
+ license_key = license_key.strip()
175
+ domain = domain or self.detect_domain()
176
+ hwid = hwid or self.detect_hwid()
177
+
178
+ # 1. Check local cache
179
+ cached = self._read_cache(license_key, domain)
180
+ if cached and cached.get("valid") is True and not cached.get("_in_grace_period"):
181
+ return True
182
+
183
+ # 2. Call Devlio API
184
+ payload = {
185
+ "license_key": license_key,
186
+ "project_slug": self.project_slug,
187
+ "domain": domain,
188
+ "hwid": hwid,
189
+ }
190
+
191
+ try:
192
+ res = self._http_post("/api/v1/licenses/verify", payload)
193
+ except NetworkError as e:
194
+ # Check offline grace period
195
+ if cached and cached.get("valid") is True and cached.get("_in_grace_period"):
196
+ return True
197
+ if raise_on_invalid:
198
+ raise e
199
+ return False
200
+
201
+ is_valid = bool(res.get("valid"))
202
+ status = res.get("status")
203
+
204
+ if is_valid:
205
+ self._write_cache(license_key, domain, res)
206
+ return True
207
+
208
+ # Clear cache if license is now explicitly invalid or revoked
209
+ self._clear_cache(license_key, domain)
210
+
211
+ if raise_on_invalid:
212
+ msg = res.get("message") or f"License is not valid (status: {status})"
213
+ if status == "expired":
214
+ raise LicenseExpiredError(msg, status=status)
215
+ raise LicenseInvalidError(msg, status=status)
216
+
217
+ return False
218
+
219
+ def activate(
220
+ self,
221
+ license_key: str,
222
+ domain: Optional[str] = None,
223
+ hwid: Optional[str] = None,
224
+ instance_name: Optional[str] = None,
225
+ ) -> Dict[str, Any]:
226
+ """
227
+ Activate software for the given license key on this machine/domain.
228
+
229
+ :param license_key: The license key string.
230
+ :param domain: Optional domain.
231
+ :param hwid: Optional hardware ID.
232
+ :param instance_name: Optional label (e.g., 'Production Server').
233
+ :return: Response dict from Devlio API.
234
+ :raises ActivationLimitReachedError: If maximum allowed installations is exceeded.
235
+ :raises LicenseError: On other activation errors.
236
+ """
237
+ license_key = license_key.strip()
238
+ domain = domain or self.detect_domain()
239
+ hwid = hwid or self.detect_hwid()
240
+
241
+ payload = {
242
+ "license_key": license_key,
243
+ "project_slug": self.project_slug,
244
+ "domain": domain,
245
+ "hwid": hwid,
246
+ "instance_name": instance_name or f"{domain} ({sys.platform})",
247
+ }
248
+
249
+ res = self._http_post("/api/v1/licenses/activate", payload)
250
+
251
+ if not res.get("success"):
252
+ err_code = res.get("error")
253
+ msg = res.get("message", "License activation failed.")
254
+ if err_code == "ACTIVATION_LIMIT_REACHED":
255
+ raise ActivationLimitReachedError(
256
+ msg,
257
+ code=err_code,
258
+ details={
259
+ "max_activations": res.get("max_activations"),
260
+ "active_activations": res.get("active_activations"),
261
+ },
262
+ )
263
+ raise LicenseError(msg, code=err_code)
264
+
265
+ # Cache positive result
266
+ self._write_cache(license_key, domain, {"valid": True, "license": res.get("license")})
267
+ return res
268
+
269
+ def deactivate(
270
+ self,
271
+ license_key: str,
272
+ domain: Optional[str] = None,
273
+ hwid: Optional[str] = None,
274
+ ) -> Dict[str, Any]:
275
+ """
276
+ Deactivate software instance to release an activation slot.
277
+
278
+ :param license_key: The license key string.
279
+ :param domain: Domain or hostname to deactivate.
280
+ :param hwid: HWID to deactivate.
281
+ :return: Response dict from Devlio API.
282
+ """
283
+ license_key = license_key.strip()
284
+ domain = domain or self.detect_domain()
285
+ hwid = hwid or self.detect_hwid()
286
+
287
+ payload = {
288
+ "license_key": license_key,
289
+ "project_slug": self.project_slug,
290
+ "domain": domain,
291
+ "hwid": hwid,
292
+ }
293
+
294
+ res = self._http_post("/api/v1/licenses/deactivate", payload)
295
+ self._clear_cache(license_key, domain)
296
+ return res
@@ -0,0 +1,75 @@
1
+ Metadata-Version: 2.4
2
+ Name: devlio
3
+ Version: 1.0.0
4
+ Summary: Official Python SDK for Devlio software licensing and digital marketplace API.
5
+ Author-email: Devlio Team <support@devlio.store>
6
+ License-Expression: MIT
7
+ Project-URL: Homepage, https://devlio.store
8
+ Project-URL: Documentation, https://devlio.store/docs
9
+ Project-URL: Repository, https://github.com/devlio/devlio-python-sdk
10
+ Project-URL: Issues, https://github.com/devlio/devlio-python-sdk/issues
11
+ Keywords: devlio,licensing,software-protection,marketplace,api-sdk
12
+ Classifier: Programming Language :: Python :: 3
13
+ Classifier: Operating System :: OS Independent
14
+ Classifier: Topic :: Software Development :: Libraries :: Python Modules
15
+ Classifier: Topic :: Security
16
+ Requires-Python: >=3.7
17
+ Description-Content-Type: text/markdown
18
+
19
+ # Devlio Python SDK
20
+
21
+ Official Python library for the Devlio digital marketplace and license verification engine.
22
+
23
+ ## Installation
24
+
25
+ ```bash
26
+ pip install devlio
27
+ ```
28
+
29
+ ## Quick Start: Software License Verification
30
+
31
+ Verify buyer license keys in your Python apps, CLI tools, scripts, or backend services with built-in 24-hour caching and automatic offline grace periods:
32
+
33
+ ```python
34
+ from devlio import DevlioLicense
35
+
36
+ # Initialize with your Devlio project slug
37
+ lic = DevlioLicense("your-project-slug")
38
+
39
+ # Verify license
40
+ if lic.verify("DEV-XXXX-XXXX-XXXX"):
41
+ print("License active!")
42
+ else:
43
+ print("Invalid or expired license.")
44
+ ```
45
+
46
+ ### Activation & Deactivation
47
+
48
+ ```python
49
+ # Activate on installation
50
+ lic.activate("DEV-XXXX-XXXX-XXXX", instance_name="Production Server")
51
+
52
+ # Deactivate on uninstall to free up a slot
53
+ lic.deactivate("DEV-XXXX-XXXX-XXXX")
54
+ ```
55
+
56
+ ---
57
+
58
+ ## Creator & Store API
59
+
60
+ Manage your marketplace account, inspect sales, and reply to support tickets programmatically:
61
+
62
+ ```python
63
+ from devlio import Devlio
64
+
65
+ client = Devlio(api_token="devlio_tok_...")
66
+
67
+ # Get user info
68
+ me = client.me()
69
+
70
+ # View published projects
71
+ projects = client.my_projects()
72
+
73
+ # Inspect earnings
74
+ earnings = client.earnings_summary()
75
+ ```
@@ -0,0 +1,8 @@
1
+ devlio/__init__.py,sha256=0BEtH0jF4vtWcS7sDDFseFQRi7FwG8YE19nK06iTBBo,1235
2
+ devlio/client.py,sha256=ZUqOlfp1SShCY-kBdMVZM4p_xcwDtB1glMO5Kz4Lij8,6128
3
+ devlio/exceptions.py,sha256=B0k6ZeHMKDcU9WaczzJylwlApnLn6PR4zfNqbSyIDLw,1007
4
+ devlio/license.py,sha256=2Mh2o12taG0BOSO0f5akne2CVFX4lrVZLe-aouftZPo,10609
5
+ devlio-1.0.0.dist-info/METADATA,sha256=SuxNNtxtMNexVxgTKrglEQHLpy0CAfYpZMEWxdcdE7c,2068
6
+ devlio-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
7
+ devlio-1.0.0.dist-info/top_level.txt,sha256=vYRmPEqBNxQap-PkAp3ZFYMyjiEJSB1csZiDUw22Jpk,7
8
+ devlio-1.0.0.dist-info/RECORD,,
@@ -0,0 +1,5 @@
1
+ Wheel-Version: 1.0
2
+ Generator: setuptools (84.2.1)
3
+ Root-Is-Purelib: true
4
+ Tag: py3-none-any
5
+
@@ -0,0 +1 @@
1
+ devlio