pybiolib 1.1.1747__py3-none-any.whl → 1.1.2193__py3-none-any.whl

biolib/utils/seq_util.py

@@ -1,27 +1,26 @@
 import re
 from io import BufferedIOBase
-from biolib.typing_utils import List, Optional, Dict, Union
 
-allowed_sequence_chars = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.")
-def find_invalid_sequence_characters(sequence):
-    invalid_chars = [char for char in sequence if char not in allowed_sequence_chars]
-    return invalid_chars
+from biolib.typing_utils import Dict, List, Optional, Union
+
 
 class SeqUtilRecord:
-    def __init__(self,
-                 sequence: str,
-                 sequence_id: str,
-                 description: Optional['str'],
-                 properties: Optional[Dict[str, str]] = None):
+    def __init__(
+        self,
+        sequence: str,
+        sequence_id: str,
+        description: Optional['str'],
+        properties: Optional[Dict[str, str]] = None,
+    ):
         self.sequence = sequence
         self.id = sequence_id  # pylint: disable=invalid-name
         self.description = description
 
         if properties:
-            disallowed_pattern = re.compile(r"[=\[\]\n]")
+            disallowed_pattern = re.compile(r'[=\[\]\n]')
             for key, value in properties.items():
-                assert not bool(disallowed_pattern.search(key)), "Key cannot contain characters =[] and newline"
-                assert not bool(disallowed_pattern.search(value)), "Value cannot contain characters =[] and newline"
+                assert not bool(disallowed_pattern.search(key)), 'Key cannot contain characters =[] and newline'
+                assert not bool(disallowed_pattern.search(value)), 'Value cannot contain characters =[] and newline'
             self.properties = properties
         else:
             self.properties = {}
@@ -33,24 +32,24 @@ class SeqUtilRecord:
 class SeqUtil:
     @staticmethod
     def parse_fasta(
-        input_file: Union[str, BufferedIOBase] = None,
+        input_file: Union[str, BufferedIOBase, None] = None,
         default_header: Optional[str] = None,
         allow_any_sequence_characters: bool = False,
-        allow_empty_sequence: bool = False,
+        allow_empty_sequence: bool = True,
         file_name: Optional[str] = None,
     ) -> List[SeqUtilRecord]:
         if input_file is None:
             if file_name:
                 input_file = file_name
             else:
-                raise ValueError("input_file must be a file name (str) or a BufferedIOBase object")
+                raise ValueError('input_file must be a file name (str) or a BufferedIOBase object')
         if isinstance(input_file, str):
-            with open(input_file, 'r') as file_handle:
+            with open(input_file) as file_handle:
                 data = file_handle.read().strip()
         elif isinstance(input_file, BufferedIOBase):
             data = input_file.read().decode('utf-8')
         else:
-            raise ValueError("input_file must be a file name (str) or a BufferedIOBase object")
+            raise ValueError('input_file must be a file name (str) or a BufferedIOBase object')
         if not data:
             return []
 
@@ -66,9 +65,9 @@ class SeqUtil:
                 raise Exception(f'No header line found in FASTA file "{file_name}"')
 
         splitted = []
-        tmp_data = ""
+        tmp_data = ''
         for line in data.splitlines():
-            if line.startswith(">"):
+            if line.startswith('>'):
                 if tmp_data:
                     splitted.append(tmp_data)
                 tmp_data = line[1:].strip() + '\n'
@@ -84,23 +83,20 @@ class SeqUtil:
             sequence_data_splitted = sequence_data.strip().split('\n')
             header_line = sequence_data_splitted[0].split()
             sequence_id = header_line[0]
-            description = sequence_data_splitted[0][len(sequence_id):].strip()
-            sequence = "".join([seq.strip().upper() for seq in sequence_data_splitted[1:]])
+            description = sequence_data_splitted[0][len(sequence_id) :].strip()
+            sequence = ''.join([seq.strip() for seq in sequence_data_splitted[1:]])
 
             if not allow_any_sequence_characters:
-                invalid_sequence_characters = find_invalid_sequence_characters(sequence)
+                invalid_sequence_characters = SeqUtil._find_invalid_sequence_characters(sequence)
                 if len(invalid_sequence_characters) > 0:
                     raise Exception(
                         f'Error: Invalid character ("{invalid_sequence_characters[0]}") found in sequence {sequence_id}'
                     )
             if not allow_empty_sequence and len(sequence) == 0:
-                raise Exception(
-                    f'Error: No sequence found for fasta entry {sequence_id}'
-                )
+                raise Exception(f'Error: No sequence found for fasta entry {sequence_id}')
+
+            parsed_sequences.append(SeqUtilRecord(sequence=sequence, sequence_id=sequence_id, description=description))
 
-            parsed_sequences.append(
-                SeqUtilRecord(sequence=sequence, sequence_id=sequence_id, description=description)
-            )
         return parsed_sequences
 
     @staticmethod
@@ -111,5 +107,17 @@ class SeqUtil:
                 if record.properties:
                     for key, value in record.properties.items():
                         optional_description += f' [{key}={value}]'
-                sequence = '\n'.join(record.sequence[i:i + 80] for i in range(0, len(record.sequence), 80))
+                sequence = '\n'.join(record.sequence[i : i + 80] for i in range(0, len(record.sequence), 80))
                 file_handle.write(f'>{record.id}{optional_description}\n{sequence}\n')
+
+    @staticmethod
+    def _find_invalid_sequence_characters(sequence: str) -> List[str]:
+        allowed_sequence_chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.')
+        invalid_chars = [char for char in sequence if char not in allowed_sequence_chars]
+        return invalid_chars
+
+    @staticmethod
+    def _find_invalid_sequence_id_characters(sequence: str) -> List[str]:
+        allowed_chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.:*#')
+        invalid_chars = [char for char in sequence if char not in allowed_chars]
+        return invalid_chars

{pybiolib-1.1.1747.dist-info → pybiolib-1.1.2193.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybiolib
-Version: 1.1.1747
+Version: 1.1.2193
 Summary: BioLib Python Client
 Home-page: https://github.com/biolib
 License: MIT

pybiolib-1.1.2193.dist-info/RECORD

@@ -0,0 +1,123 @@
+LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
+README.md,sha256=_IH7pxFiqy2bIAmaVeA-iVTyUwWRjMIlfgtUbYTtmls,368
+biolib/__init__.py,sha256=_tThyzISH81yS9KXP_X3qEiKXmsIp5XOBcJIODfLVnc,4338
+biolib/_data_record/data_record.py,sha256=CoyYRse5VdUBhQzzPfR9BkytgOsM-IZxkfMX1kyRnPk,12589
+biolib/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biolib/_internal/data_record/__init__.py,sha256=fGdME6JGRU_2VxpJbYpGXYndjN-feUkmKY4fuMyq3cg,76
+biolib/_internal/data_record/data_record.py,sha256=YmaAABR57goDCE8-rKb2j0FPMSbDtRPCm_HhT3mM074,4299
+biolib/_internal/data_record/remote_storage_endpoint.py,sha256=eCptuZ4DMAPnaNCVDvpWXwXGI6Jac9U1N5dqU8Cj95Q,1732
+biolib/_internal/file_utils.py,sha256=4jT6j7bB21c0JNn5BfnyWQib_zt0CVtJ_TiOFOStRcE,2604
+biolib/_internal/fuse_mount/__init__.py,sha256=B_tM6RM2dBw-vbpoHJC4X3tOAaN1H2RDvqYJOw3xFwg,55
+biolib/_internal/fuse_mount/experiment_fuse_mount.py,sha256=08aUdEq_bvqLBft_gSLjOClKDy5sBnMts1RfJf7AP_U,7012
+biolib/_internal/http_client.py,sha256=DdooXei93JKGYGV4aQmzue_oFzvHkozg2UCxgk9dfDM,5081
+biolib/_internal/lfs/__init__.py,sha256=gSWo_xg61UniYgD7yNYxeT4I9uaXBCBSi3_nmZjnPpE,35
+biolib/_internal/lfs/cache.py,sha256=pQS2np21rdJ6I3DpoOutnzPHpLOZgUIS8TMltUJk_k4,2226
+biolib/_internal/libs/__init__.py,sha256=Jdf4tNPqe_oIIf6zYml6TiqhL_02Vyqwge6IELrAFhw,98
+biolib/_internal/libs/fusepy/__init__.py,sha256=AWDzNFS-XV_5yKb0Qx7kggIhPzq1nj_BZS5y2Nso08k,41944
+biolib/_internal/push_application.py,sha256=8P7eXvySn7CRp5XBDkO3xjTGixS8g7-jD-_iwzM_XDI,10020
+biolib/_internal/runtime.py,sha256=9pZ3s3L7LGxdqOgnHh1KK3Jjyn_9MjhQmKHI-6hMT3U,448
+biolib/_internal/types/__init__.py,sha256=11ZucS8jKeLGAAswXyKI7FH2KLHd6T9Sh8ZK2Ar3jlk,152
+biolib/_internal/types/app.py,sha256=Mz2QGD_jESX-K9JYnLWPo4YA__Q_1FQQTk9pvidCohU,118
+biolib/_internal/types/data_record.py,sha256=AHoIiwVqeHj0HozQxFRAyxk-d3XJgLWno4ic1z9eTrQ,865
+biolib/_internal/types/experiment.py,sha256=D94iBdn2nS92lRW-TOs1a2WKXJD5ZtmzL4ypggKX2ys,176
+biolib/_internal/types/resource.py,sha256=G-vPkZoe4Um6FPxsQZtRzAlbSW5sDW4NFkbjn21I3V4,372
+biolib/_internal/types/typing.py,sha256=D4EKKEe7kDx0K6lJi-H_XLtk-8w6nu2fdqn9bvzI-Xo,288
+biolib/_internal/utils/__init__.py,sha256=p5vsIFyu-zYqBgdSMfwW9NC_jk7rXvvCbV4Bzd3As7c,630
+biolib/_runtime/runtime.py,sha256=daYxzIpRoW4k-HJFu2BMXeylYSlCXn3-SqdSriCFnKw,2770
+biolib/api/__init__.py,sha256=mQ4u8FijqyLzjYMezMUUbbBGNB3iFmkNdjXnWPZ7Jlw,138
+biolib/api/client.py,sha256=FRpdH5aI187b_I_4HUNi680v4iOP65z5f2RcUo8D8MA,3559
+biolib/app/__init__.py,sha256=cdPtcfb_U-bxb9iSL4fCEq2rpD9OjkyY4W-Zw60B0LI,37
+biolib/app/app.py,sha256=P2RwaDAskUHzlciuTJUroqUocRwoyOLT6YbgMyCRRDI,8484
+biolib/app/search_apps.py,sha256=K4a41f5XIWth2BWI7OffASgIsD0ko8elCax8YL2igaY,1470
+biolib/biolib_api_client/__init__.py,sha256=E5EMa19wJoblwSdQPYrxc_BtIeRsAuO0L_jQweWw-Yk,182
+biolib/biolib_api_client/api_client.py,sha256=ciNx4ybpyKG5LEf4KQdGEz13r0jTxImyQat4_HDecD0,7373
+biolib/biolib_api_client/app_types.py,sha256=FxSr4UqfnMhLe34p8bm02wsC3g1Jz8iaing5tRKDOQI,2442
+biolib/biolib_api_client/auth.py,sha256=kjm0ZHnH3I8so3su2sZbBxNHYp-ZUdrZ5lwQ0K36RSw,949
+biolib/biolib_api_client/biolib_app_api.py,sha256=DndlVxrNTes6DOaWyMINLGZQCRMWVvR7gwt5HVlyf5Y,4240
+biolib/biolib_api_client/biolib_job_api.py,sha256=7bKfav3-12ewXkEUoLdCmbWdebW8148kxfGJW9SsXZI,7125
+biolib/biolib_api_client/common_types.py,sha256=RH-1KNHqUF-EkTpfPOSTt5Mq1GPdfju_cqXDesscO1I,123
+biolib/biolib_api_client/job_types.py,sha256=Dl4NhU2xpgpXV-7YIoDf6WL63SLR5bni55OX8x5539M,1300
+biolib/biolib_api_client/lfs_types.py,sha256=joZWP6-sa5_Ug_6xIp5fHAgEo_bqLE3rbleQocZtDcg,339
+biolib/biolib_api_client/user_state.py,sha256=XcgWV-MgVk88mIlMmnu8yHxMu8OCaw8o0tk7TVo5Hcg,637
+biolib/biolib_binary_format/__init__.py,sha256=HMl5SdX_VUWE4OQzi4Jf_yFvC7b0bSPOGPHYi9dWM2Q,185
+biolib/biolib_binary_format/base_bbf_package.py,sha256=vxRV4iKy0dXeDOlFWnMFI0hGnDBYDH5Cgh5gAfuObt8,959
+biolib/biolib_binary_format/file_in_container.py,sha256=j1eEPRxf_ew8I6G8sDiiZZxn4Wx1ppagfM9K8zTDG4U,3591
+biolib/biolib_binary_format/module_input.py,sha256=led2QhHeec_ymBPw5uEn3_3vJKI-1T8zrFQGqwEWLMY,2788
+biolib/biolib_binary_format/module_output_v2.py,sha256=J5ZO5gCSeudpE12EVDrjYrNTS2DwgszY-SVXT7Qjuyg,5913
+biolib/biolib_binary_format/remote_endpoints.py,sha256=V48mwOj3eAQAKp-8DjtWUdEKUyC0WKc1pEiKTmtjrJY,1651
+biolib/biolib_binary_format/remote_stream_seeker.py,sha256=uyi6kJBU1C1DWfiuR0kRUQIY7nalG7ocgwgngd3Ul4U,1999
+biolib/biolib_binary_format/saved_job.py,sha256=nFHVFRNTNcAFGODLSiBntCtMk55QKwreUq6qLX80dI4,1125
+biolib/biolib_binary_format/stdout_and_stderr.py,sha256=WfUUJFFCBrtfXjuWIaRPiWCpuBLxfko68oxoTKhrwx8,1023
+biolib/biolib_binary_format/system_exception.py,sha256=T3iL4_cSHAHim3RSDPS8Xyb1mfteaJBZonSXuRltc28,853
+biolib/biolib_binary_format/system_status_update.py,sha256=aOELuQ0k-GtpaZTUxYd0GFomP_OInmrK585y6fuQuKE,1191
+biolib/biolib_binary_format/utils.py,sha256=ra_plrh_Z10u98O2gW9uW2qzscQZCfq91SOznmDTY64,5170
+biolib/biolib_docker_client/__init__.py,sha256=aBfA6mtWSI5dBEfNNMD6bIZzCPloW4ghKm0wqQiljdo,1481
+biolib/biolib_download_container.py,sha256=8TmBV8iv3bCvkNlHa1SSsc4zl0wX_eaxhfnW5rvFIh8,1779
+biolib/biolib_errors.py,sha256=5m4lK2l39DafpoXBImEBD4EPH3ayXBX0JgtPzmGClow,689
+biolib/biolib_logging.py,sha256=J3E5H_LL5k6ZUim2C8gqN7E6lCBZMTpO4tnMpOPwG9U,2854
+biolib/cli/__init__.py,sha256=0v3c_J-U0k46c5ZWeQjLG_kTaKDJm81LBxQpDO2B_aI,1286
+biolib/cli/auth.py,sha256=rpWGmXs6Fz6CGrO9K8ibPRszOdXG78Vig_boKaVCD9A,2082
+biolib/cli/data_record.py,sha256=08JbZkFWKMo0PrnhhG0jQEKnNW7pPLti9cOw8s1TWfI,3344
+biolib/cli/download_container.py,sha256=HIZVHOPmslGE5M2Dsp9r2cCkAEJx__vcsDz5Wt5LRos,483
+biolib/cli/init.py,sha256=wQOfii_au-d30Hp7DdH-WVw-WVraKvA_zY4za1w7DE8,821
+biolib/cli/lfs.py,sha256=z2qHUwink85mv9yDgifbVKkVwuyknGhMDTfly_gLKJM,4151
+biolib/cli/push.py,sha256=TFi7O9tJ3zFe0VmtVTV3Vh9_xIMHnrc41xxcaBKU46g,813
+biolib/cli/run.py,sha256=BbvXLQ-XibjQ71Y2d4URMH_8dflNVwM0i3TIWhw_u_c,1634
+biolib/cli/runtime.py,sha256=Xv-nrma5xX8NidWcvbUKcUvuN5TCarZa4A8mPVmF-z0,361
+biolib/cli/start.py,sha256=rg8VVY8rboFhf1iQo3zE3WA5oh_R1VWWfYJEO1gMReY,1737
+biolib/compute_node/.gitignore,sha256=GZdZ4g7HftqfOfasFpBC5zV1YQAbht1a7EzcXD6f3zg,45
+biolib/compute_node/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biolib/compute_node/cloud_utils/__init__.py,sha256=VZSScLqaz5tg_gpMvWgwkAu9Qf-vgW_QHRoDOaAmU44,67
+biolib/compute_node/cloud_utils/cloud_utils.py,sha256=_iaKelsmQLLwbDKVXZMXPFZayZPH9iHXc4NISFP9uzk,7462
+biolib/compute_node/job_worker/__init__.py,sha256=ipdPWaABKYrltxny15e2kK8PWdEE7VzXbkKK6wM_zDk,71
+biolib/compute_node/job_worker/cache_state.py,sha256=MwjSRzcJJ_4jybqvBL4xdgnDYSIiw4s90pNn83Netoo,4830
+biolib/compute_node/job_worker/cache_types.py,sha256=ajpLy8i09QeQS9dEqTn3T6NVNMY_YsHQkSD5nvIHccQ,818
+biolib/compute_node/job_worker/docker_image_cache.py,sha256=ansHIkJIq_EMW1nZNlW-RRLVVeKWTbzNICYaOHpKiRE,7460
+biolib/compute_node/job_worker/executors/__init__.py,sha256=bW6t1qi3PZTlHM4quaTLa8EI4ALTCk83cqcVJfJfJfE,145
+biolib/compute_node/job_worker/executors/docker_executor.py,sha256=2H7GooL0oAifPcbie0unatB4fRoHyqbsr6S91uagc_g,27952
+biolib/compute_node/job_worker/executors/docker_types.py,sha256=VhsU1DKtJjx_BbCkVmiPZPH4ROiL1ygW1Y_s1Kbpa2o,216
+biolib/compute_node/job_worker/executors/tars/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biolib/compute_node/job_worker/executors/types.py,sha256=yP5gG39hr-DLnw9bOE--VHi-1arDbIYiGuV1rlTbbHI,1466
+biolib/compute_node/job_worker/job_legacy_input_wait_timeout_thread.py,sha256=_cvEiZbOwfkv6fYmfrvdi_FVviIEYr_dSClQcOQaUWM,1198
+biolib/compute_node/job_worker/job_max_runtime_timer_thread.py,sha256=K_xgz7IhiIjpLlXRk8sqaMyLoApcidJkgu29sJX0gb8,1174
+biolib/compute_node/job_worker/job_storage.py,sha256=LNkklckDLbYgCHsK5FGrEK75Kw-H4f4JcTCAtuE9His,4035
+biolib/compute_node/job_worker/job_worker.py,sha256=fuWoYJo9HOqLmWl8yeCXh0mhT4ebbkrWac-BVb58khs,28842
+biolib/compute_node/job_worker/large_file_system.py,sha256=XXqRlVtYhs-Ji9zQGIk5KQPXFO_Q5jJH0nnlw4GkeMY,10461
+biolib/compute_node/job_worker/mappings.py,sha256=Z48Kg4nbcOvsT2-9o3RRikBkqflgO4XeaWxTGz-CNvI,2499
+biolib/compute_node/job_worker/utilization_reporter_thread.py,sha256=7tm5Yk9coqJ9VbEdnO86tSXI0iM0omwIyKENxdxiVXk,8575
+biolib/compute_node/job_worker/utils.py,sha256=wgxcIA8yAhUPdCwyvuuJ0JmreyWmmUoBO33vWtG60xg,1282
+biolib/compute_node/remote_host_proxy.py,sha256=CNWJLXXYm8DGujxEJIsg1wUKFoSgU0nhwdmjMn5gelE,14690
+biolib/compute_node/socker_listener_thread.py,sha256=T5_UikA3MB9bD5W_dckYLPTgixh72vKUlgbBvj9dbM0,1601
+biolib/compute_node/socket_sender_thread.py,sha256=YgamPHeUm2GjMFGx8qk-99WlZhEs-kAb3q_2O6qByig,971
+biolib/compute_node/utils.py,sha256=M7i_WTyxbFM3Lri9RWZ_8FeQNYrQIWpKGLfp2I55oeY,4677
+biolib/compute_node/webserver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biolib/compute_node/webserver/gunicorn_flask_application.py,sha256=jPfR_YvNBekLUXWo_vHFV-FIwlb8s8tacKmGHvh93qc,914
+biolib/compute_node/webserver/webserver.py,sha256=15PkRyhtdtSgFDxa0z78aPO4ciZURsFqJYi-HtUmZF8,6494
+biolib/compute_node/webserver/webserver_types.py,sha256=2t8EaFKESnves3BA_NBdnS2yAdo1qwamCFHiSt888nE,380
+biolib/compute_node/webserver/webserver_utils.py,sha256=XWvwYPbWNR3qS0FYbLLp-MDDfVk0QdaAmg3xPrT0H2s,4234
+biolib/compute_node/webserver/worker_thread.py,sha256=26tG73TADnOcXsAr7Iyf6smrLlCqB4x-vvmpUb8WqnA,11569
+biolib/experiments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biolib/experiments/experiment.py,sha256=jIRixmQm3Gq9YdJ3I0-rE1vFukXqq6U4zXehFOJ1yZk,7614
+biolib/jobs/__init__.py,sha256=aIb2H2DHjQbM2Bs-dysFijhwFcL58Blp0Co0gimED3w,32
+biolib/jobs/job.py,sha256=OfG8cLd3AjGjiMWRlJRZdVVbLsRWSX-OM5nxJhR6mPQ,19136
+biolib/jobs/job_result.py,sha256=rALHiKYNaC9lHi_JJqBob1RubzNLwG9Z386kwRJjd2M,5885
+biolib/jobs/types.py,sha256=qhadtH2KDC2WUOOqPiwke0YgtQY4FtuB71Stekq1k48,970
+biolib/runtime/__init__.py,sha256=MlRepA11n2H-3plB5rzWyyHK2JmP6PiaP3i6x3vt0mg,506
+biolib/sdk/__init__.py,sha256=amVp_jMxi2nqCcTsmL2aKUNGCAH3Yk4EzAnps9d1VH8,1928
+biolib/tables.py,sha256=acH7VjwAbadLo8P84FSnKEZxCTVsF5rEg9VPuxElNs8,872
+biolib/templates/__init__.py,sha256=Yx62sSyDCDesRQDQgmbDsLpfgEh93fWE8r9u4g2azXk,36
+biolib/templates/example_app.py,sha256=EB3E3RT4SeO_ii5nVQqJpi5KDGNE_huF1ub-e5ZFveE,715
+biolib/typing_utils.py,sha256=ntzrlyTkUaO2OtccLYzCAGztGdca0WT5fikJUmSkT-Y,148
+biolib/user/__init__.py,sha256=Db5wtxLfFz3ID9TULSSTo77csw9tO6RtxMRvV5cqKEE,39
+biolib/user/sign_in.py,sha256=XTAmRPKfmg7VAaB8cT5wcmfxoPXeHqY8LmDiADF7zbw,2064
+biolib/utils/__init__.py,sha256=fwjciJyJicvYyZcVTzfDBgD0SKY13DeXqvTeG4qZIy8,5548
+biolib/utils/app_uri.py,sha256=Yq_-_VGugQhMMo6mM5f0G9yNlLkr0WK4j0Nrf3FE4xQ,2171
+biolib/utils/cache_state.py,sha256=u256F37QSRIVwqKlbnCyzAX4EMI-kl6Dwu6qwj-Qmag,3100
+biolib/utils/multipart_uploader.py,sha256=XvGP1I8tQuKhAH-QugPRoEsCi9qvbRk-DVBs5PNwwJo,8452
+biolib/utils/seq_util.py,sha256=ZQFcaE37B2dtucN2zDjOmdya_X0ITc1zBFZJNQY13XA,5183
+biolib/utils/zip/remote_zip.py,sha256=0wErYlxir5921agfFeV1xVjf29l9VNgGQvNlWOlj2Yc,23232
+pybiolib-1.1.2193.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
+pybiolib-1.1.2193.dist-info/METADATA,sha256=NCFsHsCnbnOhw1O2L-polZfFa2pNdtA89TfBW7f_o7E,1508
+pybiolib-1.1.2193.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pybiolib-1.1.2193.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
+pybiolib-1.1.2193.dist-info/RECORD,,

{pybiolib-1.1.1747.dist-info → pybiolib-1.1.2193.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

biolib/biolib_api_client/biolib_account_api.py

@@ -1,8 +0,0 @@
-import biolib.api
-
-class BiolibAccountApi:
-
-    @staticmethod
-    def fetch_by_handle(account_handle):
-        response = biolib.api.client.get(path=f'/account/{account_handle}')
-        return response.json()

biolib/biolib_api_client/biolib_large_file_system_api.py

@@ -1,34 +0,0 @@
-import biolib.api
-from biolib.biolib_api_client.lfs_types import LargeFileSystemVersion, LargeFileSystem
-
-
-class BiolibLargeFileSystemApi:
-
-    @staticmethod
-    def create(account_uuid: str, name: str) -> LargeFileSystem:
-        response = biolib.api.client.post(
-            path='/lfs/',
-            data={'account_uuid': account_uuid, 'name': name},
-        )
-
-        lfs: LargeFileSystem = response.json()
-        return lfs
-
-    @staticmethod
-    def fetch_version(lfs_version_uuid: str) -> LargeFileSystemVersion:
-        response = biolib.api.client.get(
-            path=f'/lfs/versions/{lfs_version_uuid}/',
-        )
-
-        lfs_version: LargeFileSystemVersion = response.json()
-        return lfs_version
-
-    @staticmethod
-    def create_version(resource_uuid: str) -> LargeFileSystemVersion:
-        response = biolib.api.client.post(
-            path='/lfs/versions/',
-            data={'resource_uuid': resource_uuid},
-        )
-
-        lfs_version: LargeFileSystemVersion = response.json()
-        return lfs_version

biolib/experiments/types.py

@@ -1,9 +0,0 @@
-from biolib.typing_utils import TypedDict
-
-
-class ExperimentDict(TypedDict):
-    created_at: str
-    job_count: int
-    job_running_count: int
-    name: str
-    uuid: str

biolib/lfs/__init__.py

@@ -1,6 +0,0 @@
-from .cache import prune_lfs_cache
-from .utils import \
-    describe_large_file_system, \
-    get_file_data_from_large_file_system, \
-    push_large_file_system, \
-    create_large_file_system

biolib/lfs/utils.py

@@ -1,237 +0,0 @@
-import io
-import json
-import os
-import zipfile as zf
-from collections import namedtuple
-from pathlib import Path
-from struct import Struct
-
-from biolib import utils
-from biolib._internal.http_client import HttpClient
-from biolib.app import BioLibApp
-from biolib.biolib_api_client.biolib_account_api import BiolibAccountApi
-from biolib.biolib_api_client.biolib_large_file_system_api import BiolibLargeFileSystemApi
-from biolib.biolib_api_client import BiolibApiClient
-from biolib.biolib_logging import logger
-from biolib.biolib_errors import BioLibError
-from biolib.typing_utils import List, Tuple, Iterator, Optional
-from biolib.utils.zip.remote_zip import RemoteZip  # type:ignore
-
-
-def _get_lfs_info_from_uri(lfs_uri):
-    lfs_uri_parts = lfs_uri.split('/')
-    lfs_uri_parts = [uri_part for uri_part in lfs_uri_parts if '@' not in uri_part]  # Remove hostname
-    team_account_handle = lfs_uri_parts[0]
-    lfs_name = lfs_uri_parts[1]
-    account = BiolibAccountApi.fetch_by_handle(team_account_handle)
-    return account, lfs_name
-
-
-def get_files_and_size_of_directory(directory: str) -> Tuple[List[str], int]:
-    data_size = 0
-    file_list: List[str] = []
-
-    for path, _, files in os.walk(directory):
-        for file in files:
-            file_path = os.path.join(path, file)
-            if os.path.islink(file_path):
-                continue  # skip symlinks
-
-            relative_file_path = file_path[len(directory) + 1:]  # +1 to remove starting slash
-            file_list.append(relative_file_path)
-            data_size += os.path.getsize(file_path)
-
-    return file_list, data_size
-
-
-def get_iterable_zip_stream(files: List[str], chunk_size: int) -> Iterator[bytes]:
-    class ChunkedIOBuffer(io.RawIOBase):
-        def __init__(self, chunk_size: int):
-            super().__init__()
-            self.chunk_size = chunk_size
-            self.tmp_data = bytearray()
-
-        def get_buffer_size(self):
-            return len(self.tmp_data)
-
-        def read_chunk(self):
-            chunk = bytes(self.tmp_data[:self.chunk_size])
-            self.tmp_data = self.tmp_data[self.chunk_size:]
-            return chunk
-
-        def write(self, data):
-            data_length = len(data)
-            self.tmp_data += data
-            return data_length
-
-    # create chunked buffer to hold data temporarily
-    io_buffer = ChunkedIOBuffer(chunk_size)
-
-    # create zip writer that will write to the io buffer
-    zip_writer = zf.ZipFile(io_buffer, mode='w')  # type: ignore
-
-    for file_path in files:
-        # generate zip info and prepare zip pointer for writing
-        z_info = zf.ZipInfo.from_file(file_path)
-        zip_pointer = zip_writer.open(z_info, mode='w')
-        if Path(file_path).is_file():
-            # read file chunk by chunk
-            with open(file_path, 'br') as file_pointer:
-                while True:
-                    chunk = file_pointer.read(chunk_size)
-                    if len(chunk) == 0:
-                        break
-                    # write the chunk to the zip
-                    zip_pointer.write(chunk)
-                    # if writing the chunk caused us to go over chunk_size, flush it
-                    if io_buffer.get_buffer_size() > chunk_size:
-                        yield io_buffer.read_chunk()
-
-        zip_pointer.close()
-
-    # flush any remaining data in the stream (e.g. zip file meta data)
-    zip_writer.close()
-    while True:
-        chunk = io_buffer.read_chunk()
-        if len(chunk) == 0:
-            break
-        yield chunk
-
-
-def create_large_file_system(lfs_uri: str):
-    BiolibApiClient.assert_is_signed_in(authenticated_action_description='create a Large File System')
-    lfs_account, lfs_name = _get_lfs_info_from_uri(lfs_uri)
-    lfs_resource = BiolibLargeFileSystemApi.create(account_uuid=lfs_account['public_id'], name=lfs_name)
-    logger.info(f"Successfully created new Large File System '{lfs_resource['uri']}'")
-
-
-def push_large_file_system(lfs_uri: str, input_dir: str, chunk_size_in_mb: Optional[int] = None) -> None:
-    BiolibApiClient.assert_is_signed_in(authenticated_action_description='push data to a Large File System')
-
-    if not os.path.isdir(input_dir):
-        raise BioLibError(f'Could not find folder at {input_dir}')
-
-    if os.path.realpath(input_dir) == '/':
-        raise BioLibError('Pushing your root directory is not possible')
-
-    lfs_resource = BioLibApp(lfs_uri)
-
-    original_working_dir = os.getcwd()
-    os.chdir(input_dir)
-    files_to_zip, data_size_in_bytes = get_files_and_size_of_directory(directory=os.getcwd())
-
-    if data_size_in_bytes > 4_500_000_000_000:
-        raise BioLibError('Attempted to push directory with a size larger than the limit of 4.5 TB')
-
-    min_chunk_size_bytes = 10_000_000
-    chunk_size_in_bytes: int
-    if chunk_size_in_mb:
-        chunk_size_in_bytes = chunk_size_in_mb * 1_000_000  # Convert megabytes to bytes
-        if chunk_size_in_bytes < min_chunk_size_bytes:
-            logger.warning('Specified chunk size is too small, using minimum of 10 MB instead.')
-            chunk_size_in_bytes = min_chunk_size_bytes
-    else:
-        # Calculate chunk size based on max chunk count of 10_000, using 9_000 to be on the safe side
-        chunk_size_in_bytes = max(min_chunk_size_bytes, int(data_size_in_bytes / 9_000))
-
-    data_size_in_mb = round(data_size_in_bytes / 10 ** 6)
-    print(f'Zipping {len(files_to_zip)} files, in total ~{data_size_in_mb}mb of data')
-
-    lfs_resource_version = BiolibLargeFileSystemApi.create_version(resource_uuid=lfs_resource.uuid)
-    lfs_resource_version_uuid = lfs_resource_version['uuid']
-
-    iterable_zip_stream = get_iterable_zip_stream(files=files_to_zip, chunk_size=chunk_size_in_bytes)
-
-    multipart_uploader = utils.MultiPartUploader(
-        use_process_pool=True,
-        get_presigned_upload_url_request=dict(
-            headers=None,
-            requires_biolib_auth=True,
-            path=f'/lfs/versions/{lfs_resource_version_uuid}/presigned_upload_url/',
-        ),
-        complete_upload_request=dict(
-            headers=None,
-            requires_biolib_auth=True,
-            path=f'/lfs/versions/{lfs_resource_version_uuid}/complete_upload/',
-        ),
-    )
-
-    multipart_uploader.upload(payload_iterator=iterable_zip_stream, payload_size_in_bytes=data_size_in_bytes)
-    logger.info(f"Successfully pushed a new LFS version '{lfs_resource_version['uri']}'")
-    os.chdir(original_working_dir)
-
-
-def describe_large_file_system(lfs_uri: str, output_as_json: bool = False) -> None:
-    BiolibApiClient.assert_is_signed_in(authenticated_action_description='describe a Large File System')
-    lfs_resource = BioLibApp(lfs_uri)
-    lfs_version = BiolibLargeFileSystemApi.fetch_version(lfs_version_uuid=lfs_resource.version['public_id'])
-
-    files = []
-    total_size = 0
-    with RemoteZip(url=lfs_version['presigned_download_url']) as remote_zip:
-        central_directory = remote_zip.get_central_directory()
-        for file in central_directory.values():
-            files.append(dict(path=file['filename'], size_bytes=file['file_size']))
-            total_size += file['file_size']
-
-    lfs_version_metadata = dict(files=files, **lfs_version)
-    lfs_version_metadata['size_bytes'] = total_size
-
-    if output_as_json:
-        print(json.dumps(lfs_version_metadata, indent=4))
-    else:
-        print(f"Large File System {lfs_version_metadata['uri']}\ntotal {lfs_version_metadata['size_bytes']} bytes\n")
-        print('size bytes    path')
-        for file in files:
-            size_string = str(file['size_bytes'])
-            leading_space_string = ' ' * (10 - len(size_string))
-            print(f"{leading_space_string}{size_string}    {file['path']}")
-
-
-def get_file_data_from_large_file_system(lfs_uri: str, file_path: str) -> bytes:
-    BiolibApiClient.assert_is_signed_in(authenticated_action_description='get file from a Large File System')
-    lfs_resource = BioLibApp(lfs_uri)
-    lfs_version = BiolibLargeFileSystemApi.fetch_version(lfs_version_uuid=lfs_resource.version['public_id'])
-    lfs_url = lfs_version['presigned_download_url']
-
-    with RemoteZip(lfs_url) as remote_zip:
-        central_directory = remote_zip.get_central_directory()
-        if file_path not in central_directory:
-            raise Exception('File not found in Large File System')
-
-        file_info = central_directory[file_path]
-
-        local_file_header_signature_bytes = b'\x50\x4b\x03\x04'
-        local_file_header_struct = Struct('<H2sHHHIIIHH')
-        LocalFileHeader = namedtuple('LocalFileHeader', (
-            'version',
-            'flags',
-            'compression_raw',
-            'mod_time',
-            'mod_date',
-            'crc_32_expected',
-            'compressed_size_raw',
-            'uncompressed_size_raw',
-            'file_name_len',
-            'extra_field_len',
-        ))
-
-        local_file_header_start = file_info['header_offset'] + len(local_file_header_signature_bytes)
-        local_file_header_end = local_file_header_start + local_file_header_struct.size
-
-        local_file_header_response = HttpClient.request(
-            url=lfs_url,
-            headers={'range': f'bytes={local_file_header_start}-{local_file_header_end - 1}'},
-            timeout_in_seconds=300,
-        )
-        local_file_header = LocalFileHeader._make(local_file_header_struct.unpack(local_file_header_response.content))
-
-        file_start = local_file_header_end + local_file_header.file_name_len + local_file_header.extra_field_len
-        file_end = file_start + file_info['file_size']
-
-        response = HttpClient.request(
-            url=lfs_url,
-            headers={'range': f'bytes={file_start}-{file_end - 1}'},
-            timeout_in_seconds=300,  # timeout after 5 min
-        )
-        return response.content

biolib/runtime/results.py

@@ -1,20 +0,0 @@
-import json
-
-from biolib import api
-
-
-def set_main_result_prefix(result_prefix: str) -> None:
-    try:
-        with open('/biolib/secrets/biolib_system_secret', mode='r') as system_secrets_file:
-            system_secrets = json.loads(system_secrets_file.read())
-    except Exception:  # pylint: disable=broad-except
-        raise Exception('Unable to load the BioLib runtime system secret') from None
-
-    if not system_secrets['version'].startswith('1.'):
-        raise Exception(f"Unexpected system secret version {system_secrets['version']} expected 1.x.x")
-
-    api.client.patch(
-        data={'result_name_prefix': result_prefix},
-        headers={'Job-Auth-Token': system_secrets['job_auth_token']},
-        path=f"/jobs/{system_secrets['job_uuid']}/main_result/",
-    )