octoprint 0.1.0
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.
- checksums.yaml +7 -0
- data/CHANGELOG.md +10 -0
- data/LICENSE.txt +21 -0
- data/README.md +336 -0
- data/lib/octoprint/access/group.rb +88 -0
- data/lib/octoprint/access/groups.rb +166 -0
- data/lib/octoprint/access/login_response.rb +63 -0
- data/lib/octoprint/access/permission.rb +71 -0
- data/lib/octoprint/access/permissions.rb +29 -0
- data/lib/octoprint/access/user.rb +95 -0
- data/lib/octoprint/access/users.rb +347 -0
- data/lib/octoprint/auto_initializable.rb +219 -0
- data/lib/octoprint/base_resource.rb +139 -0
- data/lib/octoprint/client.rb +151 -0
- data/lib/octoprint/connection/options.rb +44 -0
- data/lib/octoprint/connection/settings.rb +35 -0
- data/lib/octoprint/connection.rb +74 -0
- data/lib/octoprint/deserializable.rb +483 -0
- data/lib/octoprint/exceptions.rb +30 -0
- data/lib/octoprint/files/file.rb +55 -0
- data/lib/octoprint/files/folder.rb +29 -0
- data/lib/octoprint/files/operation_result.rb +37 -0
- data/lib/octoprint/files/refs.rb +19 -0
- data/lib/octoprint/files.rb +238 -0
- data/lib/octoprint/job/information.rb +42 -0
- data/lib/octoprint/job/progress.rb +46 -0
- data/lib/octoprint/job.rb +140 -0
- data/lib/octoprint/languages/language_pack.rb +31 -0
- data/lib/octoprint/languages.rb +102 -0
- data/lib/octoprint/location.rb +23 -0
- data/lib/octoprint/logs/log_file.rb +59 -0
- data/lib/octoprint/logs/references.rb +28 -0
- data/lib/octoprint/logs.rb +98 -0
- data/lib/octoprint/printer/bed.rb +32 -0
- data/lib/octoprint/printer/chamber.rb +29 -0
- data/lib/octoprint/printer/command.rb +129 -0
- data/lib/octoprint/printer/custom_control/input.rb +45 -0
- data/lib/octoprint/printer/custom_control.rb +119 -0
- data/lib/octoprint/printer/error_information.rb +104 -0
- data/lib/octoprint/printer/heater.rb +113 -0
- data/lib/octoprint/printer/history_query.rb +25 -0
- data/lib/octoprint/printer/printhead.rb +105 -0
- data/lib/octoprint/printer/sd.rb +97 -0
- data/lib/octoprint/printer/state.rb +41 -0
- data/lib/octoprint/printer/state_flags.rb +70 -0
- data/lib/octoprint/printer/temperature_attributes.rb +70 -0
- data/lib/octoprint/printer/temperature_data.rb +53 -0
- data/lib/octoprint/printer/temperature_data_point.rb +73 -0
- data/lib/octoprint/printer/temperature_reading.rb +47 -0
- data/lib/octoprint/printer/temperature_state.rb +67 -0
- data/lib/octoprint/printer/tool.rb +154 -0
- data/lib/octoprint/printer.rb +126 -0
- data/lib/octoprint/printer_profiles/printer_profile.rb +40 -0
- data/lib/octoprint/printer_profiles.rb +158 -0
- data/lib/octoprint/server_information.rb +51 -0
- data/lib/octoprint/server_version.rb +52 -0
- data/lib/octoprint/settings/webcam.rb +135 -0
- data/lib/octoprint/settings.rb +133 -0
- data/lib/octoprint/slicing/profile.rb +65 -0
- data/lib/octoprint/slicing/slicer.rb +83 -0
- data/lib/octoprint/slicing.rb +227 -0
- data/lib/octoprint/system_commands/command.rb +41 -0
- data/lib/octoprint/system_commands.rb +110 -0
- data/lib/octoprint/timelapse/config.rb +68 -0
- data/lib/octoprint/timelapse/file_attributes.rb +50 -0
- data/lib/octoprint/timelapse/rendered.rb +51 -0
- data/lib/octoprint/timelapse/unrendered.rb +43 -0
- data/lib/octoprint/timelapse.rb +221 -0
- data/lib/octoprint/types.rb +140 -0
- data/lib/octoprint/util.rb +151 -0
- data/lib/octoprint/version.rb +7 -0
- data/lib/octoprint/wizard.rb +57 -0
- data/lib/octoprint.rb +57 -0
- data/rbi/octoprint/access/group.rbi +46 -0
- data/rbi/octoprint/access/login_response.rbi +22 -0
- data/rbi/octoprint/access/permission.rbi +34 -0
- data/rbi/octoprint/access/user.rbi +43 -0
- data/rbi/octoprint/connection/options.rbi +28 -0
- data/rbi/octoprint/connection/settings.rbi +19 -0
- data/rbi/octoprint/connection.rbi +13 -0
- data/rbi/octoprint/files/file.rbi +61 -0
- data/rbi/octoprint/files/folder.rbi +22 -0
- data/rbi/octoprint/files/operation_result.rbi +22 -0
- data/rbi/octoprint/files/refs.rbi +16 -0
- data/rbi/octoprint/job/information.rbi +22 -0
- data/rbi/octoprint/job/progress.rbi +25 -0
- data/rbi/octoprint/job.rbi +22 -0
- data/rbi/octoprint/languages/language_pack.rbi +19 -0
- data/rbi/octoprint/languages.rbi +13 -0
- data/rbi/octoprint/logs/log_file.rbi +19 -0
- data/rbi/octoprint/logs/references.rbi +13 -0
- data/rbi/octoprint/logs.rbi +13 -0
- data/rbi/octoprint/printer/bed.rbi +22 -0
- data/rbi/octoprint/printer/chamber.rbi +22 -0
- data/rbi/octoprint/printer/custom_control/input.rbi +22 -0
- data/rbi/octoprint/printer/custom_control.rbi +67 -0
- data/rbi/octoprint/printer/error_information.rbi +25 -0
- data/rbi/octoprint/printer/sd.rbi +13 -0
- data/rbi/octoprint/printer/state.rbi +19 -0
- data/rbi/octoprint/printer/state_flags.rbi +43 -0
- data/rbi/octoprint/printer/temperature_data.rbi +19 -0
- data/rbi/octoprint/printer/temperature_data_point.rbi +22 -0
- data/rbi/octoprint/printer/temperature_reading.rbi +19 -0
- data/rbi/octoprint/printer/temperature_state.rbi +22 -0
- data/rbi/octoprint/printer/tool.rbi +22 -0
- data/rbi/octoprint/printer.rbi +19 -0
- data/rbi/octoprint/printer_profiles/printer_profile.rbi +46 -0
- data/rbi/octoprint/printer_profiles.rbi +13 -0
- data/rbi/octoprint/server_information.rbi +16 -0
- data/rbi/octoprint/server_version.rbi +19 -0
- data/rbi/octoprint/settings/webcam.rbi +34 -0
- data/rbi/octoprint/slicing/profile.rbi +28 -0
- data/rbi/octoprint/slicing/slicer.rbi +31 -0
- data/rbi/octoprint/system_commands/command.rbi +25 -0
- data/rbi/octoprint/system_commands.rbi +16 -0
- data/rbi/octoprint/timelapse/config.rbi +31 -0
- data/rbi/octoprint/timelapse/rendered.rbi +31 -0
- data/rbi/octoprint/timelapse/unrendered.rbi +34 -0
- data/rbi/octoprint/timelapse.rbi +22 -0
- data/rbi/octoprint/util.rbi +19 -0
- data/rbi/octoprint.rbi +1848 -0
- metadata +264 -0
data/rbi/octoprint.rbi
ADDED
|
@@ -0,0 +1,1848 @@
|
|
|
1
|
+
# typed: true
|
|
2
|
+
|
|
3
|
+
# DO NOT EDIT MANUALLY
|
|
4
|
+
# This is an autogenerated file for types exported from the `octoprint` gem.
|
|
5
|
+
# Please instead update this file by running `bundle exec rake rbi:export`.
|
|
6
|
+
|
|
7
|
+
module Octoprint
|
|
8
|
+
class << self
|
|
9
|
+
sig { returns(T.nilable(::Octoprint::Client)) }
|
|
10
|
+
def client; end
|
|
11
|
+
|
|
12
|
+
def client=(client); end
|
|
13
|
+
|
|
14
|
+
sig do
|
|
15
|
+
params(
|
|
16
|
+
host: ::String,
|
|
17
|
+
api_key: ::String,
|
|
18
|
+
open_timeout: T.nilable(::Numeric),
|
|
19
|
+
timeout: T.nilable(::Numeric)
|
|
20
|
+
).void
|
|
21
|
+
end
|
|
22
|
+
def configure(host:, api_key:, open_timeout: T.unsafe(nil), timeout: T.unsafe(nil)); end
|
|
23
|
+
end
|
|
24
|
+
end
|
|
25
|
+
|
|
26
|
+
module Octoprint::Access; end
|
|
27
|
+
|
|
28
|
+
class Octoprint::Access::Group
|
|
29
|
+
include ::Octoprint::AutoInitializable
|
|
30
|
+
include ::Octoprint::Deserializable
|
|
31
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
32
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
33
|
+
|
|
34
|
+
def initialize(**kwargs); end
|
|
35
|
+
|
|
36
|
+
def changeable; end
|
|
37
|
+
def dangerous; end
|
|
38
|
+
def default; end
|
|
39
|
+
def description; end
|
|
40
|
+
def extra; end
|
|
41
|
+
def key; end
|
|
42
|
+
def name; end
|
|
43
|
+
def needs; end
|
|
44
|
+
def needs_role; end
|
|
45
|
+
def permissions; end
|
|
46
|
+
def removable; end
|
|
47
|
+
def subgroups; end
|
|
48
|
+
def toggleable; end
|
|
49
|
+
end
|
|
50
|
+
|
|
51
|
+
class Octoprint::Access::Groups < ::Octoprint::BaseResource
|
|
52
|
+
class << self
|
|
53
|
+
sig do
|
|
54
|
+
params(
|
|
55
|
+
key: ::String,
|
|
56
|
+
name: ::String,
|
|
57
|
+
description: ::String,
|
|
58
|
+
permissions: T::Array[::String],
|
|
59
|
+
subgroups: T::Array[::String],
|
|
60
|
+
default: T::Boolean
|
|
61
|
+
).returns(T::Array[::Octoprint::Access::Group])
|
|
62
|
+
end
|
|
63
|
+
def add(key:, name:, description:, permissions:, subgroups:, default:); end
|
|
64
|
+
|
|
65
|
+
sig do
|
|
66
|
+
params(
|
|
67
|
+
key: T.nilable(::String),
|
|
68
|
+
path: ::String,
|
|
69
|
+
params: T::Hash[::Symbol, T.untyped],
|
|
70
|
+
headers: T::Hash[::Symbol, T.untyped],
|
|
71
|
+
options: T::Hash[::Symbol, T.untyped]
|
|
72
|
+
).returns(T.untyped)
|
|
73
|
+
end
|
|
74
|
+
def delete(key: T.unsafe(nil), path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
75
|
+
|
|
76
|
+
sig { params(path: ::String).void }
|
|
77
|
+
def delete_resource(path); end
|
|
78
|
+
|
|
79
|
+
sig { params(key: ::String).returns(::Octoprint::Access::Group) }
|
|
80
|
+
def get(key:); end
|
|
81
|
+
|
|
82
|
+
sig { returns(T::Array[::Octoprint::Access::Group]) }
|
|
83
|
+
def list; end
|
|
84
|
+
|
|
85
|
+
sig { params(key: ::String, params: T::Hash[::Symbol, T.untyped]).returns(T::Array[::Octoprint::Access::Group]) }
|
|
86
|
+
def update(key:, params:); end
|
|
87
|
+
end
|
|
88
|
+
end
|
|
89
|
+
|
|
90
|
+
class Octoprint::Access::LoginResponse
|
|
91
|
+
include ::Octoprint::AutoInitializable
|
|
92
|
+
include ::Octoprint::Deserializable
|
|
93
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
94
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
95
|
+
|
|
96
|
+
def initialize(**kwargs); end
|
|
97
|
+
|
|
98
|
+
def credentials_seen; end
|
|
99
|
+
def is_external_client; end
|
|
100
|
+
def login_mechanism; end
|
|
101
|
+
def session; end
|
|
102
|
+
def user; end
|
|
103
|
+
end
|
|
104
|
+
|
|
105
|
+
Octoprint::Access::LoginResponse::LOGIN_FIELDS = T.let(T.unsafe(nil), Array)
|
|
106
|
+
|
|
107
|
+
class Octoprint::Access::Permission
|
|
108
|
+
include ::Octoprint::AutoInitializable
|
|
109
|
+
include ::Octoprint::Deserializable
|
|
110
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
111
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
112
|
+
|
|
113
|
+
def initialize(**kwargs); end
|
|
114
|
+
|
|
115
|
+
def dangerous; end
|
|
116
|
+
def default_groups; end
|
|
117
|
+
def description; end
|
|
118
|
+
def extra; end
|
|
119
|
+
def key; end
|
|
120
|
+
def name; end
|
|
121
|
+
def needs; end
|
|
122
|
+
def needs_role; end
|
|
123
|
+
def plugin; end
|
|
124
|
+
end
|
|
125
|
+
|
|
126
|
+
class Octoprint::Access::Permissions < ::Octoprint::BaseResource
|
|
127
|
+
class << self
|
|
128
|
+
sig { returns(T::Array[::Octoprint::Access::Permission]) }
|
|
129
|
+
def list; end
|
|
130
|
+
end
|
|
131
|
+
end
|
|
132
|
+
|
|
133
|
+
class Octoprint::Access::User
|
|
134
|
+
include ::Octoprint::AutoInitializable
|
|
135
|
+
include ::Octoprint::Deserializable
|
|
136
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
137
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
138
|
+
|
|
139
|
+
def initialize(**kwargs); end
|
|
140
|
+
|
|
141
|
+
def active; end
|
|
142
|
+
def admin; end
|
|
143
|
+
def api_key; end
|
|
144
|
+
def extra; end
|
|
145
|
+
def groups; end
|
|
146
|
+
def name; end
|
|
147
|
+
def needs; end
|
|
148
|
+
def needs_role; end
|
|
149
|
+
def permissions; end
|
|
150
|
+
def roles; end
|
|
151
|
+
def settings; end
|
|
152
|
+
def user; end
|
|
153
|
+
|
|
154
|
+
class << self
|
|
155
|
+
sig { returns(::Octoprint::Access::User) }
|
|
156
|
+
def current; end
|
|
157
|
+
end
|
|
158
|
+
end
|
|
159
|
+
|
|
160
|
+
class Octoprint::Access::Users < ::Octoprint::BaseResource
|
|
161
|
+
class << self
|
|
162
|
+
sig do
|
|
163
|
+
params(
|
|
164
|
+
name: ::String,
|
|
165
|
+
password: ::String,
|
|
166
|
+
active: T::Boolean,
|
|
167
|
+
admin: T::Boolean,
|
|
168
|
+
groups: T.nilable(T::Array[::String]),
|
|
169
|
+
permissions: T.nilable(T::Array[::String])
|
|
170
|
+
).returns(T::Array[::Octoprint::Access::User])
|
|
171
|
+
end
|
|
172
|
+
def add(name:, password:, active:, admin:, groups: T.unsafe(nil), permissions: T.unsafe(nil)); end
|
|
173
|
+
|
|
174
|
+
sig { params(username: ::String, password: ::String).returns(T.untyped) }
|
|
175
|
+
def change_password(username:, password:); end
|
|
176
|
+
|
|
177
|
+
sig { returns(::Octoprint::Access::User) }
|
|
178
|
+
def current; end
|
|
179
|
+
|
|
180
|
+
sig do
|
|
181
|
+
params(
|
|
182
|
+
username: T.nilable(::String),
|
|
183
|
+
path: T.nilable(::String),
|
|
184
|
+
params: T.nilable(T::Hash[::Symbol, T.untyped]),
|
|
185
|
+
headers: T.nilable(T::Hash[::Symbol, T.untyped]),
|
|
186
|
+
options: T.nilable(T::Hash[::Symbol, T.untyped])
|
|
187
|
+
).returns(T.untyped)
|
|
188
|
+
end
|
|
189
|
+
def delete(username: T.unsafe(nil), path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
190
|
+
|
|
191
|
+
sig { params(username: ::String).returns(T.untyped) }
|
|
192
|
+
def delete_api_key(username:); end
|
|
193
|
+
|
|
194
|
+
sig { params(path: ::String).void }
|
|
195
|
+
def delete_resource(path); end
|
|
196
|
+
|
|
197
|
+
sig { params(username: ::String).returns(::String) }
|
|
198
|
+
def generate_api_key(username:); end
|
|
199
|
+
|
|
200
|
+
sig { params(username: ::String).returns(::Octoprint::Access::User) }
|
|
201
|
+
def get(username:); end
|
|
202
|
+
|
|
203
|
+
sig { params(username: ::String).returns(T::Hash[::Symbol, T.untyped]) }
|
|
204
|
+
def get_settings(username:); end
|
|
205
|
+
|
|
206
|
+
sig { returns(T::Array[::Octoprint::Access::User]) }
|
|
207
|
+
def list; end
|
|
208
|
+
|
|
209
|
+
sig do
|
|
210
|
+
params(
|
|
211
|
+
username: T.nilable(::String),
|
|
212
|
+
password: T.nilable(::String),
|
|
213
|
+
remember: T::Boolean
|
|
214
|
+
).returns(::Octoprint::Access::LoginResponse)
|
|
215
|
+
end
|
|
216
|
+
def login(username: T.unsafe(nil), password: T.unsafe(nil), remember: T.unsafe(nil)); end
|
|
217
|
+
|
|
218
|
+
sig { returns(T::Boolean) }
|
|
219
|
+
def logout; end
|
|
220
|
+
|
|
221
|
+
sig do
|
|
222
|
+
params(
|
|
223
|
+
username: ::String,
|
|
224
|
+
params: T::Hash[::Symbol, T.untyped]
|
|
225
|
+
).returns(T::Array[::Octoprint::Access::User])
|
|
226
|
+
end
|
|
227
|
+
def update(username:, params:); end
|
|
228
|
+
|
|
229
|
+
sig { params(username: ::String, settings: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
|
|
230
|
+
def update_settings(username:, settings:); end
|
|
231
|
+
|
|
232
|
+
private
|
|
233
|
+
|
|
234
|
+
sig do
|
|
235
|
+
params(
|
|
236
|
+
username: T.nilable(::String),
|
|
237
|
+
password: T.nilable(::String),
|
|
238
|
+
remember: T::Boolean
|
|
239
|
+
).returns(T::Hash[::Symbol, T.untyped])
|
|
240
|
+
end
|
|
241
|
+
def login_params(username, password, remember); end
|
|
242
|
+
|
|
243
|
+
sig { params(path: ::String, params: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
|
|
244
|
+
def patch_with_hash_format(path: T.unsafe(nil), params: T.unsafe(nil)); end
|
|
245
|
+
|
|
246
|
+
sig { params(path: ::String, params: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
|
|
247
|
+
def post_with_hash_format(path: T.unsafe(nil), params: T.unsafe(nil)); end
|
|
248
|
+
|
|
249
|
+
sig { params(path: ::String, params: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
|
|
250
|
+
def put_with_hash_format(path: T.unsafe(nil), params: T.unsafe(nil)); end
|
|
251
|
+
end
|
|
252
|
+
end
|
|
253
|
+
|
|
254
|
+
module Octoprint::AutoInitializable
|
|
255
|
+
mixes_in_class_methods ::Octoprint::AutoInitializable::ClassMethods
|
|
256
|
+
end
|
|
257
|
+
|
|
258
|
+
module Octoprint::AutoInitializable::ClassMethods
|
|
259
|
+
sig do
|
|
260
|
+
params(
|
|
261
|
+
name: ::Symbol,
|
|
262
|
+
type: T.untyped,
|
|
263
|
+
from: T.nilable(::Symbol),
|
|
264
|
+
array: T::Boolean,
|
|
265
|
+
nilable: T::Boolean
|
|
266
|
+
).void
|
|
267
|
+
end
|
|
268
|
+
def auto_attr(name, type: T.unsafe(nil), from: T.unsafe(nil), array: T.unsafe(nil), nilable: T.unsafe(nil)); end
|
|
269
|
+
|
|
270
|
+
sig { returns(T::Hash[::Symbol, T.untyped]) }
|
|
271
|
+
def auto_attrs; end
|
|
272
|
+
|
|
273
|
+
sig { void }
|
|
274
|
+
def auto_initialize!; end
|
|
275
|
+
|
|
276
|
+
private
|
|
277
|
+
|
|
278
|
+
sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
|
|
279
|
+
def convert_value(value, type); end
|
|
280
|
+
end
|
|
281
|
+
|
|
282
|
+
class Octoprint::BaseResource
|
|
283
|
+
def initialize(**attrs); end
|
|
284
|
+
|
|
285
|
+
class << self
|
|
286
|
+
sig do
|
|
287
|
+
params(
|
|
288
|
+
path: ::String,
|
|
289
|
+
params: T::Hash[::Symbol, T.untyped],
|
|
290
|
+
headers: T::Hash[::Symbol, T.untyped],
|
|
291
|
+
options: T::Hash[::Symbol, T.untyped]
|
|
292
|
+
).returns(T.untyped)
|
|
293
|
+
end
|
|
294
|
+
def delete(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
295
|
+
|
|
296
|
+
def deserialize(attrs); end
|
|
297
|
+
def fetch_resource(path = T.unsafe(nil), deserialize: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
298
|
+
|
|
299
|
+
sig do
|
|
300
|
+
params(
|
|
301
|
+
path: ::String,
|
|
302
|
+
params: T::Hash[::Symbol, T.untyped],
|
|
303
|
+
headers: T::Hash[::Symbol, T.untyped],
|
|
304
|
+
options: T::Hash[::Symbol, T.untyped]
|
|
305
|
+
).returns(T.untyped)
|
|
306
|
+
end
|
|
307
|
+
def patch(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
308
|
+
|
|
309
|
+
sig do
|
|
310
|
+
params(
|
|
311
|
+
path: ::String,
|
|
312
|
+
params: T::Hash[::Symbol, T.untyped],
|
|
313
|
+
headers: T::Hash[::Symbol, T.untyped],
|
|
314
|
+
options: T::Hash[::Symbol, T.untyped]
|
|
315
|
+
).returns(T.untyped)
|
|
316
|
+
end
|
|
317
|
+
def post(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
318
|
+
|
|
319
|
+
sig do
|
|
320
|
+
params(
|
|
321
|
+
path: ::String,
|
|
322
|
+
params: T::Hash[::Symbol, T.untyped],
|
|
323
|
+
headers: T::Hash[::Symbol, T.untyped],
|
|
324
|
+
options: T::Hash[::Symbol, T.untyped]
|
|
325
|
+
).returns(T.untyped)
|
|
326
|
+
end
|
|
327
|
+
def put(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
328
|
+
|
|
329
|
+
def resource_path(path); end
|
|
330
|
+
|
|
331
|
+
private
|
|
332
|
+
|
|
333
|
+
sig { returns(::Octoprint::Client) }
|
|
334
|
+
def client; end
|
|
335
|
+
end
|
|
336
|
+
end
|
|
337
|
+
|
|
338
|
+
class Octoprint::Client
|
|
339
|
+
sig do
|
|
340
|
+
params(
|
|
341
|
+
host: T.nilable(T.any(::String, ::URI::Generic)),
|
|
342
|
+
api_key: T.nilable(::String),
|
|
343
|
+
open_timeout: T.nilable(::Numeric),
|
|
344
|
+
timeout: T.nilable(::Numeric)
|
|
345
|
+
).void
|
|
346
|
+
end
|
|
347
|
+
def initialize(host:, api_key:, open_timeout: T.unsafe(nil), timeout: T.unsafe(nil)); end
|
|
348
|
+
|
|
349
|
+
def api_key; end
|
|
350
|
+
def client; end
|
|
351
|
+
def host; end
|
|
352
|
+
def open_timeout; end
|
|
353
|
+
def request(path, options_or_http_method = T.unsafe(nil), body: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil), http_method: T.unsafe(nil)); end
|
|
354
|
+
def timeout; end
|
|
355
|
+
def use; end
|
|
356
|
+
|
|
357
|
+
private
|
|
358
|
+
|
|
359
|
+
def new_client(multipart: T.unsafe(nil)); end
|
|
360
|
+
def parse_response(response); end
|
|
361
|
+
def process_error(response); end
|
|
362
|
+
def request_with_client(http_method, path, body, headers, force_multipart: T.unsafe(nil)); end
|
|
363
|
+
def transform_keys_recursively(obj); end
|
|
364
|
+
end
|
|
365
|
+
|
|
366
|
+
Octoprint::Client::DEFAULT_OPEN_TIMEOUT = T.let(T.unsafe(nil), Integer)
|
|
367
|
+
Octoprint::Client::DEFAULT_TIMEOUT = T.let(T.unsafe(nil), Integer)
|
|
368
|
+
|
|
369
|
+
class Octoprint::Connection < ::Octoprint::BaseResource
|
|
370
|
+
include ::Octoprint::AutoInitializable
|
|
371
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
372
|
+
|
|
373
|
+
def initialize(**kwargs); end
|
|
374
|
+
|
|
375
|
+
def current; end
|
|
376
|
+
def options; end
|
|
377
|
+
|
|
378
|
+
class << self
|
|
379
|
+
def connect(params = T.unsafe(nil)); end
|
|
380
|
+
def disconnect; end
|
|
381
|
+
def fake_ack; end
|
|
382
|
+
def get; end
|
|
383
|
+
end
|
|
384
|
+
end
|
|
385
|
+
|
|
386
|
+
class Octoprint::Connection::Options
|
|
387
|
+
include ::Octoprint::AutoInitializable
|
|
388
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
389
|
+
|
|
390
|
+
def initialize(**kwargs); end
|
|
391
|
+
|
|
392
|
+
def autoconnect; end
|
|
393
|
+
def baudrate_preference; end
|
|
394
|
+
def baudrates; end
|
|
395
|
+
def port_preference; end
|
|
396
|
+
def ports; end
|
|
397
|
+
def printer_profile_preference; end
|
|
398
|
+
def printer_profiles; end
|
|
399
|
+
end
|
|
400
|
+
|
|
401
|
+
class Octoprint::Connection::Settings
|
|
402
|
+
include ::Octoprint::AutoInitializable
|
|
403
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
404
|
+
|
|
405
|
+
def initialize(**kwargs); end
|
|
406
|
+
|
|
407
|
+
def baudrate; end
|
|
408
|
+
def port; end
|
|
409
|
+
def printer_profile; end
|
|
410
|
+
def state; end
|
|
411
|
+
end
|
|
412
|
+
|
|
413
|
+
module Octoprint::Deserializable
|
|
414
|
+
mixes_in_class_methods ::Octoprint::Deserializable::ClassMethods
|
|
415
|
+
end
|
|
416
|
+
|
|
417
|
+
module Octoprint::Deserializable::ClassMethods
|
|
418
|
+
sig { params(data: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
|
|
419
|
+
def convert_camel_case_keys(data); end
|
|
420
|
+
|
|
421
|
+
sig { params(data: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
|
|
422
|
+
def deserialize(data); end
|
|
423
|
+
|
|
424
|
+
sig do
|
|
425
|
+
params(
|
|
426
|
+
data: T::Hash[::Symbol, T.untyped],
|
|
427
|
+
field: ::Symbol,
|
|
428
|
+
klass: T.untyped
|
|
429
|
+
).returns(T::Hash[::Symbol, T.untyped])
|
|
430
|
+
end
|
|
431
|
+
def deserialize_array(data, field, klass); end
|
|
432
|
+
|
|
433
|
+
sig { params(block: T.nilable(T.proc.bind(::Octoprint::Deserializable::DeserializationConfig).void)).void }
|
|
434
|
+
def deserialize_config(&block); end
|
|
435
|
+
|
|
436
|
+
sig { returns(T.nilable(::Octoprint::Deserializable::DeserializationConfig)) }
|
|
437
|
+
def deserialize_configuration; end
|
|
438
|
+
|
|
439
|
+
sig do
|
|
440
|
+
params(
|
|
441
|
+
data: T::Hash[::Symbol, T.untyped],
|
|
442
|
+
field: ::Symbol,
|
|
443
|
+
klass: T.untyped
|
|
444
|
+
).returns(T::Hash[::Symbol, T.untyped])
|
|
445
|
+
end
|
|
446
|
+
def deserialize_nested(data, field, klass); end
|
|
447
|
+
|
|
448
|
+
sig { params(data: T::Hash[::Symbol, T.untyped]).void }
|
|
449
|
+
def handle_extras(data); end
|
|
450
|
+
|
|
451
|
+
sig do
|
|
452
|
+
params(
|
|
453
|
+
data: T::Hash[::Symbol, T.untyped],
|
|
454
|
+
mapping: T::Hash[::Symbol, ::Symbol]
|
|
455
|
+
).returns(T::Hash[::Symbol, T.untyped])
|
|
456
|
+
end
|
|
457
|
+
def rename_keys(data, mapping); end
|
|
458
|
+
|
|
459
|
+
private
|
|
460
|
+
|
|
461
|
+
sig { params(key: ::Symbol).returns(T::Boolean) }
|
|
462
|
+
def camel_case?(key); end
|
|
463
|
+
|
|
464
|
+
sig { params(camel_key: ::Symbol).returns(::Symbol) }
|
|
465
|
+
def camel_to_snake(camel_key); end
|
|
466
|
+
end
|
|
467
|
+
|
|
468
|
+
class Octoprint::Deserializable::DeserializationConfig
|
|
469
|
+
sig { void }
|
|
470
|
+
def initialize; end
|
|
471
|
+
|
|
472
|
+
sig { params(field: ::Symbol, klass: T.untyped).void }
|
|
473
|
+
def array(field, klass); end
|
|
474
|
+
|
|
475
|
+
sig { returns(T::Hash[::Symbol, T.untyped]) }
|
|
476
|
+
def array_objects; end
|
|
477
|
+
|
|
478
|
+
sig { returns(T::Hash[::Symbol, ::Symbol]) }
|
|
479
|
+
def key_mappings; end
|
|
480
|
+
|
|
481
|
+
sig { params(field: ::Symbol, klass: T.untyped).void }
|
|
482
|
+
def nested(field, klass); end
|
|
483
|
+
|
|
484
|
+
sig { returns(T::Hash[::Symbol, T.untyped]) }
|
|
485
|
+
def nested_objects; end
|
|
486
|
+
|
|
487
|
+
sig { params(mappings: T::Hash[::Symbol, ::Symbol]).void }
|
|
488
|
+
def rename(mappings); end
|
|
489
|
+
|
|
490
|
+
sig { params(block: T.proc.params(data: T::Hash[::Symbol, T.untyped]).void).void }
|
|
491
|
+
def transform(&block); end
|
|
492
|
+
|
|
493
|
+
sig { returns(T::Array[T.proc.params(data: T::Hash[::Symbol, T.untyped]).void]) }
|
|
494
|
+
def transformations; end
|
|
495
|
+
end
|
|
496
|
+
|
|
497
|
+
module Octoprint::Exceptions; end
|
|
498
|
+
class Octoprint::Exceptions::AuthenticationError < ::Octoprint::Exceptions::Error; end
|
|
499
|
+
class Octoprint::Exceptions::BadRequestError < ::Octoprint::Exceptions::Error; end
|
|
500
|
+
class Octoprint::Exceptions::ConflictError < ::Octoprint::Exceptions::Error; end
|
|
501
|
+
class Octoprint::Exceptions::ConnectionError < ::Octoprint::Exceptions::Error; end
|
|
502
|
+
class Octoprint::Exceptions::Error < ::StandardError; end
|
|
503
|
+
class Octoprint::Exceptions::InternalServerError < ::Octoprint::Exceptions::Error; end
|
|
504
|
+
class Octoprint::Exceptions::MissingCredentialsError < ::Octoprint::Exceptions::Error; end
|
|
505
|
+
class Octoprint::Exceptions::NotFoundError < ::Octoprint::Exceptions::Error; end
|
|
506
|
+
class Octoprint::Exceptions::TimeoutError < ::Octoprint::Exceptions::ConnectionError; end
|
|
507
|
+
class Octoprint::Exceptions::UnknownError < ::Octoprint::Exceptions::Error; end
|
|
508
|
+
class Octoprint::Exceptions::UnsupportedMediaTypeError < ::Octoprint::Exceptions::Error; end
|
|
509
|
+
|
|
510
|
+
class Octoprint::Files < ::Octoprint::BaseResource
|
|
511
|
+
def initialize(files:, free: T.unsafe(nil), total: T.unsafe(nil)); end
|
|
512
|
+
|
|
513
|
+
def files; end
|
|
514
|
+
def free; end
|
|
515
|
+
def total; end
|
|
516
|
+
|
|
517
|
+
class << self
|
|
518
|
+
sig { params(filename: ::String, destination: ::String, location: ::Octoprint::Location).returns(T.untyped) }
|
|
519
|
+
def copy(filename:, destination:, location: T.unsafe(nil)); end
|
|
520
|
+
|
|
521
|
+
sig do
|
|
522
|
+
params(
|
|
523
|
+
foldername: ::String,
|
|
524
|
+
location: ::Octoprint::Location,
|
|
525
|
+
path: T.nilable(::String),
|
|
526
|
+
_kargs: T::Hash[::Symbol, T.untyped]
|
|
527
|
+
).returns(::Octoprint::Files::OperationResult)
|
|
528
|
+
end
|
|
529
|
+
def create_folder(foldername:, location: T.unsafe(nil), path: T.unsafe(nil), **_kargs); end
|
|
530
|
+
|
|
531
|
+
sig { params(filename: ::String, location: ::Octoprint::Location).returns(T.untyped) }
|
|
532
|
+
def delete_file(filename:, location: T.unsafe(nil)); end
|
|
533
|
+
|
|
534
|
+
sig do
|
|
535
|
+
params(
|
|
536
|
+
filename: ::String,
|
|
537
|
+
location: ::Octoprint::Location,
|
|
538
|
+
options: T.nilable(T::Hash[::Symbol, T.untyped])
|
|
539
|
+
).returns(::Octoprint::Files::File)
|
|
540
|
+
end
|
|
541
|
+
def get(filename:, location: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
542
|
+
|
|
543
|
+
sig do
|
|
544
|
+
params(
|
|
545
|
+
filename: ::String,
|
|
546
|
+
command: ::String,
|
|
547
|
+
location: ::Octoprint::Location,
|
|
548
|
+
options: T::Hash[::Symbol, T.untyped]
|
|
549
|
+
).returns(T.untyped)
|
|
550
|
+
end
|
|
551
|
+
def issue_command(filename:, command:, location: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
552
|
+
|
|
553
|
+
sig { params(location: ::Octoprint::Location, options: T::Hash[::Symbol, T.untyped]).returns(::Octoprint::Files) }
|
|
554
|
+
def list(location: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
555
|
+
|
|
556
|
+
sig { params(filename: ::String, destination: ::String, location: ::Octoprint::Location).returns(T.untyped) }
|
|
557
|
+
def move(filename:, destination:, location: T.unsafe(nil)); end
|
|
558
|
+
|
|
559
|
+
sig do
|
|
560
|
+
params(
|
|
561
|
+
filename: ::String,
|
|
562
|
+
location: ::Octoprint::Location,
|
|
563
|
+
print: T.nilable(T::Boolean)
|
|
564
|
+
).returns(T.untyped)
|
|
565
|
+
end
|
|
566
|
+
def select(filename:, location: T.unsafe(nil), print: T.unsafe(nil)); end
|
|
567
|
+
|
|
568
|
+
sig do
|
|
569
|
+
params(
|
|
570
|
+
filename: ::String,
|
|
571
|
+
location: ::Octoprint::Location,
|
|
572
|
+
print: T.nilable(T::Boolean),
|
|
573
|
+
profile: T.nilable(T::Hash[::Symbol, T.untyped])
|
|
574
|
+
).returns(T.untyped)
|
|
575
|
+
end
|
|
576
|
+
def slice(filename:, location: T.unsafe(nil), print: T.unsafe(nil), profile: T.unsafe(nil)); end
|
|
577
|
+
|
|
578
|
+
sig { params(filename: ::String, location: ::Octoprint::Location).returns(T.untyped) }
|
|
579
|
+
def unselect(filename:, location: T.unsafe(nil)); end
|
|
580
|
+
|
|
581
|
+
sig do
|
|
582
|
+
params(
|
|
583
|
+
file_path: ::String,
|
|
584
|
+
location: ::Octoprint::Location,
|
|
585
|
+
options: {path: T.nilable(::String), select: T.nilable(T::Boolean), print: T.nilable(T::Boolean), userdata: T.nilable(::String)}
|
|
586
|
+
).returns(::Octoprint::Files::OperationResult)
|
|
587
|
+
end
|
|
588
|
+
def upload(file_path, location: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
589
|
+
end
|
|
590
|
+
end
|
|
591
|
+
|
|
592
|
+
class Octoprint::Files::File
|
|
593
|
+
include ::Octoprint::Deserializable
|
|
594
|
+
include ::Octoprint::AutoInitializable
|
|
595
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
596
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
597
|
+
|
|
598
|
+
def initialize(**kwargs); end
|
|
599
|
+
|
|
600
|
+
def children; end
|
|
601
|
+
def dashboard; end
|
|
602
|
+
|
|
603
|
+
sig { returns(T.nilable(::Time)) }
|
|
604
|
+
def date; end
|
|
605
|
+
|
|
606
|
+
def date_timestamp; end
|
|
607
|
+
def display_layer_progress; end
|
|
608
|
+
def display_name; end
|
|
609
|
+
def extra; end
|
|
610
|
+
def gcode_analysis; end
|
|
611
|
+
def md5_hash; end
|
|
612
|
+
def name; end
|
|
613
|
+
def origin; end
|
|
614
|
+
def path; end
|
|
615
|
+
def prints; end
|
|
616
|
+
def refs; end
|
|
617
|
+
def size; end
|
|
618
|
+
def statistics; end
|
|
619
|
+
def type; end
|
|
620
|
+
def type_path; end
|
|
621
|
+
def userdata; end
|
|
622
|
+
end
|
|
623
|
+
|
|
624
|
+
class Octoprint::Files::Folder
|
|
625
|
+
include ::Octoprint::Deserializable
|
|
626
|
+
include ::Octoprint::AutoInitializable
|
|
627
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
628
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
629
|
+
|
|
630
|
+
def initialize(**kwargs); end
|
|
631
|
+
|
|
632
|
+
def display_name; end
|
|
633
|
+
def name; end
|
|
634
|
+
def origin; end
|
|
635
|
+
def path; end
|
|
636
|
+
def refs; end
|
|
637
|
+
end
|
|
638
|
+
|
|
639
|
+
class Octoprint::Files::OperationResult
|
|
640
|
+
include ::Octoprint::Deserializable
|
|
641
|
+
include ::Octoprint::AutoInitializable
|
|
642
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
643
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
644
|
+
|
|
645
|
+
def initialize(**kwargs); end
|
|
646
|
+
|
|
647
|
+
def done; end
|
|
648
|
+
def effective_print; end
|
|
649
|
+
def effective_select; end
|
|
650
|
+
def files; end
|
|
651
|
+
def folder; end
|
|
652
|
+
end
|
|
653
|
+
|
|
654
|
+
class Octoprint::Files::Refs
|
|
655
|
+
include ::Octoprint::AutoInitializable
|
|
656
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
657
|
+
|
|
658
|
+
def initialize(**kwargs); end
|
|
659
|
+
|
|
660
|
+
def download; end
|
|
661
|
+
def model; end
|
|
662
|
+
def resource; end
|
|
663
|
+
end
|
|
664
|
+
|
|
665
|
+
class Octoprint::Job < ::Octoprint::BaseResource
|
|
666
|
+
include ::Octoprint::AutoInitializable
|
|
667
|
+
include ::Octoprint::Deserializable
|
|
668
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
669
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
670
|
+
|
|
671
|
+
def initialize(**kwargs); end
|
|
672
|
+
|
|
673
|
+
def error; end
|
|
674
|
+
def extra; end
|
|
675
|
+
def information; end
|
|
676
|
+
def progress; end
|
|
677
|
+
def state; end
|
|
678
|
+
|
|
679
|
+
class << self
|
|
680
|
+
sig { returns(T.untyped) }
|
|
681
|
+
def cancel; end
|
|
682
|
+
|
|
683
|
+
sig { returns(::Octoprint::Job) }
|
|
684
|
+
def get; end
|
|
685
|
+
|
|
686
|
+
sig { params(command: ::String, options: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
|
|
687
|
+
def issue_command(command:, options: T.unsafe(nil)); end
|
|
688
|
+
|
|
689
|
+
sig { returns(T.untyped) }
|
|
690
|
+
def pause; end
|
|
691
|
+
|
|
692
|
+
sig { returns(T.untyped) }
|
|
693
|
+
def restart; end
|
|
694
|
+
|
|
695
|
+
sig { returns(T.untyped) }
|
|
696
|
+
def resume; end
|
|
697
|
+
|
|
698
|
+
sig { returns(T.untyped) }
|
|
699
|
+
def start; end
|
|
700
|
+
end
|
|
701
|
+
end
|
|
702
|
+
|
|
703
|
+
class Octoprint::Job::Information
|
|
704
|
+
include ::Octoprint::AutoInitializable
|
|
705
|
+
include ::Octoprint::Deserializable
|
|
706
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
707
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
708
|
+
|
|
709
|
+
def initialize(**kwargs); end
|
|
710
|
+
|
|
711
|
+
def estimated_print_time; end
|
|
712
|
+
def extra; end
|
|
713
|
+
def filament; end
|
|
714
|
+
def file; end
|
|
715
|
+
def last_print_time; end
|
|
716
|
+
end
|
|
717
|
+
|
|
718
|
+
class Octoprint::Job::Progress
|
|
719
|
+
include ::Octoprint::AutoInitializable
|
|
720
|
+
include ::Octoprint::Deserializable
|
|
721
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
722
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
723
|
+
|
|
724
|
+
def initialize(**kwargs); end
|
|
725
|
+
|
|
726
|
+
def completion; end
|
|
727
|
+
def extra; end
|
|
728
|
+
def filepos; end
|
|
729
|
+
def print_time; end
|
|
730
|
+
def print_time_left; end
|
|
731
|
+
def print_time_left_origin; end
|
|
732
|
+
end
|
|
733
|
+
|
|
734
|
+
class Octoprint::Languages < ::Octoprint::BaseResource
|
|
735
|
+
include ::Octoprint::AutoInitializable
|
|
736
|
+
include ::Octoprint::Deserializable
|
|
737
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
738
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
739
|
+
|
|
740
|
+
def initialize(**kwargs); end
|
|
741
|
+
|
|
742
|
+
def extra; end
|
|
743
|
+
def language_packs; end
|
|
744
|
+
|
|
745
|
+
class << self
|
|
746
|
+
sig { params(locale: ::String, pack: ::String).returns(T.untyped) }
|
|
747
|
+
def delete_pack(locale:, pack:); end
|
|
748
|
+
|
|
749
|
+
sig { returns(::Octoprint::Languages) }
|
|
750
|
+
def list; end
|
|
751
|
+
|
|
752
|
+
sig do
|
|
753
|
+
params(
|
|
754
|
+
file_path: ::String,
|
|
755
|
+
locale: T.nilable(::String)
|
|
756
|
+
).returns(T::Array[::Octoprint::Languages::LanguagePack])
|
|
757
|
+
end
|
|
758
|
+
def upload(file_path, locale: T.unsafe(nil)); end
|
|
759
|
+
end
|
|
760
|
+
end
|
|
761
|
+
|
|
762
|
+
class Octoprint::Languages::LanguagePack
|
|
763
|
+
include ::Octoprint::Deserializable
|
|
764
|
+
include ::Octoprint::AutoInitializable
|
|
765
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
766
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
767
|
+
|
|
768
|
+
def initialize(**kwargs); end
|
|
769
|
+
|
|
770
|
+
def display; end
|
|
771
|
+
def extra; end
|
|
772
|
+
def identifier; end
|
|
773
|
+
def languages; end
|
|
774
|
+
end
|
|
775
|
+
|
|
776
|
+
class Octoprint::Location < ::T::Enum
|
|
777
|
+
enums do
|
|
778
|
+
Local = new
|
|
779
|
+
SDCard = new
|
|
780
|
+
end
|
|
781
|
+
|
|
782
|
+
sig { returns(::String) }
|
|
783
|
+
def to_s; end
|
|
784
|
+
end
|
|
785
|
+
|
|
786
|
+
class Octoprint::Logs < ::Octoprint::BaseResource
|
|
787
|
+
include ::Octoprint::Deserializable
|
|
788
|
+
include ::Octoprint::AutoInitializable
|
|
789
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
790
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
791
|
+
|
|
792
|
+
def initialize(**kwargs); end
|
|
793
|
+
|
|
794
|
+
def files; end
|
|
795
|
+
def free; end
|
|
796
|
+
|
|
797
|
+
class << self
|
|
798
|
+
sig { params(filename: ::String).returns(T::Boolean) }
|
|
799
|
+
def delete_file(filename:); end
|
|
800
|
+
|
|
801
|
+
sig { returns(::Octoprint::Logs) }
|
|
802
|
+
def list; end
|
|
803
|
+
end
|
|
804
|
+
end
|
|
805
|
+
|
|
806
|
+
class Octoprint::Logs::LogFile
|
|
807
|
+
include ::Octoprint::Deserializable
|
|
808
|
+
include ::Octoprint::AutoInitializable
|
|
809
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
810
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
811
|
+
|
|
812
|
+
def initialize(**kwargs); end
|
|
813
|
+
|
|
814
|
+
def date; end
|
|
815
|
+
|
|
816
|
+
sig { returns(::Time) }
|
|
817
|
+
def modification_time; end
|
|
818
|
+
|
|
819
|
+
def name; end
|
|
820
|
+
def refs; end
|
|
821
|
+
def size; end
|
|
822
|
+
|
|
823
|
+
sig { returns(::String) }
|
|
824
|
+
def to_s; end
|
|
825
|
+
end
|
|
826
|
+
|
|
827
|
+
class Octoprint::Logs::References
|
|
828
|
+
include ::Octoprint::AutoInitializable
|
|
829
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
830
|
+
|
|
831
|
+
def initialize(**kwargs); end
|
|
832
|
+
|
|
833
|
+
def download; end
|
|
834
|
+
def resource; end
|
|
835
|
+
end
|
|
836
|
+
|
|
837
|
+
class Octoprint::Printer < ::Octoprint::BaseResource
|
|
838
|
+
include ::Octoprint::AutoInitializable
|
|
839
|
+
include ::Octoprint::Deserializable
|
|
840
|
+
extend ::Octoprint::Printer::HistoryQuery
|
|
841
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
842
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
843
|
+
|
|
844
|
+
def initialize(**kwargs); end
|
|
845
|
+
|
|
846
|
+
def extra; end
|
|
847
|
+
def sd; end
|
|
848
|
+
def state; end
|
|
849
|
+
def temperature; end
|
|
850
|
+
|
|
851
|
+
class << self
|
|
852
|
+
sig do
|
|
853
|
+
params(
|
|
854
|
+
history: T::Boolean,
|
|
855
|
+
limit: T.nilable(::Integer),
|
|
856
|
+
exclude: T::Array[T.any(::String, ::Symbol)]
|
|
857
|
+
).returns(::Octoprint::Printer)
|
|
858
|
+
end
|
|
859
|
+
def get(history: T.unsafe(nil), limit: T.unsafe(nil), exclude: T.unsafe(nil)); end
|
|
860
|
+
|
|
861
|
+
sig { returns(::Octoprint::Printer::ErrorInformation) }
|
|
862
|
+
def last_error; end
|
|
863
|
+
end
|
|
864
|
+
end
|
|
865
|
+
|
|
866
|
+
class Octoprint::Printer::Bed < ::Octoprint::BaseResource
|
|
867
|
+
include ::Octoprint::Printer::Heater
|
|
868
|
+
include ::Octoprint::Printer::TemperatureAttributes
|
|
869
|
+
include ::Octoprint::AutoInitializable
|
|
870
|
+
include ::Octoprint::Deserializable
|
|
871
|
+
extend ::Octoprint::Printer::HistoryQuery
|
|
872
|
+
extend ::Octoprint::Printer::Heater::ClassMethods
|
|
873
|
+
extend ::Octoprint::Printer::TemperatureAttributes::ClassMethods
|
|
874
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
875
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
876
|
+
|
|
877
|
+
def initialize(**kwargs); end
|
|
878
|
+
|
|
879
|
+
def actual; end
|
|
880
|
+
def extra; end
|
|
881
|
+
def history; end
|
|
882
|
+
def offset; end
|
|
883
|
+
def target; end
|
|
884
|
+
end
|
|
885
|
+
|
|
886
|
+
class Octoprint::Printer::Chamber < ::Octoprint::BaseResource
|
|
887
|
+
include ::Octoprint::Printer::Heater
|
|
888
|
+
include ::Octoprint::Printer::TemperatureAttributes
|
|
889
|
+
include ::Octoprint::AutoInitializable
|
|
890
|
+
include ::Octoprint::Deserializable
|
|
891
|
+
extend ::Octoprint::Printer::HistoryQuery
|
|
892
|
+
extend ::Octoprint::Printer::Heater::ClassMethods
|
|
893
|
+
extend ::Octoprint::Printer::TemperatureAttributes::ClassMethods
|
|
894
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
895
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
896
|
+
|
|
897
|
+
def initialize(**kwargs); end
|
|
898
|
+
|
|
899
|
+
def actual; end
|
|
900
|
+
def extra; end
|
|
901
|
+
def history; end
|
|
902
|
+
def offset; end
|
|
903
|
+
def target; end
|
|
904
|
+
end
|
|
905
|
+
|
|
906
|
+
class Octoprint::Printer::Command < ::Octoprint::BaseResource
|
|
907
|
+
class << self
|
|
908
|
+
sig { returns(T::Array[::Octoprint::Printer::CustomControl]) }
|
|
909
|
+
def custom_controls; end
|
|
910
|
+
|
|
911
|
+
sig do
|
|
912
|
+
params(
|
|
913
|
+
command: T.nilable(::String),
|
|
914
|
+
commands: T.nilable(T::Array[::String]),
|
|
915
|
+
script: T.nilable(::String),
|
|
916
|
+
parameters: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped]),
|
|
917
|
+
context: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped])
|
|
918
|
+
).returns(T.untyped)
|
|
919
|
+
end
|
|
920
|
+
def issue(command: T.unsafe(nil), commands: T.unsafe(nil), script: T.unsafe(nil), parameters: T.unsafe(nil), context: T.unsafe(nil)); end
|
|
921
|
+
|
|
922
|
+
sig do
|
|
923
|
+
params(
|
|
924
|
+
script: ::String,
|
|
925
|
+
parameters: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped]),
|
|
926
|
+
context: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped])
|
|
927
|
+
).returns(T.untyped)
|
|
928
|
+
end
|
|
929
|
+
def run_script(script, parameters: T.unsafe(nil), context: T.unsafe(nil)); end
|
|
930
|
+
|
|
931
|
+
sig do
|
|
932
|
+
params(
|
|
933
|
+
command: ::String,
|
|
934
|
+
parameters: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped])
|
|
935
|
+
).returns(T.untyped)
|
|
936
|
+
end
|
|
937
|
+
def send_command(command, parameters: T.unsafe(nil)); end
|
|
938
|
+
|
|
939
|
+
sig do
|
|
940
|
+
params(
|
|
941
|
+
commands: T::Array[::String],
|
|
942
|
+
parameters: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped])
|
|
943
|
+
).returns(T.untyped)
|
|
944
|
+
end
|
|
945
|
+
def send_commands(commands, parameters: T.unsafe(nil)); end
|
|
946
|
+
end
|
|
947
|
+
end
|
|
948
|
+
|
|
949
|
+
class Octoprint::Printer::CustomControl
|
|
950
|
+
include ::Octoprint::AutoInitializable
|
|
951
|
+
include ::Octoprint::Deserializable
|
|
952
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
953
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
954
|
+
|
|
955
|
+
def initialize(**kwargs); end
|
|
956
|
+
|
|
957
|
+
def additional_classes; end
|
|
958
|
+
def children; end
|
|
959
|
+
def collapsed; end
|
|
960
|
+
def command; end
|
|
961
|
+
def commands; end
|
|
962
|
+
def confirm; end
|
|
963
|
+
|
|
964
|
+
sig { returns(T::Boolean) }
|
|
965
|
+
def container?; end
|
|
966
|
+
|
|
967
|
+
def enabled; end
|
|
968
|
+
def extra; end
|
|
969
|
+
def input; end
|
|
970
|
+
def javascript; end
|
|
971
|
+
def key; end
|
|
972
|
+
def layout; end
|
|
973
|
+
def name; end
|
|
974
|
+
def offset; end
|
|
975
|
+
def regex; end
|
|
976
|
+
def script; end
|
|
977
|
+
def template; end
|
|
978
|
+
def template_key; end
|
|
979
|
+
def type; end
|
|
980
|
+
def width; end
|
|
981
|
+
end
|
|
982
|
+
|
|
983
|
+
class Octoprint::Printer::CustomControl::Input
|
|
984
|
+
include ::Octoprint::AutoInitializable
|
|
985
|
+
include ::Octoprint::Deserializable
|
|
986
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
987
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
988
|
+
|
|
989
|
+
def initialize(**kwargs); end
|
|
990
|
+
|
|
991
|
+
def default; end
|
|
992
|
+
def extra; end
|
|
993
|
+
def name; end
|
|
994
|
+
def parameter; end
|
|
995
|
+
def slider; end
|
|
996
|
+
end
|
|
997
|
+
|
|
998
|
+
Octoprint::Printer::EXCLUDABLE_FIELDS = T.let(T.unsafe(nil), Array)
|
|
999
|
+
|
|
1000
|
+
class Octoprint::Printer::ErrorInformation < ::Octoprint::BaseResource
|
|
1001
|
+
include ::Octoprint::AutoInitializable
|
|
1002
|
+
include ::Octoprint::Deserializable
|
|
1003
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1004
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1005
|
+
|
|
1006
|
+
def initialize(**kwargs); end
|
|
1007
|
+
|
|
1008
|
+
def consequence; end
|
|
1009
|
+
def error; end
|
|
1010
|
+
|
|
1011
|
+
sig { returns(T::Boolean) }
|
|
1012
|
+
def error?; end
|
|
1013
|
+
|
|
1014
|
+
def extra; end
|
|
1015
|
+
def faq; end
|
|
1016
|
+
|
|
1017
|
+
sig { returns(T.nilable(::String)) }
|
|
1018
|
+
def faq_url; end
|
|
1019
|
+
|
|
1020
|
+
def logs; end
|
|
1021
|
+
def reason; end
|
|
1022
|
+
|
|
1023
|
+
class << self
|
|
1024
|
+
sig { returns(::Octoprint::Printer::ErrorInformation) }
|
|
1025
|
+
def get; end
|
|
1026
|
+
end
|
|
1027
|
+
end
|
|
1028
|
+
|
|
1029
|
+
Octoprint::Printer::ErrorInformation::FAQ_BASE_URL = T.let(T.unsafe(nil), String)
|
|
1030
|
+
|
|
1031
|
+
module Octoprint::Printer::Heater
|
|
1032
|
+
include ::Octoprint::AutoInitializable
|
|
1033
|
+
include ::Octoprint::Deserializable
|
|
1034
|
+
include ::Octoprint::Printer::TemperatureAttributes
|
|
1035
|
+
|
|
1036
|
+
mixes_in_class_methods ::Octoprint::Printer::Heater::ClassMethods
|
|
1037
|
+
mixes_in_class_methods ::Octoprint::Printer::TemperatureAttributes::ClassMethods
|
|
1038
|
+
mixes_in_class_methods ::Octoprint::AutoInitializable::ClassMethods
|
|
1039
|
+
mixes_in_class_methods ::Octoprint::Deserializable::ClassMethods
|
|
1040
|
+
|
|
1041
|
+
class << self
|
|
1042
|
+
sig { params(base: ::Module).void }
|
|
1043
|
+
def included(base); end
|
|
1044
|
+
end
|
|
1045
|
+
end
|
|
1046
|
+
|
|
1047
|
+
module Octoprint::Printer::Heater::ClassMethods
|
|
1048
|
+
extend T::Generic
|
|
1049
|
+
include ::Octoprint::Printer::HistoryQuery
|
|
1050
|
+
|
|
1051
|
+
has_attached_class!(:out)
|
|
1052
|
+
|
|
1053
|
+
sig { params(command: ::String, options: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
|
|
1054
|
+
def issue_command(command:, options: T.unsafe(nil)); end
|
|
1055
|
+
|
|
1056
|
+
sig { params(offset: ::Numeric).returns(T.untyped) }
|
|
1057
|
+
def offset(offset); end
|
|
1058
|
+
|
|
1059
|
+
sig { params(temperature: ::Numeric).returns(T.untyped) }
|
|
1060
|
+
def target(temperature); end
|
|
1061
|
+
|
|
1062
|
+
sig { params(history: T::Boolean, limit: T.nilable(::Integer)).returns(T.attached_class) }
|
|
1063
|
+
def temperature(history: T.unsafe(nil), limit: T.unsafe(nil)); end
|
|
1064
|
+
|
|
1065
|
+
private
|
|
1066
|
+
|
|
1067
|
+
sig { returns(::Symbol) }
|
|
1068
|
+
def heater_key; end
|
|
1069
|
+
end
|
|
1070
|
+
|
|
1071
|
+
module Octoprint::Printer::HistoryQuery
|
|
1072
|
+
private
|
|
1073
|
+
|
|
1074
|
+
sig { params(history: T::Boolean, limit: T.nilable(::Integer)).returns(T::Hash[::Symbol, T.untyped]) }
|
|
1075
|
+
def history_query(history:, limit:); end
|
|
1076
|
+
end
|
|
1077
|
+
|
|
1078
|
+
class Octoprint::Printer::Printhead < ::Octoprint::BaseResource
|
|
1079
|
+
class << self
|
|
1080
|
+
sig { params(factor: ::Numeric).returns(T.untyped) }
|
|
1081
|
+
def feedrate(factor); end
|
|
1082
|
+
|
|
1083
|
+
sig { params(axes: T::Array[T.any(::String, ::Symbol)]).returns(T.untyped) }
|
|
1084
|
+
def home(axes: T.unsafe(nil)); end
|
|
1085
|
+
|
|
1086
|
+
sig { params(command: ::String, options: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
|
|
1087
|
+
def issue_command(command:, options: T.unsafe(nil)); end
|
|
1088
|
+
|
|
1089
|
+
sig do
|
|
1090
|
+
params(
|
|
1091
|
+
x: T.nilable(::Numeric),
|
|
1092
|
+
y: T.nilable(::Numeric),
|
|
1093
|
+
z: T.nilable(::Numeric),
|
|
1094
|
+
absolute: T.nilable(T::Boolean),
|
|
1095
|
+
speed: T.nilable(T.any(::FalseClass, ::Integer))
|
|
1096
|
+
).returns(T.untyped)
|
|
1097
|
+
end
|
|
1098
|
+
def jog(x: T.unsafe(nil), y: T.unsafe(nil), z: T.unsafe(nil), absolute: T.unsafe(nil), speed: T.unsafe(nil)); end
|
|
1099
|
+
end
|
|
1100
|
+
end
|
|
1101
|
+
|
|
1102
|
+
class Octoprint::Printer::Sd < ::Octoprint::BaseResource
|
|
1103
|
+
include ::Octoprint::AutoInitializable
|
|
1104
|
+
include ::Octoprint::Deserializable
|
|
1105
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1106
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1107
|
+
|
|
1108
|
+
def initialize(**kwargs); end
|
|
1109
|
+
|
|
1110
|
+
def extra; end
|
|
1111
|
+
def ready; end
|
|
1112
|
+
|
|
1113
|
+
class << self
|
|
1114
|
+
sig { returns(::Octoprint::Printer::Sd) }
|
|
1115
|
+
def get; end
|
|
1116
|
+
|
|
1117
|
+
sig { returns(T.untyped) }
|
|
1118
|
+
def init; end
|
|
1119
|
+
|
|
1120
|
+
sig { params(command: ::String).returns(T.untyped) }
|
|
1121
|
+
def issue_command(command:); end
|
|
1122
|
+
|
|
1123
|
+
sig { returns(T.untyped) }
|
|
1124
|
+
def refresh; end
|
|
1125
|
+
|
|
1126
|
+
sig { returns(T.untyped) }
|
|
1127
|
+
def release; end
|
|
1128
|
+
end
|
|
1129
|
+
end
|
|
1130
|
+
|
|
1131
|
+
class Octoprint::Printer::State
|
|
1132
|
+
include ::Octoprint::AutoInitializable
|
|
1133
|
+
include ::Octoprint::Deserializable
|
|
1134
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1135
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1136
|
+
|
|
1137
|
+
def initialize(**kwargs); end
|
|
1138
|
+
|
|
1139
|
+
def error; end
|
|
1140
|
+
def extra; end
|
|
1141
|
+
def flags; end
|
|
1142
|
+
def text; end
|
|
1143
|
+
end
|
|
1144
|
+
|
|
1145
|
+
class Octoprint::Printer::StateFlags
|
|
1146
|
+
include ::Octoprint::AutoInitializable
|
|
1147
|
+
include ::Octoprint::Deserializable
|
|
1148
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1149
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1150
|
+
|
|
1151
|
+
def initialize(**kwargs); end
|
|
1152
|
+
|
|
1153
|
+
def cancelling; end
|
|
1154
|
+
def closed_or_error; end
|
|
1155
|
+
def error; end
|
|
1156
|
+
def extra; end
|
|
1157
|
+
def finishing; end
|
|
1158
|
+
def operational; end
|
|
1159
|
+
def paused; end
|
|
1160
|
+
def pausing; end
|
|
1161
|
+
def printing; end
|
|
1162
|
+
def ready; end
|
|
1163
|
+
def resuming; end
|
|
1164
|
+
def sd_ready; end
|
|
1165
|
+
end
|
|
1166
|
+
|
|
1167
|
+
module Octoprint::Printer::TemperatureAttributes
|
|
1168
|
+
include ::Octoprint::AutoInitializable
|
|
1169
|
+
include ::Octoprint::Deserializable
|
|
1170
|
+
|
|
1171
|
+
mixes_in_class_methods ::Octoprint::Printer::TemperatureAttributes::ClassMethods
|
|
1172
|
+
mixes_in_class_methods ::Octoprint::AutoInitializable::ClassMethods
|
|
1173
|
+
mixes_in_class_methods ::Octoprint::Deserializable::ClassMethods
|
|
1174
|
+
|
|
1175
|
+
class << self
|
|
1176
|
+
sig { params(base: ::Module).void }
|
|
1177
|
+
def included(base); end
|
|
1178
|
+
end
|
|
1179
|
+
end
|
|
1180
|
+
|
|
1181
|
+
module Octoprint::Printer::TemperatureAttributes::ClassMethods
|
|
1182
|
+
sig { params(response: T::Hash[::Symbol, T.untyped], key: ::Symbol).returns(T.untyped) }
|
|
1183
|
+
def from_response(response, key); end
|
|
1184
|
+
end
|
|
1185
|
+
|
|
1186
|
+
class Octoprint::Printer::TemperatureData
|
|
1187
|
+
include ::Octoprint::AutoInitializable
|
|
1188
|
+
include ::Octoprint::Deserializable
|
|
1189
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1190
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1191
|
+
|
|
1192
|
+
def initialize(**kwargs); end
|
|
1193
|
+
|
|
1194
|
+
def actual; end
|
|
1195
|
+
def extra; end
|
|
1196
|
+
def offset; end
|
|
1197
|
+
def target; end
|
|
1198
|
+
|
|
1199
|
+
class << self
|
|
1200
|
+
sig { params(data: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
|
|
1201
|
+
def extract_tools(data); end
|
|
1202
|
+
end
|
|
1203
|
+
end
|
|
1204
|
+
|
|
1205
|
+
Octoprint::Printer::TemperatureData::TOOL_KEY = T.let(T.unsafe(nil), Regexp)
|
|
1206
|
+
|
|
1207
|
+
class Octoprint::Printer::TemperatureDataPoint
|
|
1208
|
+
include ::Octoprint::AutoInitializable
|
|
1209
|
+
include ::Octoprint::Deserializable
|
|
1210
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1211
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1212
|
+
|
|
1213
|
+
def initialize(**kwargs); end
|
|
1214
|
+
|
|
1215
|
+
def bed; end
|
|
1216
|
+
def chamber; end
|
|
1217
|
+
def extra; end
|
|
1218
|
+
|
|
1219
|
+
sig { returns(T.nilable(::Time)) }
|
|
1220
|
+
def recorded_at; end
|
|
1221
|
+
|
|
1222
|
+
def time; end
|
|
1223
|
+
|
|
1224
|
+
sig { params(index: ::Integer).returns(T.nilable(::Octoprint::Printer::TemperatureData)) }
|
|
1225
|
+
def tool(index = T.unsafe(nil)); end
|
|
1226
|
+
|
|
1227
|
+
def tools; end
|
|
1228
|
+
end
|
|
1229
|
+
|
|
1230
|
+
class Octoprint::Printer::TemperatureReading
|
|
1231
|
+
include ::Octoprint::AutoInitializable
|
|
1232
|
+
include ::Octoprint::Deserializable
|
|
1233
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1234
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1235
|
+
|
|
1236
|
+
def initialize(**kwargs); end
|
|
1237
|
+
|
|
1238
|
+
def actual; end
|
|
1239
|
+
def extra; end
|
|
1240
|
+
|
|
1241
|
+
sig { returns(T.nilable(::Time)) }
|
|
1242
|
+
def recorded_at; end
|
|
1243
|
+
|
|
1244
|
+
def target; end
|
|
1245
|
+
def time; end
|
|
1246
|
+
end
|
|
1247
|
+
|
|
1248
|
+
class Octoprint::Printer::TemperatureState
|
|
1249
|
+
include ::Octoprint::AutoInitializable
|
|
1250
|
+
include ::Octoprint::Deserializable
|
|
1251
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1252
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1253
|
+
|
|
1254
|
+
def initialize(**kwargs); end
|
|
1255
|
+
|
|
1256
|
+
def bed; end
|
|
1257
|
+
def chamber; end
|
|
1258
|
+
def extra; end
|
|
1259
|
+
def history; end
|
|
1260
|
+
|
|
1261
|
+
sig { params(index: ::Integer).returns(T.nilable(::Octoprint::Printer::TemperatureData)) }
|
|
1262
|
+
def tool(index = T.unsafe(nil)); end
|
|
1263
|
+
|
|
1264
|
+
def tools; end
|
|
1265
|
+
end
|
|
1266
|
+
|
|
1267
|
+
class Octoprint::Printer::Tool < ::Octoprint::BaseResource
|
|
1268
|
+
include ::Octoprint::Printer::TemperatureAttributes
|
|
1269
|
+
include ::Octoprint::AutoInitializable
|
|
1270
|
+
include ::Octoprint::Deserializable
|
|
1271
|
+
extend ::Octoprint::Printer::HistoryQuery
|
|
1272
|
+
extend ::Octoprint::Printer::TemperatureAttributes::ClassMethods
|
|
1273
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1274
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1275
|
+
|
|
1276
|
+
def initialize(**kwargs); end
|
|
1277
|
+
|
|
1278
|
+
def actual; end
|
|
1279
|
+
def extra; end
|
|
1280
|
+
def history; end
|
|
1281
|
+
def offset; end
|
|
1282
|
+
def target; end
|
|
1283
|
+
|
|
1284
|
+
class << self
|
|
1285
|
+
sig { params(amount: ::Numeric, speed: T.nilable(::Integer)).returns(T.untyped) }
|
|
1286
|
+
def extrude(amount, speed: T.unsafe(nil)); end
|
|
1287
|
+
|
|
1288
|
+
sig { params(factor: ::Numeric).returns(T.untyped) }
|
|
1289
|
+
def flowrate(factor); end
|
|
1290
|
+
|
|
1291
|
+
sig { params(command: ::String, options: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
|
|
1292
|
+
def issue_command(command:, options: T.unsafe(nil)); end
|
|
1293
|
+
|
|
1294
|
+
sig { params(offsets: T::Hash[T.any(::String, ::Symbol), ::Numeric]).returns(T.untyped) }
|
|
1295
|
+
def offset(offsets); end
|
|
1296
|
+
|
|
1297
|
+
sig { params(tool: T.any(::String, ::Symbol)).returns(T.untyped) }
|
|
1298
|
+
def select_tool(tool); end
|
|
1299
|
+
|
|
1300
|
+
sig { params(targets: T::Hash[T.any(::String, ::Symbol), ::Numeric]).returns(T.untyped) }
|
|
1301
|
+
def target(targets); end
|
|
1302
|
+
|
|
1303
|
+
sig { params(history: T::Boolean, limit: T.nilable(::Integer)).returns(T::Array[::Octoprint::Printer::Tool]) }
|
|
1304
|
+
def temperatures(history: T.unsafe(nil), limit: T.unsafe(nil)); end
|
|
1305
|
+
end
|
|
1306
|
+
end
|
|
1307
|
+
|
|
1308
|
+
class Octoprint::PrinterProfiles < ::Octoprint::BaseResource
|
|
1309
|
+
include ::Octoprint::AutoInitializable
|
|
1310
|
+
include ::Octoprint::Deserializable
|
|
1311
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1312
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1313
|
+
|
|
1314
|
+
def initialize(**kwargs); end
|
|
1315
|
+
|
|
1316
|
+
def extra; end
|
|
1317
|
+
def profiles; end
|
|
1318
|
+
|
|
1319
|
+
class << self
|
|
1320
|
+
sig do
|
|
1321
|
+
params(
|
|
1322
|
+
profile: T::Hash[::Symbol, T.untyped],
|
|
1323
|
+
based_on: T.nilable(::String)
|
|
1324
|
+
).returns(::Octoprint::PrinterProfiles::PrinterProfile)
|
|
1325
|
+
end
|
|
1326
|
+
def create(profile:, based_on: T.unsafe(nil)); end
|
|
1327
|
+
|
|
1328
|
+
sig { params(identifier: ::String).returns(T.untyped) }
|
|
1329
|
+
def delete_profile(identifier:); end
|
|
1330
|
+
|
|
1331
|
+
sig { params(identifier: ::String).returns(::Octoprint::PrinterProfiles::PrinterProfile) }
|
|
1332
|
+
def get(identifier:); end
|
|
1333
|
+
|
|
1334
|
+
sig { returns(::Octoprint::PrinterProfiles) }
|
|
1335
|
+
def list; end
|
|
1336
|
+
|
|
1337
|
+
sig do
|
|
1338
|
+
params(
|
|
1339
|
+
identifier: ::String,
|
|
1340
|
+
profile: T::Hash[::Symbol, T.untyped]
|
|
1341
|
+
).returns(::Octoprint::PrinterProfiles::PrinterProfile)
|
|
1342
|
+
end
|
|
1343
|
+
def update(identifier:, profile:); end
|
|
1344
|
+
|
|
1345
|
+
private
|
|
1346
|
+
|
|
1347
|
+
sig do
|
|
1348
|
+
params(
|
|
1349
|
+
path: ::String,
|
|
1350
|
+
params: T::Hash[::Symbol, T.untyped],
|
|
1351
|
+
headers: T::Hash[::Symbol, T.untyped],
|
|
1352
|
+
options: T::Hash[::Symbol, T.untyped]
|
|
1353
|
+
).returns(T.untyped)
|
|
1354
|
+
end
|
|
1355
|
+
def patch(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
|
|
1356
|
+
end
|
|
1357
|
+
end
|
|
1358
|
+
|
|
1359
|
+
class Octoprint::PrinterProfiles::PrinterProfile
|
|
1360
|
+
include ::Octoprint::Deserializable
|
|
1361
|
+
include ::Octoprint::AutoInitializable
|
|
1362
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1363
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1364
|
+
|
|
1365
|
+
def initialize(**kwargs); end
|
|
1366
|
+
|
|
1367
|
+
def axes; end
|
|
1368
|
+
def color; end
|
|
1369
|
+
def current; end
|
|
1370
|
+
def default; end
|
|
1371
|
+
def extra; end
|
|
1372
|
+
def extruder; end
|
|
1373
|
+
def heated_bed; end
|
|
1374
|
+
def heated_chamber; end
|
|
1375
|
+
def id; end
|
|
1376
|
+
def model; end
|
|
1377
|
+
def name; end
|
|
1378
|
+
def resource; end
|
|
1379
|
+
def volume; end
|
|
1380
|
+
end
|
|
1381
|
+
|
|
1382
|
+
class Octoprint::ServerInformation < ::Octoprint::BaseResource
|
|
1383
|
+
include ::Octoprint::AutoInitializable
|
|
1384
|
+
include ::Octoprint::Deserializable
|
|
1385
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1386
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1387
|
+
|
|
1388
|
+
def initialize(**kwargs); end
|
|
1389
|
+
|
|
1390
|
+
def extra; end
|
|
1391
|
+
def safemode; end
|
|
1392
|
+
def version; end
|
|
1393
|
+
|
|
1394
|
+
class << self
|
|
1395
|
+
sig { returns(::Octoprint::ServerInformation) }
|
|
1396
|
+
def get; end
|
|
1397
|
+
end
|
|
1398
|
+
end
|
|
1399
|
+
|
|
1400
|
+
class Octoprint::ServerVersion < ::Octoprint::BaseResource
|
|
1401
|
+
include ::Octoprint::AutoInitializable
|
|
1402
|
+
include ::Octoprint::Deserializable
|
|
1403
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1404
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1405
|
+
|
|
1406
|
+
def initialize(**kwargs); end
|
|
1407
|
+
|
|
1408
|
+
def api; end
|
|
1409
|
+
def extra; end
|
|
1410
|
+
def server; end
|
|
1411
|
+
def text; end
|
|
1412
|
+
|
|
1413
|
+
class << self
|
|
1414
|
+
sig { returns(::Octoprint::ServerVersion) }
|
|
1415
|
+
def get; end
|
|
1416
|
+
end
|
|
1417
|
+
end
|
|
1418
|
+
|
|
1419
|
+
class Octoprint::Settings < ::Octoprint::BaseResource
|
|
1420
|
+
class << self
|
|
1421
|
+
sig { returns(T::Hash[::Symbol, T.untyped]) }
|
|
1422
|
+
def fetch_templates; end
|
|
1423
|
+
|
|
1424
|
+
sig { returns(T::Hash[::Symbol, T.untyped]) }
|
|
1425
|
+
def get; end
|
|
1426
|
+
|
|
1427
|
+
sig { returns(T::Hash[::Symbol, ::String]) }
|
|
1428
|
+
def regenerate_api_key; end
|
|
1429
|
+
|
|
1430
|
+
sig { params(settings: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
|
|
1431
|
+
def save(settings); end
|
|
1432
|
+
|
|
1433
|
+
sig { returns(::Octoprint::Settings::Webcam) }
|
|
1434
|
+
def webcam; end
|
|
1435
|
+
end
|
|
1436
|
+
end
|
|
1437
|
+
|
|
1438
|
+
class Octoprint::Settings::Webcam
|
|
1439
|
+
include ::Octoprint::AutoInitializable
|
|
1440
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1441
|
+
|
|
1442
|
+
def initialize(**kwargs); end
|
|
1443
|
+
|
|
1444
|
+
def display_name; end
|
|
1445
|
+
def enabled; end
|
|
1446
|
+
def flip_h; end
|
|
1447
|
+
def flip_v; end
|
|
1448
|
+
def name; end
|
|
1449
|
+
def rotate90; end
|
|
1450
|
+
def snapshot_url; end
|
|
1451
|
+
def stream_ratio; end
|
|
1452
|
+
def stream_url; end
|
|
1453
|
+
|
|
1454
|
+
class << self
|
|
1455
|
+
sig { params(settings: T::Hash[::Symbol, T.untyped]).returns(::Octoprint::Settings::Webcam) }
|
|
1456
|
+
def from_settings(settings); end
|
|
1457
|
+
|
|
1458
|
+
private
|
|
1459
|
+
|
|
1460
|
+
sig { params(legacy: T::Hash[::Symbol, T.untyped]).returns(T.nilable(T::Hash[::Symbol, T.untyped])) }
|
|
1461
|
+
def default_webcam(legacy); end
|
|
1462
|
+
|
|
1463
|
+
sig { params(legacy: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
|
|
1464
|
+
def legacy_attributes(legacy); end
|
|
1465
|
+
|
|
1466
|
+
sig { params(camera: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
|
|
1467
|
+
def webcam_attributes(camera); end
|
|
1468
|
+
end
|
|
1469
|
+
end
|
|
1470
|
+
|
|
1471
|
+
class Octoprint::Slicing < ::Octoprint::BaseResource
|
|
1472
|
+
class << self
|
|
1473
|
+
sig do
|
|
1474
|
+
params(
|
|
1475
|
+
slicer: ::String,
|
|
1476
|
+
key: ::String,
|
|
1477
|
+
data: T::Hash[T.any(::String, ::Symbol), T.untyped],
|
|
1478
|
+
display_name: T.nilable(::String),
|
|
1479
|
+
description: T.nilable(::String)
|
|
1480
|
+
).returns(::Octoprint::Slicing::Profile)
|
|
1481
|
+
end
|
|
1482
|
+
def add_profile(slicer:, key:, data: T.unsafe(nil), display_name: T.unsafe(nil), description: T.unsafe(nil)); end
|
|
1483
|
+
|
|
1484
|
+
sig { params(slicer: ::String, key: ::String).returns(::TrueClass) }
|
|
1485
|
+
def delete_profile(slicer:, key:); end
|
|
1486
|
+
|
|
1487
|
+
sig do
|
|
1488
|
+
params(
|
|
1489
|
+
profiles_data: T.nilable(T::Hash[::Symbol, T.untyped])
|
|
1490
|
+
).returns(T::Hash[::Symbol, ::Octoprint::Slicing::Profile])
|
|
1491
|
+
end
|
|
1492
|
+
def deserialize_profiles(profiles_data); end
|
|
1493
|
+
|
|
1494
|
+
sig { params(slicer: ::String, key: ::String).returns(::Octoprint::Slicing::Profile) }
|
|
1495
|
+
def get_profile(slicer:, key:); end
|
|
1496
|
+
|
|
1497
|
+
sig { params(configured: T::Boolean).returns(T::Hash[::Symbol, ::Octoprint::Slicing::Slicer]) }
|
|
1498
|
+
def list(configured: T.unsafe(nil)); end
|
|
1499
|
+
|
|
1500
|
+
sig { params(slicer: ::String, configured: T::Boolean).returns(T::Hash[::Symbol, ::Octoprint::Slicing::Profile]) }
|
|
1501
|
+
def profiles(slicer:, configured: T.unsafe(nil)); end
|
|
1502
|
+
|
|
1503
|
+
sig do
|
|
1504
|
+
params(
|
|
1505
|
+
slicer: ::String,
|
|
1506
|
+
key: ::String,
|
|
1507
|
+
data: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped]),
|
|
1508
|
+
display_name: T.nilable(::String),
|
|
1509
|
+
description: T.nilable(::String),
|
|
1510
|
+
default: T.nilable(T::Boolean)
|
|
1511
|
+
).returns(::Octoprint::Slicing::Profile)
|
|
1512
|
+
end
|
|
1513
|
+
def update_profile(slicer:, key:, data: T.unsafe(nil), display_name: T.unsafe(nil), description: T.unsafe(nil), default: T.unsafe(nil)); end
|
|
1514
|
+
|
|
1515
|
+
private
|
|
1516
|
+
|
|
1517
|
+
sig { params(configured: T::Boolean).returns(T::Hash[::Symbol, T::Boolean]) }
|
|
1518
|
+
def configured_option(configured); end
|
|
1519
|
+
|
|
1520
|
+
sig { params(slicer: ::String, key: ::String).returns(::String) }
|
|
1521
|
+
def profile_path(slicer, key); end
|
|
1522
|
+
|
|
1523
|
+
sig { params(slicer: ::String, key: ::String).returns(::String) }
|
|
1524
|
+
def profile_subpath(slicer, key); end
|
|
1525
|
+
|
|
1526
|
+
sig { params(slicer: ::String).returns(::String) }
|
|
1527
|
+
def profiles_path(slicer); end
|
|
1528
|
+
end
|
|
1529
|
+
end
|
|
1530
|
+
|
|
1531
|
+
class Octoprint::Slicing::Profile
|
|
1532
|
+
include ::Octoprint::Deserializable
|
|
1533
|
+
include ::Octoprint::AutoInitializable
|
|
1534
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1535
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1536
|
+
|
|
1537
|
+
def initialize(**kwargs); end
|
|
1538
|
+
|
|
1539
|
+
def data; end
|
|
1540
|
+
def default; end
|
|
1541
|
+
|
|
1542
|
+
sig { returns(T::Boolean) }
|
|
1543
|
+
def default?; end
|
|
1544
|
+
|
|
1545
|
+
def description; end
|
|
1546
|
+
def display_name; end
|
|
1547
|
+
def extra; end
|
|
1548
|
+
def key; end
|
|
1549
|
+
def resource; end
|
|
1550
|
+
end
|
|
1551
|
+
|
|
1552
|
+
class Octoprint::Slicing::Slicer
|
|
1553
|
+
include ::Octoprint::Deserializable
|
|
1554
|
+
include ::Octoprint::AutoInitializable
|
|
1555
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1556
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1557
|
+
|
|
1558
|
+
def initialize(**kwargs); end
|
|
1559
|
+
|
|
1560
|
+
def configured; end
|
|
1561
|
+
|
|
1562
|
+
sig { returns(T::Boolean) }
|
|
1563
|
+
def configured?; end
|
|
1564
|
+
|
|
1565
|
+
def default; end
|
|
1566
|
+
|
|
1567
|
+
sig { returns(T::Boolean) }
|
|
1568
|
+
def default?; end
|
|
1569
|
+
|
|
1570
|
+
def display_name; end
|
|
1571
|
+
def extensions; end
|
|
1572
|
+
def extra; end
|
|
1573
|
+
def key; end
|
|
1574
|
+
def profiles; end
|
|
1575
|
+
def same_device; end
|
|
1576
|
+
end
|
|
1577
|
+
|
|
1578
|
+
class Octoprint::SystemCommands < ::Octoprint::BaseResource
|
|
1579
|
+
include ::Octoprint::Deserializable
|
|
1580
|
+
include ::Octoprint::AutoInitializable
|
|
1581
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1582
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1583
|
+
|
|
1584
|
+
def initialize(**kwargs); end
|
|
1585
|
+
|
|
1586
|
+
def core; end
|
|
1587
|
+
def custom; end
|
|
1588
|
+
def extra; end
|
|
1589
|
+
|
|
1590
|
+
class << self
|
|
1591
|
+
sig { params(source: ::String, action: ::String).returns(T::Boolean) }
|
|
1592
|
+
def execute(source, action); end
|
|
1593
|
+
|
|
1594
|
+
sig { returns(::Octoprint::SystemCommands) }
|
|
1595
|
+
def list; end
|
|
1596
|
+
|
|
1597
|
+
sig { params(source: ::String).returns(T::Array[::Octoprint::SystemCommands::Command]) }
|
|
1598
|
+
def list_by_source(source); end
|
|
1599
|
+
end
|
|
1600
|
+
end
|
|
1601
|
+
|
|
1602
|
+
class Octoprint::SystemCommands::Command
|
|
1603
|
+
include ::Octoprint::Deserializable
|
|
1604
|
+
include ::Octoprint::AutoInitializable
|
|
1605
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1606
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1607
|
+
|
|
1608
|
+
def initialize(**kwargs); end
|
|
1609
|
+
|
|
1610
|
+
def action; end
|
|
1611
|
+
def confirm; end
|
|
1612
|
+
def extra; end
|
|
1613
|
+
def name; end
|
|
1614
|
+
def resource; end
|
|
1615
|
+
def source; end
|
|
1616
|
+
end
|
|
1617
|
+
|
|
1618
|
+
class Octoprint::Timelapse < ::Octoprint::BaseResource
|
|
1619
|
+
include ::Octoprint::AutoInitializable
|
|
1620
|
+
include ::Octoprint::Deserializable
|
|
1621
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1622
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1623
|
+
|
|
1624
|
+
def initialize(**kwargs); end
|
|
1625
|
+
|
|
1626
|
+
def config; end
|
|
1627
|
+
def enabled; end
|
|
1628
|
+
def extra; end
|
|
1629
|
+
def files; end
|
|
1630
|
+
def unrendered; end
|
|
1631
|
+
|
|
1632
|
+
class << self
|
|
1633
|
+
sig { params(filename: ::String, unrendered: T::Boolean).returns(::Octoprint::Timelapse) }
|
|
1634
|
+
def delete_file(filename:, unrendered: T.unsafe(nil)); end
|
|
1635
|
+
|
|
1636
|
+
sig { params(name: ::String).returns(T.untyped) }
|
|
1637
|
+
def delete_unrendered(name:); end
|
|
1638
|
+
|
|
1639
|
+
sig { params(unrendered: T::Boolean, force: T::Boolean).returns(::Octoprint::Timelapse) }
|
|
1640
|
+
def get(unrendered: T.unsafe(nil), force: T.unsafe(nil)); end
|
|
1641
|
+
|
|
1642
|
+
sig { params(name: ::String, command: ::String).returns(T.untyped) }
|
|
1643
|
+
def issue_unrendered_command(name:, command:); end
|
|
1644
|
+
|
|
1645
|
+
sig { params(name: ::String).returns(T.untyped) }
|
|
1646
|
+
def render(name:); end
|
|
1647
|
+
|
|
1648
|
+
sig do
|
|
1649
|
+
params(
|
|
1650
|
+
type: ::String,
|
|
1651
|
+
post_roll: T.nilable(::Integer),
|
|
1652
|
+
fps: T.nilable(::Integer),
|
|
1653
|
+
interval: T.nilable(::Integer),
|
|
1654
|
+
retraction_z_hop: T.nilable(::Numeric),
|
|
1655
|
+
min_delay: T.nilable(::Numeric),
|
|
1656
|
+
render_after_print: T.nilable(::String),
|
|
1657
|
+
save: T::Boolean,
|
|
1658
|
+
unrendered: T::Boolean
|
|
1659
|
+
).returns(::Octoprint::Timelapse)
|
|
1660
|
+
end
|
|
1661
|
+
def update_config(type:, post_roll: T.unsafe(nil), fps: T.unsafe(nil), interval: T.unsafe(nil), retraction_z_hop: T.unsafe(nil), min_delay: T.unsafe(nil), render_after_print: T.unsafe(nil), save: T.unsafe(nil), unrendered: T.unsafe(nil)); end
|
|
1662
|
+
|
|
1663
|
+
private
|
|
1664
|
+
|
|
1665
|
+
sig { params(name: ::String).returns(::String) }
|
|
1666
|
+
def escape(name); end
|
|
1667
|
+
|
|
1668
|
+
sig { params(flags: T::Boolean).returns(T::Hash[::Symbol, T::Boolean]) }
|
|
1669
|
+
def query(**flags); end
|
|
1670
|
+
|
|
1671
|
+
sig { params(path: ::String, options: T::Hash[::Symbol, T.untyped]).returns(::String) }
|
|
1672
|
+
def with_query(path, options); end
|
|
1673
|
+
end
|
|
1674
|
+
end
|
|
1675
|
+
|
|
1676
|
+
class Octoprint::Timelapse::Config
|
|
1677
|
+
include ::Octoprint::AutoInitializable
|
|
1678
|
+
include ::Octoprint::Deserializable
|
|
1679
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1680
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1681
|
+
|
|
1682
|
+
def initialize(**kwargs); end
|
|
1683
|
+
|
|
1684
|
+
def extra; end
|
|
1685
|
+
def fps; end
|
|
1686
|
+
def interval; end
|
|
1687
|
+
def min_delay; end
|
|
1688
|
+
|
|
1689
|
+
sig { returns(T::Boolean) }
|
|
1690
|
+
def off?; end
|
|
1691
|
+
|
|
1692
|
+
def post_roll; end
|
|
1693
|
+
def render_after_print; end
|
|
1694
|
+
def retraction_z_hop; end
|
|
1695
|
+
def type; end
|
|
1696
|
+
end
|
|
1697
|
+
|
|
1698
|
+
module Octoprint::Timelapse::FileAttributes
|
|
1699
|
+
include ::Octoprint::AutoInitializable
|
|
1700
|
+
include ::Octoprint::Deserializable
|
|
1701
|
+
|
|
1702
|
+
mixes_in_class_methods ::Octoprint::AutoInitializable::ClassMethods
|
|
1703
|
+
mixes_in_class_methods ::Octoprint::Deserializable::ClassMethods
|
|
1704
|
+
|
|
1705
|
+
class << self
|
|
1706
|
+
sig { params(base: ::Module).void }
|
|
1707
|
+
def included(base); end
|
|
1708
|
+
end
|
|
1709
|
+
end
|
|
1710
|
+
|
|
1711
|
+
class Octoprint::Timelapse::Rendered
|
|
1712
|
+
include ::Octoprint::AutoInitializable
|
|
1713
|
+
include ::Octoprint::Deserializable
|
|
1714
|
+
include ::Octoprint::Timelapse::FileAttributes
|
|
1715
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1716
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1717
|
+
|
|
1718
|
+
def initialize(**kwargs); end
|
|
1719
|
+
|
|
1720
|
+
def bytes; end
|
|
1721
|
+
def date; end
|
|
1722
|
+
def extra; end
|
|
1723
|
+
|
|
1724
|
+
sig { returns(T.nilable(::Time)) }
|
|
1725
|
+
def modification_time; end
|
|
1726
|
+
|
|
1727
|
+
def name; end
|
|
1728
|
+
def size; end
|
|
1729
|
+
def thumbnail; end
|
|
1730
|
+
def timestamp; end
|
|
1731
|
+
def url; end
|
|
1732
|
+
end
|
|
1733
|
+
|
|
1734
|
+
Octoprint::Timelapse::TYPES = T.let(T.unsafe(nil), Array)
|
|
1735
|
+
|
|
1736
|
+
class Octoprint::Timelapse::Unrendered
|
|
1737
|
+
include ::Octoprint::AutoInitializable
|
|
1738
|
+
include ::Octoprint::Deserializable
|
|
1739
|
+
include ::Octoprint::Timelapse::FileAttributes
|
|
1740
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1741
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1742
|
+
|
|
1743
|
+
def initialize(**kwargs); end
|
|
1744
|
+
|
|
1745
|
+
def bytes; end
|
|
1746
|
+
def count; end
|
|
1747
|
+
def date; end
|
|
1748
|
+
def extra; end
|
|
1749
|
+
def name; end
|
|
1750
|
+
def processing; end
|
|
1751
|
+
def recording; end
|
|
1752
|
+
def rendering; end
|
|
1753
|
+
def size; end
|
|
1754
|
+
end
|
|
1755
|
+
|
|
1756
|
+
module Octoprint::Types; end
|
|
1757
|
+
Octoprint::Types::BaudRate = Integer
|
|
1758
|
+
Octoprint::Types::BedTemperature = Float
|
|
1759
|
+
Octoprint::Types::ConnectionState = String
|
|
1760
|
+
Octoprint::Types::ExtruderCount = Integer
|
|
1761
|
+
Octoprint::Types::FilePath = String
|
|
1762
|
+
Octoprint::Types::FileSize = Integer
|
|
1763
|
+
Octoprint::Types::Hostname = String
|
|
1764
|
+
Octoprint::Types::Iso8601String = String
|
|
1765
|
+
Octoprint::Types::JobState = String
|
|
1766
|
+
Octoprint::Types::Port = Integer
|
|
1767
|
+
Octoprint::Types::PrintTime = Integer
|
|
1768
|
+
Octoprint::Types::PrinterId = String
|
|
1769
|
+
Octoprint::Types::ProgressPercent = Float
|
|
1770
|
+
Octoprint::Types::SerialPort = String
|
|
1771
|
+
Octoprint::Types::UnixTimestamp = Integer
|
|
1772
|
+
Octoprint::Types::Url = String
|
|
1773
|
+
Octoprint::User = Octoprint::Access::User
|
|
1774
|
+
|
|
1775
|
+
class Octoprint::Util < ::Octoprint::BaseResource
|
|
1776
|
+
include ::Octoprint::AutoInitializable
|
|
1777
|
+
include ::Octoprint::Deserializable
|
|
1778
|
+
extend ::Octoprint::AutoInitializable::ClassMethods
|
|
1779
|
+
extend ::Octoprint::Deserializable::ClassMethods
|
|
1780
|
+
|
|
1781
|
+
def initialize(**kwargs); end
|
|
1782
|
+
|
|
1783
|
+
def exists; end
|
|
1784
|
+
def extra; end
|
|
1785
|
+
def result; end
|
|
1786
|
+
def status; end
|
|
1787
|
+
|
|
1788
|
+
class << self
|
|
1789
|
+
sig { params(address: T.nilable(::String)).returns(::Octoprint::Util) }
|
|
1790
|
+
def test_address(address: T.unsafe(nil)); end
|
|
1791
|
+
|
|
1792
|
+
sig do
|
|
1793
|
+
params(
|
|
1794
|
+
path: ::String,
|
|
1795
|
+
check_type: T.nilable(::String),
|
|
1796
|
+
check_access: T.nilable(::String),
|
|
1797
|
+
allow_create_dir: T.nilable(T::Boolean),
|
|
1798
|
+
check_writable_dir: T.nilable(T::Boolean)
|
|
1799
|
+
).returns(::Octoprint::Util)
|
|
1800
|
+
end
|
|
1801
|
+
def test_path(path:, check_type: T.unsafe(nil), check_access: T.unsafe(nil), allow_create_dir: T.unsafe(nil), check_writable_dir: T.unsafe(nil)); end
|
|
1802
|
+
|
|
1803
|
+
sig { params(name: ::String).returns(::Octoprint::Util) }
|
|
1804
|
+
def test_resolution(name:); end
|
|
1805
|
+
|
|
1806
|
+
sig do
|
|
1807
|
+
params(
|
|
1808
|
+
host: ::String,
|
|
1809
|
+
port: ::Integer,
|
|
1810
|
+
protocol: T.nilable(::String),
|
|
1811
|
+
timeout: T.nilable(::Float)
|
|
1812
|
+
).returns(::Octoprint::Util)
|
|
1813
|
+
end
|
|
1814
|
+
def test_server(host:, port:, protocol: T.unsafe(nil), timeout: T.unsafe(nil)); end
|
|
1815
|
+
|
|
1816
|
+
sig do
|
|
1817
|
+
params(
|
|
1818
|
+
url: ::String,
|
|
1819
|
+
method: T.nilable(::String),
|
|
1820
|
+
timeout: T.nilable(::Integer),
|
|
1821
|
+
status: T.nilable(::Integer),
|
|
1822
|
+
auth_user: T.nilable(::String),
|
|
1823
|
+
auth_pass: T.nilable(::String),
|
|
1824
|
+
auth_digest: T.nilable(::String),
|
|
1825
|
+
auth_bearer: T.nilable(::String),
|
|
1826
|
+
content_type_whitelist: T.nilable(::String),
|
|
1827
|
+
content_type_blacklist: T.nilable(::String)
|
|
1828
|
+
).returns(::Octoprint::Util)
|
|
1829
|
+
end
|
|
1830
|
+
def test_url(url:, method: T.unsafe(nil), timeout: T.unsafe(nil), status: T.unsafe(nil), auth_user: T.unsafe(nil), auth_pass: T.unsafe(nil), auth_digest: T.unsafe(nil), auth_bearer: T.unsafe(nil), content_type_whitelist: T.unsafe(nil), content_type_blacklist: T.unsafe(nil)); end
|
|
1831
|
+
|
|
1832
|
+
private
|
|
1833
|
+
|
|
1834
|
+
def build_url_test_params(url, options); end
|
|
1835
|
+
end
|
|
1836
|
+
end
|
|
1837
|
+
|
|
1838
|
+
Octoprint::VERSION = T.let(T.unsafe(nil), String)
|
|
1839
|
+
|
|
1840
|
+
class Octoprint::Wizard < ::Octoprint::BaseResource
|
|
1841
|
+
class << self
|
|
1842
|
+
sig { params(handled: T::Array[::String]).returns(T.untyped) }
|
|
1843
|
+
def finish(handled:); end
|
|
1844
|
+
|
|
1845
|
+
sig { returns(T::Hash[::Symbol, T.untyped]) }
|
|
1846
|
+
def get; end
|
|
1847
|
+
end
|
|
1848
|
+
end
|