ScriptCollection 4.4.9__py3-none-any.whl → 4.4.11__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.
@@ -39,7 +39,7 @@ from .ProgramRunnerBase import ProgramRunnerBase
39
39
  from .ProgramRunnerPopen import ProgramRunnerPopen
40
40
  from .SCLog import SCLog, LogLevel
41
41
 
42
- version = "4.4.9"
42
+ version = "4.4.11"
43
43
  __version__ = version
44
44
 
45
45
  class VSCodeWorkspaceShellTask:
@@ -164,45 +164,49 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
164
164
  return value
165
165
 
166
166
  @GeneralUtilities.check_arguments
167
- def __get_lock_file_name(self, runtime: str) -> str:
168
- """Returns the name of the lock-file which belongs to the given runtime.
167
+ def __get_lock_file_name(self) -> str:
168
+ """Returns the name of the lock-file of a project.
169
169
 
170
- Every runtime needs its own lock-file: the lock-file records the set of runtime-identifiers it was created for, and a
171
- restore in locked mode fails with NU1004 when that set differs from the one which is currently restored (the restore
172
- gets exactly one runtime via "--runtime"). The name is relative, so NuGet resolves it per project - a restore over the
173
- solution therefore creates one lock-file next to each of the two project-files instead of letting them collide."""
174
- return f"packages.{runtime}.lock.json"
170
+ There is exactly one, and it carries the name nuget uses on its own. A codeunit is built for more than one runtime, but
171
+ the runtime is not part of the restore anymore: the projects state their runtimes (see
172
+ __assert_projects_state_their_runtimes), so one restore resolves all of them and writes one lock-file which knows all of
173
+ them. Every operation - the build, the linting, the testcases, the reference, and a developer who builds in an ide -
174
+ therefore reads and writes the same file, and none of them has to be kept away from it."""
175
+ return "packages.lock.json"
175
176
 
176
177
  @GeneralUtilities.check_arguments
177
- def __get_lock_file_arguments(self, codeunit_folder: str, codeunit_name: str, runtime: str) -> list[str]:
178
- """Returns the restore-arguments which pin the dependencies of the given runtime to the content of its lock-files.
178
+ def __get_lock_file_arguments(self, codeunit_folder: str, codeunit_name: str) -> list[str]:
179
+ """Returns the restore-arguments which pin the dependencies of a codeunit to the content of its lock-files.
179
180
 
180
181
  Locked mode is only requested when the lock-file of every project of the codeunit already exists, because a restore in
181
182
  locked mode can not create one. A codeunit which does not have them yet is restored without it and gets a warning, so
182
183
  introducing the lock-files does not break the build of a codeunit which was not migrated yet."""
183
- lock_file_name: str = self.__get_lock_file_name(runtime)
184
+ lock_file_name: str = self.__get_lock_file_name()
184
185
  expected_lock_files: list[str] = [os.path.join(codeunit_folder, project_name, lock_file_name) for project_name in [codeunit_name, codeunit_name+"Tests"]]
185
186
  missing_lock_files: list[str] = [lock_file for lock_file in expected_lock_files if not os.path.isfile(lock_file)]
186
- result: list[str] = [f"-p:NuGetLockFilePath={lock_file_name}"]
187
+ result: list[str] = []
187
188
  if len(missing_lock_files) == 0:
188
189
  result.append("--locked-mode")
189
190
  else:
190
- self._protected_sc.log.log(f"The dependencies of codeunit \"{codeunit_name}\" are not restored in locked mode for the runtime \"{runtime}\", because the following lock-file(s) do not exist yet: {', '.join(missing_lock_files)}. The restore creates them now; commit them so that the dependencies of this codeunit are pinned.", LogLevel.Warning)
191
+ self._protected_sc.log.log(f"The dependencies of codeunit \"{codeunit_name}\" are not restored in locked mode, because the following lock-file(s) do not exist yet: {', '.join(missing_lock_files)}. The restore creates them now; commit them so that the dependencies of this codeunit are pinned.", LogLevel.Warning)
191
192
  return result
192
193
 
193
194
  @GeneralUtilities.check_arguments
194
- def __get_arguments_which_prevent_writing_a_lock_file(self) -> list[str]:
195
- """Returns the arguments which keep a dotnet-operation from writing a lock-file.
195
+ def __assert_projects_state_their_runtimes(self, csproj_file: str, runtimes: list[str]) -> None:
196
+ """Ensures that the given project states the runtimes it is built for.
196
197
 
197
- The lock-files belong to the restore of the build alone, because only there the runtime - and with it the name of the
198
- lock-file which belongs to that runtime - is known. Every other dotnet-operation of a codeunit (linting, test, ...)
199
- works on the solution instead of on one runtime and restores implicitly, and the csproj-property
200
- "RestorePackagesWithLockFile" would make each of those restores write a lock-file under the default-name. Such a file
201
- is never validated against anything, because locked mode is only requested for the runtime-specific one, so it would
202
- only be an additional file which looks like the relevant pinning without being it. The value has to be passed on the
203
- command-line because a property which the project-file sets explicitly wins over one which comes from the
204
- environment."""
205
- return ["-p:RestorePackagesWithLockFile=false"]
198
+ The build restores once without naming a runtime and builds each runtime from that result, so the project has to state
199
+ its runtimes itself - a restore which does not know them resolves no dependencies for them, and the build of the first
200
+ runtime fails with NETSDK1047, which names the assets-file and not the missing declaration. It is checked here instead,
201
+ where the reason and the remedy can be stated."""
202
+ content: str = GeneralUtilities.read_text_from_file(csproj_file)
203
+ declared_runtimes: list[str] = re.findall(r"<RuntimeIdentifiers>([^<]*)</RuntimeIdentifiers>", content)
204
+ declared: set[str] = set()
205
+ for entry in declared_runtimes:
206
+ declared.update([runtime.strip() for runtime in entry.split(";") if 0 < len(runtime.strip())])
207
+ missing: list[str] = [runtime for runtime in runtimes if runtime not in declared]
208
+ if 0 < len(missing):
209
+ raise ValueError(f"The project \"{csproj_file}\" is built for the runtime(s) {', '.join(missing)}, but does not state them. Add \"<RuntimeIdentifiers>{';'.join(runtimes)}</RuntimeIdentifiers>\" to the project-file, so that the restore of the codeunit resolves the dependencies of these runtimes.")
206
210
 
207
211
  @GeneralUtilities.check_arguments
208
212
  def __standardized_tasks_build_for_dotnet_build(self, csproj_file: str, originaloutputfolder: str, files_to_sign: dict[str, str], commitid: str, runtimes: list[str], target_environmenttype_mapping: dict[str, str], copy_license_file_to_target_folder: bool, repository_folder: str, codeunit_name: str) -> None:
@@ -218,13 +222,17 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
218
222
  GeneralUtilities.ensure_directory_exists(sarif_folder)
219
223
  gitkeep_file = os.path.join(sarif_folder, ".gitkeep")
220
224
  GeneralUtilities.ensure_file_exists(gitkeep_file)
225
+ self.__assert_projects_state_their_runtimes(csproj_file, runtimes)
226
+ # One restore for all runtimes, before the first of them is built: the projects state their runtimes, so this restore
227
+ # resolves the dependencies of every one of them and writes one lock-file which knows them all. A restore per runtime
228
+ # ("--runtime") would narrow the project to that one runtime and contradict that file with NU1004.
229
+ GeneralUtilities.ensure_directory_does_not_exist(os.path.join(csproj_file_folder, "obj"))
230
+ self._protected_sc.run_program("dotnet", "clean", csproj_file_folder)
231
+ self._protected_sc.run_program_argsasarray("dotnet", ["restore"]+self.__get_lock_file_arguments(codeunit_folder, codeunit_name), codeunit_folder,print_live_output=self.get_verbosity()==LogLevel.Debug)
221
232
  for runtime in runtimes:
222
233
  outputfolder = originaloutputfolder+runtime
223
- GeneralUtilities.ensure_directory_does_not_exist(os.path.join(csproj_file_folder, "obj"))
224
234
  GeneralUtilities.ensure_directory_does_not_exist(outputfolder)
225
- self._protected_sc.run_program("dotnet", "clean", csproj_file_folder)
226
235
  GeneralUtilities.ensure_directory_exists(outputfolder)
227
- self._protected_sc.run_program_argsasarray("dotnet", ["restore", "--runtime", runtime]+self.__get_lock_file_arguments(codeunit_folder, codeunit_name, runtime), codeunit_folder,print_live_output=self.get_verbosity()==LogLevel.Debug)
228
236
  self._protected_sc.run_program_argsasarray("dotnet", ["build", "--no-restore", csproj_file_name, "-c", dotnet_build_configuration, "-o", outputfolder, "--runtime", runtime], csproj_file_folder,print_live_output=self.get_verbosity()==LogLevel.Debug)
229
237
  if copy_license_file_to_target_folder:
230
238
  license_file = os.path.join(repository_folder, "License.txt")
@@ -247,6 +255,24 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
247
255
  sarif_target_file = os.path.join(sarif_folder_target, sarif_filename)
248
256
  GeneralUtilities.ensure_file_does_not_exist(sarif_target_file)
249
257
  shutil.copyfile(sarif_source_file, sarif_target_file)
258
+ # The lock-file becomes a part of the build-result: it states which version of which package the build actually used,
259
+ # which is what makes it possible to reproduce a build later or to check an artifact against a vulnerability
260
+ # afterwards. It covers every runtime which was built, so it is copied once and not per runtime. The working-copy
261
+ # keeps its own lock-file, so this is a copy and not a move.
262
+ # The target is a folder per project, because every project of the codeunit has a lock-file of the same name and a
263
+ # flat folder would let the second project overwrite the file of the first one.
264
+ lock_file = os.path.join(csproj_file_folder, self.__get_lock_file_name())
265
+ if os.path.isfile(lock_file):
266
+ lock_file_folder_target = os.path.join(codeunit_folder, "Other", "Artifacts", "PackagesLock", csproj_file_name_without_extension)
267
+ GeneralUtilities.ensure_directory_exists(lock_file_folder_target)
268
+ lock_file_target = os.path.join(lock_file_folder_target, os.path.basename(lock_file))
269
+ GeneralUtilities.ensure_file_does_not_exist(lock_file_target)
270
+ shutil.copyfile(lock_file, lock_file_target)
271
+ else:
272
+ # The restore which ran above creates the file whenever the project demands one (see __get_lock_file_arguments),
273
+ # so a missing file means the project does not set RestorePackagesWithLockFile - and then the build-result does
274
+ # not state which versions it used.
275
+ self._protected_sc.log.log(f"The lock-file \"{lock_file}\" does not exist, so the build-result of \"{csproj_file_name_without_extension}\" does not contain the versions which were used.", LogLevel.Warning)
250
276
 
251
277
  @GeneralUtilities.check_arguments
252
278
  def standardized_tasks_build_for_dotnet_project(self,runtimes:list[str]) -> None:
@@ -274,7 +300,6 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
274
300
 
275
301
  @GeneralUtilities.check_arguments
276
302
  def __standardized_tasks_build_for_dotnet_project(self,runtimes:list[str]) -> None:
277
-
278
303
  target_environment_type: str=self.get_target_environment_type()
279
304
  copy_license_file_to_target_folder: bool=True
280
305
  codeunitname: str = self.get_codeunit_name()
@@ -282,7 +307,7 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
282
307
  workspace_folder=os.path.join(self.get_codeunit_folder(),"Other","Workspace")
283
308
  GeneralUtilities.ensure_directory_does_not_exist(workspace_folder)
284
309
 
285
- files_to_sign: dict[str, str] = self.get_filestosign_from_commandline_arguments( dict())
310
+ files_to_sign: dict[str, str] = self.get_filestosign_from_commandline_arguments(dict())
286
311
  repository_folder: str = self.get_repository_folder()
287
312
  commitid = self._protected_sc.git_get_commit_id(repository_folder)
288
313
  outputfolder = GeneralUtilities.resolve_relative_path("./Other/Artifacts", self.get_codeunit_folder())
@@ -335,8 +360,6 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
335
360
  bomfile_folder = "Other/Artifacts/BOM"
336
361
  # "-dpr" keeps CycloneDX from restoring the project itself. The SBOM is generated directly after the project and its
337
362
  # test-project were built, so the dependencies are restored and the assets-file CycloneDX reads is up-to-date already.
338
- # Its restore would also not be able to name the lock-file of the runtime the build used, so it would write one under
339
- # the default-name (see __get_arguments_which_prevent_writing_a_lock_file).
340
363
  self._protected_sc.run_program_argsasarray("dotnet", ["CycloneDX", f"{codeunit_name}/{codeunit_name}.csproj", "-o", bomfile_folder, "-dpr"], codeunit_folder)
341
364
  codeunitversion = self.tfcps_Tools_General.get_version_of_codeunit(os.path.join(codeunit_folder, f"{codeunit_name}.codeunit.xml"))
342
365
  target = f"{codeunit_folder}/{bomfile_folder}/{codeunit_name}.{codeunitversion}.sbom.xml"
@@ -369,7 +392,7 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
369
392
  # begin with a drive-letter anymore) and resolves against the working-directory, so it writes to a path
370
393
  # which contains a quote in the middle. On Linux that only creates a strangely named folder, on Windows a
371
394
  # quote is not allowed in a path and the msbuild-task GenerateDepsFile fails with an IOException.
372
- run_result = self._protected_sc.run_program_argsasarray("dotnet", ["build", sln_file, "-nologo", "-v", "minimal", "-o", temp_output_folder]+self.__get_arguments_which_prevent_writing_a_lock_file(), temp_output_folder, throw_exception_if_exitcode_is_not_zero=False, env_vars={"DOTNET_CLI_UI_LANGUAGE": "en-US", "MSBUILDDISABLENODEREUSE": "1"})
395
+ run_result = self._protected_sc.run_program_argsasarray("dotnet", ["build", sln_file, "-nologo", "-v", "minimal", "-o", temp_output_folder], temp_output_folder, throw_exception_if_exitcode_is_not_zero=False, env_vars={"DOTNET_CLI_UI_LANGUAGE": "en-US", "MSBUILDDISABLENODEREUSE": "1"})
373
396
  finally:
374
397
  GeneralUtilities.ensure_directory_does_not_exist(temp_output_folder)
375
398
  diagnostics: list[tuple[LogLevel, str, str | None, int | None]] = []
@@ -506,6 +529,7 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
506
529
  regex = f"""^<Project Sdk=\\"Microsoft\\.NET\\.Sdk\\">
507
530
  <PropertyGroup>
508
531
  <TargetFramework>([^<]+)<\\/TargetFramework>
532
+ <RuntimeIdentifiers>([^<]+)<\\/RuntimeIdentifiers>
509
533
  <Authors>([^<]+)<\\/Authors>
510
534
  <Version>{codeunit_version_regex}<\\/Version>
511
535
  <AssemblyVersion>{codeunit_version_regex}<\\/AssemblyVersion>
@@ -572,6 +596,7 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
572
596
  regex = f"""^<Project Sdk=\\"Microsoft\\.NET\\.Sdk\\">
573
597
  <PropertyGroup>
574
598
  <TargetFramework>([^<]+)<\\/TargetFramework>
599
+ <RuntimeIdentifiers>([^<]+)<\\/RuntimeIdentifiers>
575
600
  <Authors>([^<]+)<\\/Authors>
576
601
  <Version>{codeunit_version_regex}<\\/Version>
577
602
  <AssemblyVersion>{codeunit_version_regex}<\\/AssemblyVersion>
@@ -660,6 +685,15 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
660
685
  result.append(f"Line {i+1} does not match: Regex='{r}' String='{s}'")
661
686
  return result
662
687
 
688
+ @GeneralUtilities.check_arguments
689
+ def _protected_restore_projects_for_the_metadata_of_docfx(self) -> None:
690
+ """Restores the projects of this codeunit, so that docfx can read them without restoring them itself.
691
+
692
+ Like every restore of a codeunit this one names no runtime, so it writes the same lock-file the build reads and there
693
+ is nothing to keep it away from. The restore is done here and not left to docfx, because docfx is called with
694
+ "--noRestore" and because the reference of a codeunit can also be generated on its own, without a build before it."""
695
+ self._protected_sc.run_program_argsasarray("dotnet", ["restore"], self.get_codeunit_folder(), print_live_output=self.get_verbosity() == LogLevel.Debug)
696
+
663
697
  @GeneralUtilities.check_arguments
664
698
  def generate_reference(self, generate_class_reference:bool=False) -> None:
665
699
  self.generate_reference_using_docfx(generate_class_reference)
@@ -694,7 +728,7 @@ class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
694
728
  GeneralUtilities.ensure_file_does_not_exist(target_file)
695
729
 
696
730
  sln_file = os.path.join(codeunit_folder, f"{codeunit_name}.sln")
697
- args: list[str] = ["test", sln_file, "-c", dotnet_build_configuration, "-o", temp_folder]+self.__get_arguments_which_prevent_writing_a_lock_file()
731
+ args: list[str] = ["test", sln_file, "-c", dotnet_build_configuration, "-o", temp_folder]
698
732
  runsettings_path = os.path.join(codeunit_folder, runsettings_file)
699
733
  if os.path.isfile(runsettings_path):
700
734
  args += ["--settings", runsettings_path]
@@ -283,6 +283,15 @@ class TFCPS_CodeUnitSpecific_Base(ABC):
283
283
  content_without_trailing_commas: str = re.sub(r",(\s*[}\]])", r"\1", content)
284
284
  return 0 < len(json.loads(content_without_trailing_commas).get("metadata", []))
285
285
 
286
+ @GeneralUtilities.check_arguments
287
+ def _protected_restore_projects_for_the_metadata_of_docfx(self) -> None:
288
+ """Restores what the metadata-step of docfx reads.
289
+
290
+ docfx is called with "--noRestore" (see generate_reference_using_docfx), so a codeunit whose reference is generated
291
+ from project-files has to restore them itself; this is where a codeunit-kind states how that is done. Doing nothing
292
+ is the default, because the reference of a codeunit of most kinds is generated from files which are read as they
293
+ are."""
294
+
286
295
  @GeneralUtilities.check_arguments
287
296
  def generate_reference_using_docfx(self, generate_class_reference:bool=False):
288
297
  reference_folder =os.path.join( self.get_codeunit_folder(),"Other","Reference")
@@ -297,15 +306,16 @@ class TFCPS_CodeUnitSpecific_Base(ABC):
297
306
  obj_folder = os.path.join(reference_folder, "obj")
298
307
  GeneralUtilities.ensure_folder_exists_and_is_empty(obj_folder)
299
308
  # The metadata-step and the build-step are executed separately instead of using the default-command which runs both
300
- # of them at once, because only the metadata-command accepts "--property". That property is required because docfx
301
- # restores the project before it reads it (which is what its option "--noRestore" switches off): that restore does
302
- # not know the name of the lock-file which belongs to the runtime the build restored for, so it would write one
303
- # under the default-name besides them (see
304
- # TFCPS_CodeUnitSpecific_DotNet.__get_arguments_which_prevent_writing_a_lock_file). The restore itself is kept
305
- # (instead of passing "--noRestore"), because the reference of a codeunit can also be generated on its own, without
306
- # a build before it.
309
+ # of them at once, because only the metadata-command accepts "--noRestore". That option is required because the
310
+ # restore which docfx runs before it reads a project is a process of its own which none of the properties of this
311
+ # call reach: neither "RestorePackagesWithLockFile" nor "NuGetLockFilePath" arrives there, so that restore writes a
312
+ # lock-file under the default-name into the codeunit. Such a file must never exist - it pins nothing, because only
313
+ # the runtime-specific lock-files are validated, and every following dotnet-operation fails with NU1005 as long as
314
+ # it lies there. What the metadata-step reads is therefore restored before docfx is called (see
315
+ # _protected_restore_projects_for_the_metadata_of_docfx), where the name of the lock-file is under our control.
307
316
  if self.__docfx_configuration_declares_metadata(os.path.join(reference_folder, "docfx.json")):
308
- self._protected_sc.run_program("docfx", "metadata docfx.json --property RestorePackagesWithLockFile=false", reference_folder)
317
+ self._protected_restore_projects_for_the_metadata_of_docfx()
318
+ self._protected_sc.run_program("docfx", "metadata docfx.json --noRestore", reference_folder)
309
319
  self._protected_sc.run_program("docfx", "build -t default,templates/darkfx docfx.json", reference_folder)
310
320
  GeneralUtilities.ensure_directory_does_not_exist(obj_folder)
311
321
 
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: scriptcollection
3
- Version: 4.4.9
3
+ Version: 4.4.11
4
4
  Summary: The ScriptCollection is the place for reusable scripts.
5
5
  Author-email: Marius Göcke <marius.goecke@gmail.com>
6
6
  Project-URL: Homepage, https://github.com/anionDev/ScriptCollection
@@ -9,7 +9,7 @@ ScriptCollection/ProgramRunnerMock.py,sha256=uTu-aFle1W_oKjeQEmuPsFPQpvo0kRf2FrR
9
9
  ScriptCollection/ProgramRunnerPopen.py,sha256=zVD-gZY85o8wiGFcpYAGNDl-tXaKzipl1Bkhqy2ois4,4681
10
10
  ScriptCollection/ProgramRunnerSudo.py,sha256=ot9Ib-plQ8wejR9M2XXfnx6GR-va9k8SH1gAC5kjaJ0,5123
11
11
  ScriptCollection/SCLog.py,sha256=Fjf8Pdi63cXHGMxL_aI6A0dwGm7QIfrv3czjvpSUlaM,4705
12
- ScriptCollection/ScriptCollectionCore.py,sha256=rldvIi9zD5BgzRFqgmou-1P0alxEEouWky3w-PV46Pw,261810
12
+ ScriptCollection/ScriptCollectionCore.py,sha256=2jjwsumgVzyhh2pLSrzpY-3n3jMoErYeUu5qbEmWI_I,261811
13
13
  ScriptCollection/TestKind.py,sha256=EBTLR8yBz5VmWA2NZIpDTbQNg6tkfv_kAsIzEJ--mCI,1756
14
14
  ScriptCollection/UnassignedVariablesCheck.py,sha256=v59qLQ5RRvx31ouuCW7NWZj3McWENvGBPkV5ZGBmqJE,4344
15
15
  ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -37,7 +37,7 @@ ScriptCollection/Resources/MaintenanceSite/MaintenanceSite.html,sha256=CX9S1bdOz
37
37
  ScriptCollection/TFCPS/PackageSource.py,sha256=tQoMbxrIbV3mYHKH2wgOoGzIHY1TvBH8EAFpWGhryrQ,1311
38
38
  ScriptCollection/TFCPS/SCTaskRunnerServer.py,sha256=rpuwSsQ6YQfZS2LGnvOH5ql8zs_-cHU4LQttS7XNT60,11272
39
39
  ScriptCollection/TFCPS/TFCPS_BuildCodeUnitsHook.py,sha256=67_DQwoH5bhxxSmwtuAeoW1NOCMiLMzOy48OqlJX-KY,1744
40
- ScriptCollection/TFCPS/TFCPS_CodeUnitSpecific_Base.py,sha256=N6hOkfts6g61dhrQyrWx64Nxe0nInMtzyVNKyqHvUfk,38992
40
+ ScriptCollection/TFCPS/TFCPS_CodeUnitSpecific_Base.py,sha256=Rm1wY0CKHqFGyTlLAbFE1CY7SBzfhms68Mz-UFX7b5s,39740
41
41
  ScriptCollection/TFCPS/TFCPS_CodeUnit_BuildCodeUnit.py,sha256=Mj9t1SyRpkYZE74cLsGWYv4xB89gXL2ld-RX3xvvGdw,9835
42
42
  ScriptCollection/TFCPS/TFCPS_CodeUnit_BuildCodeUnits.py,sha256=PHu13UCn3xj3UBneGk5DDkYZ9iGdJ80IKIte3ewwKfI,49143
43
43
  ScriptCollection/TFCPS/TFCPS_CreateRelease.py,sha256=kpEmSnfzfgB4OjcCuS_X6jgW_ftcphxEnjjoLoAHTLY,6582
@@ -55,7 +55,7 @@ ScriptCollection/TFCPS/Docker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
55
55
  ScriptCollection/TFCPS/DotNet/CertificateGeneratorInformationBase.py,sha256=bT6Gd5pQpZCw4OQz6HWkPCSn5z__eUUEisABLDSxd0o,200
56
56
  ScriptCollection/TFCPS/DotNet/CertificateGeneratorInformationGenerate.py,sha256=QyjOfMY22JWCvKjMelHiDWbJiWqotOfebpJpgDUaoO4,237
57
57
  ScriptCollection/TFCPS/DotNet/CertificateGeneratorInformationNoGenerate.py,sha256=i0zEGehj0sttxjjZtoq2KFSKp_ulxVyWp_ZgAhIY_So,241
58
- ScriptCollection/TFCPS/DotNet/TFCPS_CodeUnitSpecific_DotNet.py,sha256=9KUJLrYqEXV-h-AR4gde2u-KX-JXwtb0BNJ9OyuUEnM,56266
58
+ ScriptCollection/TFCPS/DotNet/TFCPS_CodeUnitSpecific_DotNet.py,sha256=aQ0YyAgIlgB6gVMUWojJtyBdQMrGzDsIUzIP5BCukZY,59194
59
59
  ScriptCollection/TFCPS/DotNet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
60
60
  ScriptCollection/TFCPS/Flutter/TFCPS_CodeUnitSpecific_Flutter.py,sha256=cAE_OFJBU0M3L2Ov5PUUMH7aOVVzKtnKlFoXSw43fng,8759
61
61
  ScriptCollection/TFCPS/Flutter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -71,8 +71,8 @@ ScriptCollection/TFCPS/Rust/TFCPS_CodeUnitSpecific_Rust.py,sha256=yyjWPMHQjPLkML
71
71
  ScriptCollection/TFCPS/Rust/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
72
72
  ScriptCollection/TFCPS/TypeScript/TFCPS_CodeUnitSpecific_TypeScript.py,sha256=5z990qyO5durX07xRWRwju1hl6wpjQAy2f-yRwJ-7s0,11856
73
73
  ScriptCollection/TFCPS/TypeScript/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
74
- scriptcollection-4.4.9.dist-info/METADATA,sha256=h2-_3VwdzABZM0Qyi5VJvL_Ret6DA_KiVFyDzpd6MXo,7647
75
- scriptcollection-4.4.9.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
76
- scriptcollection-4.4.9.dist-info/entry_points.txt,sha256=Aj6CHuJxASMe52fK_O6-bNJ_uhxcDb-AgRxFOeTojyE,6069
77
- scriptcollection-4.4.9.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
78
- scriptcollection-4.4.9.dist-info/RECORD,,
74
+ scriptcollection-4.4.11.dist-info/METADATA,sha256=d9bK1paPJpLTbcb959jcRrykTIjngI4s1IUb9i_KuTU,7648
75
+ scriptcollection-4.4.11.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
76
+ scriptcollection-4.4.11.dist-info/entry_points.txt,sha256=Aj6CHuJxASMe52fK_O6-bNJ_uhxcDb-AgRxFOeTojyE,6069
77
+ scriptcollection-4.4.11.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
78
+ scriptcollection-4.4.11.dist-info/RECORD,,