karton-core 5.8.0__py3-none-any.whl → 5.9.0__py3-none-any.whl

karton/core/__version__.py

@@ -1 +1 @@
-__version__ = "5.8.0"
+__version__ = "5.9.0"

karton/core/asyncio/backend.py

@@ -12,7 +12,7 @@ from redis.asyncio.client import Pipeline
 from redis.exceptions import AuthenticationError
 
 from karton.core import Config, Task
-from karton.core.asyncio.resource import RemoteResource
+from karton.core.asyncio.resource import LocalResource, RemoteResource
 from karton.core.backend import (
     KARTON_BINDS_HSET,
     KARTON_TASK_NAMESPACE,
@@ -22,6 +22,7 @@ from karton.core.backend import (
     KartonMetrics,
     KartonServiceInfo,
 )
+from karton.core.resource import LocalResource as SyncLocalResource
 from karton.core.task import TaskState
 
 logger = logging.getLogger(__name__)
@@ -117,8 +118,9 @@ class KartonAsyncBackend(KartonBackendBase):
                 boto_session._credentials = creds  # type: ignore
                 return aioboto3.Session(botocore_session=boto_session)
 
-    @staticmethod
+    @classmethod
     async def make_redis(
+        cls,
         config,
         identity: Optional[str] = None,
         service_info: Optional[KartonServiceInfo] = None,
@@ -131,22 +133,9 @@ class KartonAsyncBackend(KartonBackendBase):
         :param service_info: Additional service identity metadata
         :return: Redis connection
         """
-        if service_info is not None:
-            client_name: Optional[str] = service_info.make_client_name()
-        else:
-            client_name = identity
-
-        redis_args = {
-            "host": config["redis"]["host"],
-            "port": config.getint("redis", "port", 6379),
-            "db": config.getint("redis", "db", 0),
-            "username": config.get("redis", "username"),
-            "password": config.get("redis", "password"),
-            "client_name": client_name,
-            # set socket_timeout to None if set to 0
-            "socket_timeout": config.getint("redis", "socket_timeout", 30) or None,
-            "decode_responses": True,
-        }
+        redis_args = cls.get_redis_configuration(
+            config, identity=identity, service_info=service_info
+        )
         try:
             rs = Redis(**redis_args)
             await rs.ping()
@@ -154,6 +143,7 @@ class KartonAsyncBackend(KartonBackendBase):
             # Maybe we've sent a wrong password.
             # Or maybe the server is not (yet) password protected
             # To make smooth transition possible, try to login insecurely
+            del redis_args["username"]
             del redis_args["password"]
             rs = Redis(**redis_args)
             await rs.ping()
@@ -168,6 +158,25 @@ class KartonAsyncBackend(KartonBackendBase):
         """
         return RemoteResource.from_dict(resource_spec, backend=self)
 
+    async def declare_task(self, task: Task) -> None:
+        """
+        Declares a new task to send it to the queue.
+
+        :param task: Task to declare
+        """
+        # Ensure all local resources have good buckets
+        for resource in task.iterate_resources():
+            if isinstance(resource, LocalResource) and not resource.bucket:
+                resource.bucket = self.default_bucket_name
+            if isinstance(resource, SyncLocalResource):
+                raise RuntimeError(
+                    "Synchronous resources are not supported. "
+                    "Use karton.core.asyncio.resource module instead."
+                )
+
+        # Register new task
+        await self.register_task(task)
+
     async def register_task(self, task: Task, pipe: Optional[Pipeline] = None) -> None:
         """
         Register or update task in Redis.

karton/core/asyncio/karton.py

@@ -12,7 +12,6 @@ from karton.core.__version__ import __version__
 from karton.core.backend import KartonBind, KartonMetrics
 from karton.core.config import Config
 from karton.core.exceptions import TaskTimeoutError
-from karton.core.resource import LocalResource as SyncLocalResource
 from karton.core.task import Task, TaskState
 
 from .backend import KartonAsyncBackend
@@ -81,18 +80,8 @@ class Producer(KartonAsyncBase):
         task.last_update = time.time()
         task.headers.update({"origin": self.identity})
 
-        # Ensure all local resources have good buckets
-        for resource in task.iterate_resources():
-            if isinstance(resource, LocalResource) and not resource.bucket:
-                resource.bucket = self.backend.default_bucket_name
-            if isinstance(resource, SyncLocalResource):
-                raise RuntimeError(
-                    "Synchronous resources are not supported. "
-                    "Use karton.core.asyncio.resource module instead."
-                )
-
         # Register new task
-        await self.backend.register_task(task)
+        await self.backend.declare_task(task)
 
         # Upload local resources
         for resource in task.iterate_resources():
@@ -222,7 +211,11 @@ class Consumer(KartonAsyncServiceBase):
             self.current_task = task
 
             if not task.matches_filters(self.filters):
-                self.log.info("Task rejected because binds are no longer valid.")
+                self.log.info(
+                    "Task rejected because binds are no longer valid. "
+                    "Rejected ask headers: %s",
+                    task.headers,
+                )
                 await self.backend.set_task_status(task, TaskState.FINISHED)
                 # Task rejected: end of processing
                 return
@@ -301,7 +294,13 @@ class Consumer(KartonAsyncServiceBase):
         if not old_bind:
             self.log.info("Service binds created.")
         elif old_bind != self._bind:
-            self.log.info("Binds changed, old service instances should exit soon.")
+            self.log.info(
+                "Binds changed, old service instances should exit soon. "
+                "Old binds: %s "
+                "New binds: %s",
+                old_bind,
+                self._bind,
+            )
 
         for task_filter in self.filters:
             self.log.info("Binding on: %s", task_filter)
@@ -312,7 +311,13 @@ class Consumer(KartonAsyncServiceBase):
             while True:
                 current_bind = await self.backend.get_bind(self.identity)
                 if current_bind != self._bind:
-                    self.log.info("Binds changed, shutting down.")
+                    self.log.info(
+                        "Binds changed, shutting down. "
+                        "Old binds: %s "
+                        "New binds: %s",
+                        self._bind,
+                        current_bind,
+                    )
                     break
                 if self.concurrency_semaphore is not None:
                     await self.concurrency_semaphore.acquire()

karton/core/backend.py

@@ -17,11 +17,12 @@ from botocore.credentials import (
 from botocore.session import get_session
 from redis import AuthenticationError, StrictRedis
 from redis.client import Pipeline
+from redis.connection import parse_url as parse_redis_url
 from urllib3.response import HTTPResponse
 
 from .config import Config
 from .exceptions import InvalidIdentityError
-from .resource import RemoteResource
+from .resource import LocalResource, RemoteResource
 from .task import Task, TaskPriority, TaskState
 from .utils import chunks, chunks_iter
 
@@ -142,6 +143,41 @@ class KartonBackendBase:
             raise RuntimeError("S3 default bucket is not defined in configuration")
         return bucket_name
 
+    @staticmethod
+    def get_redis_configuration(
+        config: Config,
+        identity: Optional[str] = None,
+        service_info: Optional[KartonServiceInfo] = None,
+    ) -> Dict[str, Any]:
+        if service_info is not None:
+            client_name: Optional[str] = service_info.make_client_name()
+        else:
+            client_name = identity
+
+        redis_url = config.get("redis", "url")
+        if redis_url is not None:
+            redis_conf = parse_redis_url(redis_url)
+        else:
+            redis_conf = {
+                "host": config["redis"]["host"],
+                "port": config.getint("redis", "port", 6379),
+                "db": config.getint("redis", "db", 0),
+                "ssl": config.getboolean("redis", "ssl", False),
+            }
+
+        if username := config.get("redis", "username"):
+            redis_conf["username"] = username
+            password = config.get("redis", "password")
+            if password is None:
+                raise RuntimeError("You must set both username and password, or none")
+            redis_conf["password"] = password
+        # Don't set if set to 0
+        if socket_timeout := config.get("redis", "socket_timeout", 30):
+            redis_conf["socket_timeout"] = socket_timeout
+        redis_conf["client_name"] = client_name
+        redis_conf["decode_responses"] = True
+        return redis_conf
+
     @staticmethod
     def get_queue_name(identity: str, priority: TaskPriority) -> str:
         """
@@ -302,8 +338,9 @@ class KartonBackend(KartonBackendBase):
                     endpoint_url=endpoint,
                 )
 
-    @staticmethod
+    @classmethod
     def make_redis(
+        cls,
         config,
         identity: Optional[str] = None,
         service_info: Optional[KartonServiceInfo] = None,
@@ -316,22 +353,9 @@ class KartonBackend(KartonBackendBase):
         :param service_info: Additional service identity metadata
         :return: Redis connection
         """
-        if service_info is not None:
-            client_name: Optional[str] = service_info.make_client_name()
-        else:
-            client_name = identity
-
-        redis_args = {
-            "host": config["redis"]["host"],
-            "port": config.getint("redis", "port", 6379),
-            "db": config.getint("redis", "db", 0),
-            "username": config.get("redis", "username"),
-            "password": config.get("redis", "password"),
-            "client_name": client_name,
-            # set socket_timeout to None if set to 0
-            "socket_timeout": config.getint("redis", "socket_timeout", 30) or None,
-            "decode_responses": True,
-        }
+        redis_args = cls.get_redis_configuration(
+            config, identity=identity, service_info=service_info
+        )
         try:
             redis = StrictRedis(**redis_args)
             redis.ping()
@@ -339,6 +363,7 @@ class KartonBackend(KartonBackendBase):
             # Maybe we've sent a wrong password.
             # Or maybe the server is not (yet) password protected
             # To make smooth transition possible, try to login insecurely
+            del redis_args["username"]
             del redis_args["password"]
             redis = StrictRedis(**redis_args)
             redis.ping()
@@ -631,10 +656,29 @@ class KartonBackend(KartonBackendBase):
             task_keys, chunk_size=chunk_size, parse_resources=parse_resources
         )
 
+    def declare_task(self, task: Task) -> None:
+        """
+        Declares a new task to send it to the queue.
+
+        Task producers should use this method for new tasks.
+
+        :param task: Task to declare
+        """
+        # Ensure all local resources have good buckets
+        for resource in task.iterate_resources():
+            if isinstance(resource, LocalResource) and not resource.bucket:
+                resource.bucket = self.default_bucket_name
+
+        # Register new task
+        self.register_task(task)
+
     def register_task(self, task: Task, pipe: Optional[Pipeline] = None) -> None:
         """
         Register or update task in Redis.
 
+        This method is used internally to alter task data. If you want to declare new
+        task in Redis, use declare_task.
+
         :param task: Task object
         :param pipe: Optional pipeline object if operation is a part of pipeline
         """

karton/core/base.py

@@ -131,11 +131,11 @@ class LoggingMixin:
         if not self.identity:
             raise ValueError("Can't setup logger without identity")
 
+        task_context_filter = TaskContextFilter()
         self._log_handler.setFormatter(logging.Formatter())
+        self._log_handler.addFilter(task_context_filter)
 
         logger = logging.getLogger(self.identity)
-        logger.addFilter(TaskContextFilter())
-
         if logger.handlers:
             # If logger already have handlers set: clear them
             logger.handlers.clear()
@@ -148,6 +148,7 @@ class LoggingMixin:
         logger.setLevel(log_level)
         stream_handler = logging.StreamHandler()
         stream_handler.setFormatter(logging.Formatter(self._log_format))
+        stream_handler.addFilter(task_context_filter)
         logger.addHandler(stream_handler)
 
         if not self.debug and self.enable_publish_log:

karton/core/config.py

@@ -14,6 +14,7 @@ class Config(object):
     - ``/etc/karton/karton.ini`` (global)
     - ``~/.config/karton/karton.ini`` (user local)
     - ``./karton.ini`` (subsystem local)
+    - path from ``KARTON_CONFIG_FILE`` environment variable
     - ``<path>`` optional, additional path provided in arguments
 
     It is also possible to pass configuration via environment variables.
@@ -38,6 +39,12 @@ class Config(object):
     ) -> None:
         self._config: Dict[str, Dict[str, Any]] = {}
 
+        path_from_env = os.getenv("KARTON_CONFIG_FILE")
+        if path_from_env:
+            if not os.path.isfile(path_from_env):
+                raise IOError(f"Configuration file not found in {path_from_env}")
+            self.SEARCH_PATHS = self.SEARCH_PATHS + [path_from_env]
+
         if path is not None:
             if not os.path.isfile(path):
                 raise IOError("Configuration file not found in " + path)
@@ -222,7 +229,7 @@ class Config(object):
         for name, value in os.environ.items():
             # Load env variables named KARTON_[section]_[key]
             # to match ConfigParser structure
-            result = re.fullmatch(r"KARTON_([A-Z0-9-]+)_([A-Z0-9_]+)", name)
+            result = re.fullmatch(r"KARTON_([A-Z0-9\-\.]+)_([A-Z0-9_]+)", name)
 
             if not result:
                 continue

karton/core/karton.py

@@ -80,13 +80,8 @@ class Producer(KartonBase):
         task.last_update = time.time()
         task.headers.update({"origin": self.identity})
 
-        # Ensure all local resources have good buckets
-        for resource in task.iterate_resources():
-            if isinstance(resource, LocalResource) and not resource.bucket:
-                resource.bucket = self.backend.default_bucket_name
-
         # Register new task
-        self.backend.register_task(task)
+        self.backend.declare_task(task)
 
         # Upload local resources
         for resource in task.iterate_resources():
@@ -172,7 +167,11 @@ class Consumer(KartonServiceBase):
         self.current_task = task
 
         if not task.matches_filters(self.filters):
-            self.log.info("Task rejected because binds are no longer valid.")
+            self.log.info(
+                "Task rejected because binds are no longer valid. "
+                "Rejected ask headers: %s",
+                task.headers,
+            )
             self.backend.set_task_status(task, TaskState.FINISHED)
             # Task rejected: end of processing
             return
@@ -339,15 +338,28 @@ class Consumer(KartonServiceBase):
         if not old_bind:
             self.log.info("Service binds created.")
         elif old_bind != self._bind:
-            self.log.info("Binds changed, old service instances should exit soon.")
+            self.log.info(
+                "Binds changed, old service instances should exit soon. "
+                "Old binds: %s "
+                "New binds: %s",
+                old_bind,
+                self._bind,
+            )
 
         for task_filter in self.filters:
             self.log.info("Binding on: %s", task_filter)
 
         with self.graceful_killer():
             while not self.shutdown:
-                if self.backend.get_bind(self.identity) != self._bind:
-                    self.log.info("Binds changed, shutting down.")
+                current_bind = self.backend.get_bind(self.identity)
+                if current_bind != self._bind:
+                    self.log.info(
+                        "Binds changed, shutting down. "
+                        "Old binds: %s "
+                        "New binds: %s",
+                        self._bind,
+                        current_bind,
+                    )
                     break
                 task = self.backend.consume_routed_task(self.identity)
                 if task:

karton/core/main.py

@@ -144,10 +144,23 @@ def configuration_wizard(config_filename: str) -> None:
     log.info("Saved the new configuration file in %s", os.path.abspath(config_filename))
 
 
-def print_bind_list(config: Config) -> None:
+def print_bind_list(config: Config, output_format: str) -> None:
     backend = KartonBackend(config=config)
-    for bind in backend.get_binds():
-        print(bind)
+
+    if output_format == "table":
+        # Print a human-readable table-like version
+        print(f"{'karton name':50} {'version':10} {'karton':10}")
+        print("-" * 72)
+        for bind in backend.get_binds():
+            print(
+                f"{bind.identity:50} {bind.service_version or "-":10} {bind.version:10}"
+            )
+    elif output_format == "json":
+        # Use JSONL, each line is a JSON representing next bind
+        for bind in backend.get_binds():
+            print(backend.serialize_bind(bind))
+    else:
+        raise RuntimeError(f"Invalid output format: {output_format}")
 
 
 def delete_bind(config: Config, karton_name: str) -> None:
@@ -180,7 +193,7 @@ def delete_bind(config: Config, karton_name: str) -> None:
 
 def main() -> None:
 
-    parser = argparse.ArgumentParser(description="Your red pill to the karton-verse")
+    parser = argparse.ArgumentParser(description="Karton-core management utility")
     parser.add_argument("--version", action="version", version=__version__)
     parser.add_argument("-c", "--config-file", help="Alternative configuration path")
     parser.add_argument(
@@ -189,7 +202,14 @@ def main() -> None:
 
     subparsers = parser.add_subparsers(dest="command", help="sub-command help")
 
-    subparsers.add_parser("list", help="List active karton binds")
+    list_parser = subparsers.add_parser("list", help="List active karton binds")
+    list_parser.add_argument(
+        "-o",
+        "--output",
+        help="Short, human readable output, with names and versions only.",
+        default="table",
+        choices=("table", "json"),
+    )
 
     logs_parser = subparsers.add_parser("logs", help="Start streaming logs")
     logs_parser.add_argument(
@@ -253,7 +273,7 @@ def main() -> None:
         return
 
     if args.command == "list":
-        print_bind_list(config)
+        print_bind_list(config, args.output)
     elif args.command == "delete":
         karton_name = args.identity
         print(

karton/core/test.py

@@ -35,8 +35,12 @@ class BackendMock:
     def default_bucket_name(self) -> str:
         return "karton.test"
 
-    def register_task(self, task: Task, pipe=None) -> None:
-        log.debug("Registering a new task in Redis: %s", task.serialize())
+    def declare_task(self, task: Task) -> None:
+        # Ensure all local resources have good buckets
+        for resource in task.iterate_resources():
+            if isinstance(resource, LocalResource) and not resource.bucket:
+                resource.bucket = self.default_bucket_name
+        log.debug("Declaring a new task in Redis: %s", task.serialize())
 
     def set_task_status(self, task: Task, status: TaskState, pipe=None) -> None:
         log.debug("Setting task %s status to %s", task.uid, status)

{karton_core-5.8.0.dist-info → karton_core-5.9.0.dist-info}/METADATA

@@ -1,18 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: karton-core
-Version: 5.8.0
+Version: 5.9.0
 Summary: Distributed malware analysis orchestration framework
-Home-page: https://github.com/CERT-Polska/karton
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/CERT-Polska/karton
+Project-URL: Documentation, https://karton-core.readthedocs.io/
+Project-URL: Repository, https://github.com/CERT-Polska/karton
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Classifier: License :: OSI Approved :: BSD License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aioboto3 ==14.3.0
-Requires-Dist: boto3 <1.37.4,>=1.37.2
-Requires-Dist: orjson
 Requires-Dist: redis
+Requires-Dist: orjson
+Requires-Dist: boto3<=1.35.81
+Requires-Dist: aioboto3==13.3.0
+Dynamic: license-file
 
 # Karton <img src="img/logo.svg" width="64">
 
@@ -82,6 +85,26 @@ if __name__ == "__main__":
     GenericUnpacker.main()
 ```
 
+## Command line
+
+This package also provies a command-line utility called "karton". You can use it for simple management tasks (but it's not designed as a fully capable management tool).
+
+```
+$ karton configure  # create a new configuration file
+
+$ karton list -s  # list current binds
+karton name                                        version    karton
+------------------------------------------------------------------------
+karton.yaramatcher                                 1.2.0      5.3.0
+karton.autoit-ripper                               1.2.1      5.3.3
+karton.mwdb-reporter                               1.3.0      5.3.2
+
+$ karton logs  # start streaming all system logs
+
+$ karton delete karton.something  # remove unused bind (will be GCed by system during the next operation)
+```
+
+
 ## Karton systems
 
 Some Karton systems are universal and useful to everyone. We decided to share them with the community.

{karton_core-5.8.0.dist-info → karton_core-5.9.0.dist-info}/RECORD

@@ -1,33 +1,31 @@
-karton_core-5.8.0-nspkg.pth,sha256=vHa-jm6pBTeInFrmnsHMg9AOeD88czzQy-6QCFbpRcM,539
 karton/core/__init__.py,sha256=QuT0BWZyp799eY90tK3H1OD2hwuusqMJq8vQwpB3kG4,337
-karton/core/__version__.py,sha256=duDTiv1rL8Ee9_jtzzhpq-j4xkkpVPkUh2Daa_Ou-xA,22
-karton/core/backend.py,sha256=3tmjAM35jaoZr_5QqarcVH81LvKMEB63vyvMKCYXPCM,39934
-karton/core/base.py,sha256=6PEQiEWHjMtJKRj0dfgEEpNhgSRoKOBYF1WBlrmyBp0,9064
-karton/core/config.py,sha256=UTd0hLqYNUttfI7FYUDOJPaz-C3uj1Kw7xxataTG_OM,8234
+karton/core/__version__.py,sha256=K8QUWqtzm0RvyvMi0shZurlcbRE1MiHY43oJIJLcGF0,22
+karton/core/backend.py,sha256=IhqK-Pia3RjUGHdWEtV7ruFr3w6rhDETrewU3DQo-Pw,41547
+karton/core/base.py,sha256=mbsZKna9TNqGpvDMwp2nuc9KvlevwOH94ubu0rJvVgk,9178
+karton/core/config.py,sha256=7nZHQ_25k-dyofohiubOPUBISY3f362gJTh80Igyh4U,8580
 karton/core/exceptions.py,sha256=8i9WVzi4PinNlX10Cb-lQQC35Hl-JB5R_UKXa9AUKoQ,153
 karton/core/inspect.py,sha256=aIJQEOEkD5q2xLlV8nhxY5qL5zqcnprP-2DdP6ecKlE,6150
-karton/core/karton.py,sha256=4CISOmUTfaEaCJUtbYxJSBMzydT27o3a-R14VBNpmr0,15269
+karton/core/karton.py,sha256=SUcu1V0Xehq5X5EFp91uaulaefZoF1ObYlEV6VsBZrQ,15522
 karton/core/logger.py,sha256=UhYCoVARXaatvoJ2lO2mfBHeODOS7z8O-vqdeQhNmV4,2654
-karton/core/main.py,sha256=ir1-dhn3vbwfh2YHiM6ZYfRBbjwLvJSz0d8tuK1mb_4,8310
+karton/core/main.py,sha256=2teV0W4W672fzDk6zNcRF77qhhac1_peN3aEWpGXOdQ,9109
 karton/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 karton/core/query.py,sha256=sf24DweVlXfJuBbBD_ns2LXhOV-IBwuPG3jBfTJu77s,12063
 karton/core/resource.py,sha256=GkU3JGSP1kOsAoblon4BWbQp31eZiDsCjaaDKanEokk,20872
 karton/core/task.py,sha256=QvAsSUIsyYiRmkgxgugrYkHWH2gczrFDfw2V4izdt1E,19566
-karton/core/test.py,sha256=cj6W4gNt0BpRjsYiiBt0hPE8dmRfUeIc8sSVkxB50cU,9123
+karton/core/test.py,sha256=TwLXnyNvTvZbnYTjiB4PhW0F_mXiiov4fhLL5Cs2-6I,9349
 karton/core/utils.py,sha256=sEVqGdVPyYswWuVn8wYXBQmln8Az826N_2HgC__pmW8,4090
 karton/core/asyncio/__init__.py,sha256=ZgndeKzS3Yg2o8hebwFYJWlCRdW3ImdCOShK4EVmZ14,457
-karton/core/asyncio/backend.py,sha256=GF0z9YxWvUKYkvnBatCDthX0M9Kwt9cRfVSWQq5bc9E,12751
+karton/core/asyncio/backend.py,sha256=fyOl5kA_KJ-SUyTPzR9ZU5Iz_6vvUb0Je3SVaBQrs6U,13057
 karton/core/asyncio/base.py,sha256=YDNGyWzgVvt2TnfKvHYbJbcNJaQl95bdBq45YGEo-3Q,4246
-karton/core/asyncio/karton.py,sha256=LhzMGuJsmXdTEa323gZted8KgVfHH6l0j0_tTqMh4Z4,12932
+karton/core/asyncio/karton.py,sha256=sWzwsBBbAhO32TIu7hi0R9HAWlcN_SzgrmaloEgwsgY,12844
 karton/core/asyncio/logger.py,sha256=BjkbuAeWylTmFjWv8-ckmOGf4nL2Tma96W0nIOc2vwk,1752
 karton/core/asyncio/resource.py,sha256=86AYm7JeVjEYRNw--h02HIS9xFvgddhktmDUp0qvTO4,12517
 karton/system/__init__.py,sha256=JF51OqRU_Y4c0unOulvmv1KzSHSq4ZpXU8ZsH4nefRM,63
 karton/system/__main__.py,sha256=QJkwIlSwaPRdzwKlNmCAL41HtDAa73db9MZKWmOfxGM,56
 karton/system/system.py,sha256=d_5hhLTthJdr_4gZEGQ6Y-kHvxeBqyQxjjx_wRs3xMA,17285
-karton_core-5.8.0.dist-info/LICENSE,sha256=o8h7hYhn7BJC_-DmrfqWwLjaR_Gbe0TZOOQJuN2ca3I,1519
-karton_core-5.8.0.dist-info/METADATA,sha256=26n1VrX-0ESRMG7fug5hqKxYT1URIa_NgypF5N1E2gg,6860
-karton_core-5.8.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-karton_core-5.8.0.dist-info/entry_points.txt,sha256=OgLlsXy61GP6-Yob3oXqeJ2hlRU6LBLj33fr0NufKz0,98
-karton_core-5.8.0.dist-info/namespace_packages.txt,sha256=X8SslCPsqXDCnGZqrYYolzT3xPzJMq1r-ZQSc0jfAEA,7
-karton_core-5.8.0.dist-info/top_level.txt,sha256=X8SslCPsqXDCnGZqrYYolzT3xPzJMq1r-ZQSc0jfAEA,7
-karton_core-5.8.0.dist-info/RECORD,,
+karton_core-5.9.0.dist-info/licenses/LICENSE,sha256=o8h7hYhn7BJC_-DmrfqWwLjaR_Gbe0TZOOQJuN2ca3I,1519
+karton_core-5.9.0.dist-info/METADATA,sha256=r6CDk__eoUHVC2zufKRsKr64ZGgz_xII1tFSZulMkv4,7788
+karton_core-5.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+karton_core-5.9.0.dist-info/entry_points.txt,sha256=OgLlsXy61GP6-Yob3oXqeJ2hlRU6LBLj33fr0NufKz0,98
+karton_core-5.9.0.dist-info/top_level.txt,sha256=X8SslCPsqXDCnGZqrYYolzT3xPzJMq1r-ZQSc0jfAEA,7
+karton_core-5.9.0.dist-info/RECORD,,

{karton_core-5.8.0.dist-info → karton_core-5.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

karton_core-5.8.0-nspkg.pth

@@ -1 +0,0 @@
-import sys, types, os;has_mfs = sys.version_info > (3, 5);p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('karton',));importlib = has_mfs and __import__('importlib.util');has_mfs and __import__('importlib.machinery');m = has_mfs and sys.modules.setdefault('karton', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('karton', [os.path.dirname(p)])));m = m or sys.modules.setdefault('karton', types.ModuleType('karton'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p)

karton_core-5.8.0.dist-info/namespace_packages.txt

@@ -1 +0,0 @@
-karton