edq-utils 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

edq/util/json.py

@@ -0,0 +1,80 @@
+"""
+This file standardizes how we write and read JSON.
+Specifically, we try to be flexible when reading (using JSON5),
+and strict when writing (using vanilla JSON).
+"""
+
+import json
+import typing
+
+import json5
+
+import edq.util.dirent
+
+def load(file_obj: typing.TextIO, strict: bool = False, **kwargs) -> typing.Dict[str, typing.Any]:
+    """
+    Load a file object/handler as JSON.
+    If strict is set, then use standard Python JSON,
+    otherwise use JSON5.
+    """
+
+    if (strict):
+        return json.load(file_obj, **kwargs)
+
+    return json5.load(file_obj, **kwargs)
+
+def loads(text: str, strict: bool = False, **kwargs) -> typing.Dict[str, typing.Any]:
+    """
+    Load a string as JSON.
+    If strict is set, then use standard Python JSON,
+    otherwise use JSON5.
+    """
+
+    if (strict):
+        return json.loads(text, **kwargs)
+
+    return json5.loads(text, **kwargs)
+
+def load_path(
+        path: str,
+        strict: bool = False,
+        encoding: str = edq.util.dirent.DEFAULT_ENCODING,
+        **kwargs) -> typing.Dict[str, typing.Any]:
+    """
+    Load a file path as JSON.
+    If strict is set, then use standard Python JSON,
+    otherwise use JSON5.
+    """
+
+    try:
+        with open(path, 'r', encoding = encoding) as file:
+            return load(file, strict = strict, **kwargs)
+    except Exception as ex:
+        raise ValueError(f"Failed to read JSON file '{path}'.") from ex
+
+def dump(
+        data: typing.Any,
+        file_obj: typing.TextIO,
+        sort_keys: bool = True,
+        **kwargs) -> None:
+    """ Dump an object as a JSON file object. """
+
+    json.dump(data, file_obj, sort_keys = sort_keys, **kwargs)
+
+def dumps(
+        data: typing.Any,
+        sort_keys: bool = True,
+        **kwargs) -> str:
+    """ Dump an object as a JSON string. """
+
+    return json.dumps(data, sort_keys = sort_keys, **kwargs)
+
+def dump_path(
+        data: typing.Any,
+        path: str,
+        encoding: str = edq.util.dirent.DEFAULT_ENCODING,
+        **kwargs) -> None:
+    """ Dump an object as a JSON file. """
+
+    with open(path, 'w', encoding = encoding) as file:
+        dump(data, file, **kwargs)

edq/util/json_test.py

@@ -0,0 +1,121 @@
+import os
+
+import edq.testing.unittest
+import edq.util.dirent
+import edq.util.json
+import edq.util.reflection
+
+class TestJSON(edq.testing.unittest.BaseTest):
+    """ Test JSON utils. """
+
+    def test_loading_dumping_base(self):
+        """
+        Test the family of JSON loading and dumping functions.
+        """
+
+        # [(string, dict, strict?, error_substring), ...]
+        test_cases = [
+            # Base
+            (
+                '{"a": 1}',
+                {"a": 1},
+                False,
+                None,
+            ),
+
+            # Trivial - Strict
+            (
+                '{"a": 1}',
+                {"a": 1},
+                True,
+                None,
+            ),
+
+            # JSON5
+            (
+                '{"a": 1,}',
+                {"a": 1},
+                False,
+                None,
+            ),
+
+            # JSON5 - Strict
+            (
+                '{"a": 1,}',
+                {"a": 1},
+                True,
+                'JSONDecodeError',
+            ),
+        ]
+
+        # [(function, name), ...]
+        test_methods = [
+            (self._subtest_loads_dumps, 'subtest_loads_dumps'),
+            (self._subtest_load_dump, 'subtest_load_dump'),
+            (self._subtest_load_dump_path, 'subtest_load_dump_path'),
+        ]
+
+        for (test_method, test_method_name) in test_methods:
+            for (i, test_case) in enumerate(test_cases):
+                (text_content, dict_content, strict, error_substring) = test_case
+
+                with self.subTest(msg = f"Subtest {test_method_name}, Case {i} ('{text_content}'):"):
+                    try:
+                        test_method(text_content, dict_content, strict)
+                    except AssertionError:
+                        # The subttest failed an assertion.
+                        raise
+                    except Exception as ex:
+                        error_string = self.format_error_string(ex)
+                        if (error_substring is None):
+                            self.fail(f"Unexpected error: '{error_string}'.")
+
+                        self.assertIn(error_substring, error_string, 'Error is not as expected.')
+
+                        continue
+
+                    if (error_substring is not None):
+                        self.fail(f"Did not get expected error: '{error_substring}'.")
+
+    def _subtest_loads_dumps(self, text_content, dict_content, strict):
+        actual_dict = edq.util.json.loads(text_content, strict = strict)
+        actual_text = edq.util.json.dumps(dict_content)
+        double_conversion_dict = edq.util.json.dumps(actual_dict)
+
+        self.assertDictEqual(dict_content, actual_dict)
+        self.assertEqual(actual_text, double_conversion_dict)
+
+    def _subtest_load_dump(self, text_content, dict_content, strict):
+        temp_dir = edq.util.dirent.get_temp_dir(prefix = 'edq_test_json_')
+
+        path_text = os.path.join(temp_dir, 'test-text.json')
+        path_dict = os.path.join(temp_dir, 'test-dict.json')
+
+        edq.util.dirent.write_file(path_text, text_content)
+
+        with open(path_text, 'r', encoding = edq.util.dirent.DEFAULT_ENCODING) as file:
+            text_load = edq.util.json.load(file, strict = strict)
+
+        with open(path_dict, 'w', encoding = edq.util.dirent.DEFAULT_ENCODING) as file:
+            edq.util.json.dump(dict_content, file)
+
+        with open(path_dict, 'r', encoding = edq.util.dirent.DEFAULT_ENCODING) as file:
+            dict_load = edq.util.json.load(file, strict = strict)
+
+        self.assertDictEqual(dict_content, text_load)
+        self.assertDictEqual(dict_load, text_load)
+
+    def _subtest_load_dump_path(self, text_content, dict_content, strict):
+        temp_dir = edq.util.dirent.get_temp_dir(prefix = 'edq_test_json_path_')
+
+        path_text = os.path.join(temp_dir, 'test-text.json')
+        path_dict = os.path.join(temp_dir, 'test-dict.json')
+
+        edq.util.dirent.write_file(path_text, text_content)
+        text_load = edq.util.json.load_path(path_text, strict = strict)
+
+        edq.util.json.dump_path(dict_content, path_dict)
+        dict_load = edq.util.json.load_path(path_dict, strict = strict)
+
+        self.assertDictEqual(dict_content, text_load)
+        self.assertDictEqual(dict_load, text_load)

edq/util/pyimport.py

@@ -0,0 +1,73 @@
+import importlib
+import importlib.util
+import os
+import typing
+import uuid
+
+import edq.util.dirent
+
+_import_cache: typing.Dict[str, typing.Any] = {}
+""" A cache to help avoid importing a module multiple times. """
+
+def import_path(raw_path: str, cache: bool = True, module_name: typing.Union[str, None] = None) -> typing.Any:
+    """
+    Import a module from a file.
+    If cache is false, then the module will not be fetched or stored in this module's cache.
+    """
+
+    path = os.path.abspath(raw_path)
+    cache_key = f"PATH::{path}"
+
+    # Check the cache before importing.
+    if (cache):
+        module = _import_cache.get(cache_key, None)
+        if (module is not None):
+            return module
+
+    if (not edq.util.dirent.exists(path)):
+        raise ValueError(f"Module path does not exist: '{raw_path}'.")
+
+    if (not os.path.isfile(path)):
+        raise ValueError(f"Module path is not a file: '{raw_path}'.")
+
+    if (module_name is None):
+        module_name = str(uuid.uuid4()).replace('-', '')
+
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    if ((spec is None) or (spec.loader is None)):
+        raise ValueError(f"Failed to load module specification for path: '{raw_path}'.")
+
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    # Store the module in the cache.
+    if (cache):
+        _import_cache[cache_key] = module
+
+    return module
+
+def import_name(module_name: str, cache: bool = True) -> typing.Any:
+    """
+    Import a module from a name.
+    The module must already be in the system's path (sys.path).
+    If cache is false, then the module will not be fetched or stored in this module's cache.
+    """
+
+    cache_key = f"NAME::{module_name}"
+
+    # Check the cache before importing.
+    if (cache):
+        module = _import_cache.get(cache_key, None)
+        if (module is not None):
+            return module
+
+    try:
+        module = importlib.import_module(module_name)
+    except ImportError as ex:
+        raise ValueError(f"Unable to locate module '{module_name}'.") from ex
+
+    # Store the module in the cache.
+    if (cache):
+        _import_cache[cache_key] = module
+
+    return module

edq/util/pyimport_test.py

@@ -0,0 +1,83 @@
+import os
+
+import edq.testing.unittest
+import edq.util.pyimport
+
+THIS_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
+PACKAGE_ROOT_DIR = os.path.join(THIS_DIR, '..')
+
+class TestPyImport(edq.testing.unittest.BaseTest):
+    """ Test Python importing operations. """
+
+    def test_import_path_base(self):
+        """ Test importing a module from a path. """
+
+        # [(relative path, error substring), ...]
+        # All paths are relative to the package root.
+        test_cases = [
+            # Standard Module
+            (os.path.join('util', 'pyimport.py'), None),
+
+            # Errors
+            ('ZZZ', 'Module path does not exist'),
+            ('util', 'Module path is not a file'),
+        ]
+
+        for (i, test_case) in enumerate(test_cases):
+            (relpath, error_substring) = test_case
+
+            with self.subTest(msg = f"Case {i} ('{relpath}'):"):
+                path = os.path.join(PACKAGE_ROOT_DIR, relpath)
+
+                try:
+                    module = edq.util.pyimport.import_path(path)
+                except Exception as ex:
+                    error_string = self.format_error_string(ex)
+                    if (error_substring is None):
+                        self.fail(f"Unexpected error: '{error_string}'.")
+
+                    self.assertIn(error_substring, error_string, 'Error is not as expected.')
+
+                    continue
+
+                if (error_substring is not None):
+                    self.fail(f"Did not get expected error: '{error_substring}'.")
+
+                self.assertIsNotNone(module)
+
+    def test_import_name_base(self):
+        """ Test importing a module from a name. """
+
+        # [(name, error substring), ...]
+        test_cases = [
+            # Standard Module
+            ('edq.util.pyimport', None),
+
+            # Package (__init__.py)
+            ('edq.util', None),
+
+            # Errors
+            ('', 'Empty module name'),
+            ('edq.util.ZZZ', 'Unable to locate module'),
+            ('edq.util.pyimport.ZZZ', 'Unable to locate module'),
+        ]
+
+        for (i, test_case) in enumerate(test_cases):
+            (name, error_substring) = test_case
+
+            with self.subTest(msg = f"Case {i} ('{name}'):"):
+                try:
+                    module = edq.util.pyimport.import_name(name)
+                except Exception as ex:
+                    error_string = self.format_error_string(ex)
+                    if (error_substring is None):
+                        self.fail(f"Unexpected error: '{error_string}'.")
+
+                    self.assertIn(error_substring, error_string, 'Error is not as expected.')
+
+                    continue
+
+                if (error_substring is not None):
+                    self.fail(f"Did not get expected error: '{error_substring}'.")
+
+                self.assertIsNotNone(module)

edq/util/reflection.py

@@ -0,0 +1,32 @@
+import typing
+
+def get_qualified_name(target: typing.Union[type, object, str]) -> str:
+    """
+    Try to get a qualified name for a type (or for the type of an object).
+    Names will not always come out clean.
+    """
+
+    # Get the type for this target.
+    if (isinstance(target, type)):
+        target_class = target
+    elif (callable(target)):
+        target_class = typing.cast(type, target)
+    else:
+        target_class = type(target)
+
+    # Check for various name components.
+    parts = []
+
+    if (hasattr(target_class, '__module__')):
+        parts.append(str(getattr(target_class, '__module__')))
+
+    if (hasattr(target_class, '__qualname__')):
+        parts.append(str(getattr(target_class, '__qualname__')))
+    elif (hasattr(target_class, '__name__')):
+        parts.append(str(getattr(target_class, '__name__')))
+
+    # Fall back to just the string reprsentation.
+    if (len(parts) == 0):
+        return str(target_class)
+
+    return '.'.join(parts)

edq/util/time.py

@@ -0,0 +1,75 @@
+import datetime
+import time
+
+PRETTY_SHORT_FORMAT: str = '%Y-%m-%d %H:%M'
+
+class Duration(int):
+    """
+    A Duration represents some length in time in milliseconds.
+    """
+
+    def to_secs(self) -> float:
+        """ Convert the duration to float seconds. """
+
+        return self / 1000.0
+
+    def to_msecs(self) -> int:
+        """ Convert the duration to integer milliseconds. """
+
+        return self
+
+class Timestamp(int):
+    """
+    A Timestamp represent a moment in time (sometimes called "datetimes").
+    Timestamps are internally represented by the number of milliseconds since the
+    (Unix Epoch)[https://en.wikipedia.org/wiki/Unix_time].
+    This is sometimes referred to as "Unix Time".
+    Since Unix Time is in UTC, timestamps do not need to carry timestamp information with them.
+
+    Note that timestamps are just integers with some decoration,
+    so they respond to all normal int functionality.
+    """
+
+    def sub(self, other: 'Timestamp') -> Duration:
+        """ Return a new duration that is the difference of this and the given duration. """
+
+        return Duration(self - other)
+
+    def to_pytime(self, timezone: datetime.timezone = datetime.timezone.utc) -> datetime.datetime:
+        """ Convert this timestamp to a Python datetime in the given timezone (UTC by default). """
+
+        return datetime.datetime.fromtimestamp(self / 1000, timezone)
+
+    def to_local_pytime(self) -> datetime.datetime:
+        """ Convert this timestamp to a Python datetime in the system timezone. """
+
+        local_timezone = datetime.datetime.now().astimezone().tzinfo
+        if ((local_timezone is None) or (not isinstance(local_timezone, datetime.timezone))):
+            raise ValueError("Could not discover local timezone.")
+
+        return self.to_pytime(timezone = local_timezone)
+
+    def pretty(self, short: bool = False, timezone: datetime.timezone = datetime.timezone.utc) -> str:
+        """
+        Get a "pretty" string representation of this timestamp.
+        There is no guarantee that this representation can be parsed back to its original form.
+        """
+
+        pytime = self.to_pytime(timezone = timezone)
+
+        if (short):
+            return pytime.strftime(PRETTY_SHORT_FORMAT)
+
+        return pytime.isoformat(timespec = 'milliseconds')
+
+    @staticmethod
+    def from_pytime(pytime: datetime.datetime) -> 'Timestamp':
+        """ Convert a Python datetime to a timestamp. """
+
+        return Timestamp(int(pytime.timestamp() * 1000))
+
+    @staticmethod
+    def now() -> 'Timestamp':
+        """ Get a Timestamp that represents the current moment. """
+
+        return Timestamp(time.time() * 1000)

edq/util/time_test.py

@@ -0,0 +1,107 @@
+import time
+import datetime
+
+import edq.testing.unittest
+import edq.util.time
+
+TIMEZONE_UTC: datetime.timezone = datetime.timezone.utc
+TIMEZONE_PST: datetime.timezone = datetime.timezone(datetime.timedelta(hours = -7), name = 'PST')
+TIMEZONE_CEST: datetime.timezone = datetime.timezone(datetime.timedelta(hours = 2), name = 'CEST')
+
+class TestTime(edq.testing.unittest.BaseTest):
+    """ Test time-based operations. """
+
+    def test_timestamp_now(self):
+        """ Test getting a timestamp for the current moment. """
+
+        start = edq.util.time.Timestamp.now()
+        time.sleep(0.01)
+        middle = edq.util.time.Timestamp.now()
+        time.sleep(0.01)
+        end = edq.util.time.Timestamp.now()
+
+        self.assertLessEqual(start, middle)
+        self.assertLessEqual(middle, end)
+
+    def test_timestamp_pytime_conversion(self):
+        """ Test converting between timestamps and Python datetimes. """
+
+        # [(timestamp, python time), ...]
+        test_cases = [
+            (edq.util.time.Timestamp(0), datetime.datetime(1970, 1, 1, 0, 0, 0, 0, TIMEZONE_UTC)),
+
+            (edq.util.time.Timestamp(1755139534019), datetime.datetime(2025, 8, 14, 2,  45, 34, 19000, TIMEZONE_UTC)),
+            (edq.util.time.Timestamp(1755139534019), datetime.datetime(2025, 8, 13, 19, 45, 34, 19000, TIMEZONE_PST)),
+            (edq.util.time.Timestamp(1755139534019), datetime.datetime(2025, 8, 14, 4,  45, 34, 19000, TIMEZONE_CEST)),
+        ]
+
+        for (i, test_case) in enumerate(test_cases):
+            (timestamp, pytime) = test_case
+
+            with self.subTest(msg = f"Case {i} ('{timestamp}' == '{pytime}'):"):
+                convert_pytime = timestamp.to_pytime(pytime.tzinfo)
+                self.assertEqual(pytime, convert_pytime, 'pytime')
+
+                convert_timestamp = edq.util.time.Timestamp.from_pytime(pytime)
+                self.assertEqual(timestamp, convert_timestamp, 'timestamp')
+
+                # Check other time zones.
+                # Use string comparisons to ensure the timezone is compared (and not just the UTC time).
+                timezones = [
+                    TIMEZONE_UTC,
+                    TIMEZONE_PST,
+                    TIMEZONE_CEST,
+                ]
+
+                for timezone in timezones:
+                    pytime_pst = pytime.astimezone(timezone).isoformat(timespec = 'milliseconds')
+                    convert_pytime_pst = timestamp.to_pytime(timezone).isoformat(timespec = 'milliseconds')
+                    self.assertEqual(pytime_pst, convert_pytime_pst, f"pytime {timezone}")
+
+    def test_timestamp_pretty(self):
+        """ Test the "pretty" representations of timestamps. """
+
+        # [(timestamp, timezone, pretty short, pretty long), ...]
+        test_cases = [
+            (edq.util.time.Timestamp(0), TIMEZONE_UTC, "1970-01-01 00:00", "1970-01-01T00:00:00.000+00:00"),
+
+            (edq.util.time.Timestamp(1755139534019), TIMEZONE_UTC,  "2025-08-14 02:45", "2025-08-14T02:45:34.019+00:00"),
+            (edq.util.time.Timestamp(1755139534019), TIMEZONE_PST,  "2025-08-13 19:45", "2025-08-13T19:45:34.019-07:00"),
+            (edq.util.time.Timestamp(1755139534019), TIMEZONE_CEST, "2025-08-14 04:45", "2025-08-14T04:45:34.019+02:00"),
+        ]
+
+        for (i, test_case) in enumerate(test_cases):
+            (timestamp, timezone, expected_pretty_short, expected_pretty_long) = test_case
+
+            with self.subTest(msg = f"Case {i} ('{timestamp}'):"):
+                actual_pretty_short = timestamp.pretty(short = True, timezone = timezone)
+                actual_pretty_long = timestamp.pretty(short = False, timezone = timezone)
+
+                self.assertEqual(expected_pretty_short, actual_pretty_short, 'short')
+                self.assertEqual(expected_pretty_long, actual_pretty_long, 'long')
+
+    def test_timestamp_sub(self):
+        """ Test subtracting timestamps. """
+
+        # [(a, b, expected), ...]
+        # All values in this structure will be in ints and converted later.
+        test_cases = [
+            (0, 0, 0),
+            (0, 1, -1),
+            (1, 0, 1),
+
+            (100, 100, 0),
+            (100, 101, -1),
+            (101, 100, 1),
+        ]
+
+        for (i, test_case) in enumerate(test_cases):
+            (raw_a, raw_b, raw_expected) = test_case
+
+            with self.subTest(msg = f"Case {i} ({raw_a} - {raw_b}):"):
+                a = edq.util.time.Timestamp(raw_a)
+                b = edq.util.time.Timestamp(raw_b)
+                expected = edq.util.time.Duration(raw_expected)
+
+                actual = a - b
+                self.assertEqual(expected, actual)

{edq_utils-0.0.1.dist-info → edq_utils-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edq-utils
-Version: 0.0.1
+Version: 0.0.2
 Summary: Common utilities used by EduLinq Python projects.
 Author-email: Eriq Augustine <eriq@edulinq.org>
 License: MIT License
@@ -34,6 +34,7 @@ Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: json5>=0.9.14
 Provides-Extra: dev
 Requires-Dist: mypy>=1.14.1; extra == "dev"
 Requires-Dist: pylint; extra == "dev"

edq_utils-0.0.2.dist-info/RECORD

@@ -0,0 +1,26 @@
+edq/__init__.py,sha256=miSsqPy2PFJ18TW9kocQJLcv4HFpkfQhcTzgAO-GTVE,22
+edq/testing/run.py,sha256=pibKFJDHCtGoKyuN7i95ZGjwuXV5jL-XPy4W-l14X2Q,3150
+edq/testing/unittest.py,sha256=WIcc5psTM-e6NQbQ3ajBjSRRRHBqvMuKOvK_pZMcTlk,1341
+edq/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edq/util/dirent.py,sha256=LR-ePtQZKEWNfZkyJ-zxFdcggQKYZ8fT379mcBYeepw,9412
+edq/util/dirent_test.py,sha256=FSRqhp18S4-7J9XroLxPUoJMKPBDpp3PfPKraM_7atw,30037
+edq/util/json.py,sha256=YRUrQvLvwDTQBcURGk6nGJLd9m6TB_jdgdrYPLElcyk,2132
+edq/util/json_test.py,sha256=a0my-tdo1NoPv8wWwxk2pIw56CS7QyOrODkGx2-GO1c,4273
+edq/util/pyimport.py,sha256=M1j58vg4b6gTg92Cz5-bns3eQCCIMKDApBclP-iR620,2198
+edq/util/pyimport_test.py,sha256=wuTR5pzVZanWDA2FuVc-Pxyo_GwkGGfFf_qyK6LNQRs,2851
+edq/util/reflection.py,sha256=jPcW6h0fwSDYh04O5rUxlgoF7HK6fVQ2mq7DD9qPrEg,972
+edq/util/time.py,sha256=anoNM_KniARLombv2BnsoHuCzDqMKiDdIzV7RUe2ZOk,2648
+edq/util/time_test.py,sha256=iQZwzVTVQQ4TdXrLb9MUMCYlKrIe8qyF-hiC9YLTaMo,4610
+edq/util/testdata/dirent-operations/a.txt,sha256=h0KPxSKAPTEGXnvOPPA_5HUJZjHl4Hu9eg_eYMTPJcc,2
+edq/util/testdata/dirent-operations/file_empty,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edq/util/testdata/dirent-operations/symlink_a.txt,sha256=h0KPxSKAPTEGXnvOPPA_5HUJZjHl4Hu9eg_eYMTPJcc,2
+edq/util/testdata/dirent-operations/symlink_file_empty,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edq/util/testdata/dirent-operations/dir_1/b.txt,sha256=AmOCmYm2_ZVPcrqvL8ZLwuLwHWktTecphuqAj26ZgT8,2
+edq/util/testdata/dirent-operations/dir_1/dir_2/c.txt,sha256=o6XnFfDMV0pzw_m-u2vCTzL_1bZ7OHJEwskJ2neaFHg,2
+edq/util/testdata/dirent-operations/symlink_dir_1/b.txt,sha256=AmOCmYm2_ZVPcrqvL8ZLwuLwHWktTecphuqAj26ZgT8,2
+edq/util/testdata/dirent-operations/symlink_dir_1/dir_2/c.txt,sha256=o6XnFfDMV0pzw_m-u2vCTzL_1bZ7OHJEwskJ2neaFHg,2
+edq_utils-0.0.2.dist-info/licenses/LICENSE,sha256=MS4iYEl4rOxMoprZuc86iYVoyk4YgaVoMt7WmGvVF8w,1064
+edq_utils-0.0.2.dist-info/METADATA,sha256=WczGh7XL8QbJ0OLaLPE0WyHA65YucW8UAv0LG6TN7s8,2427
+edq_utils-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+edq_utils-0.0.2.dist-info/top_level.txt,sha256=znBHSj6tgXtcMKrUVtovLli5fIEJCb7d-BMxTLRK4zk,4
+edq_utils-0.0.2.dist-info/RECORD,,

edq_utils-0.0.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-edq/__init__.py,sha256=DsAHdxLC16H2VjdFOU5tBx2xT9VnNQ-XbTS24fRCa_w,22
-edq/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-edq/util/dirent.py,sha256=Dr4OtB9TvJmiGLrjdiSmsh5Fk8G49jfklh4wdOx13ro,4436
-edq/util/dirent_test.py,sha256=FBMHEmcrfR7VILBzgy1cMWrFEp9wNQ5RNbL5vOdezT4,5998
-edq/util/testdata/dirent-operations/a.txt,sha256=h0KPxSKAPTEGXnvOPPA_5HUJZjHl4Hu9eg_eYMTPJcc,2
-edq/util/testdata/dirent-operations/file_empty,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-edq/util/testdata/dirent-operations/symlinklink_a.txt,sha256=h0KPxSKAPTEGXnvOPPA_5HUJZjHl4Hu9eg_eYMTPJcc,2
-edq/util/testdata/dirent-operations/dir_1/b.txt,sha256=AmOCmYm2_ZVPcrqvL8ZLwuLwHWktTecphuqAj26ZgT8,2
-edq/util/testdata/dirent-operations/dir_1/dir_2/c.txt,sha256=o6XnFfDMV0pzw_m-u2vCTzL_1bZ7OHJEwskJ2neaFHg,2
-edq/util/testdata/dirent-operations/symlinklink_dir_1/b.txt,sha256=AmOCmYm2_ZVPcrqvL8ZLwuLwHWktTecphuqAj26ZgT8,2
-edq/util/testdata/dirent-operations/symlinklink_dir_1/dir_2/c.txt,sha256=o6XnFfDMV0pzw_m-u2vCTzL_1bZ7OHJEwskJ2neaFHg,2
-edq_utils-0.0.1.dist-info/licenses/LICENSE,sha256=MS4iYEl4rOxMoprZuc86iYVoyk4YgaVoMt7WmGvVF8w,1064
-edq_utils-0.0.1.dist-info/METADATA,sha256=Q99RoHQkHjWZEkP-gEdtEaEPE1xoauWVtUXWsE3OlmM,2398
-edq_utils-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-edq_utils-0.0.1.dist-info/top_level.txt,sha256=znBHSj6tgXtcMKrUVtovLli5fIEJCb7d-BMxTLRK4zk,4
-edq_utils-0.0.1.dist-info/RECORD,,