wexample-file 0.0.1__tar.gz

wexample_file-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wexample_file-0.0.1/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: wexample-file
+Version: 0.0.1
+Summary: Package that allows you to manage the state of files and directories using YAML configuration files.
+Author-email: weeger <contact@wexample.com>
+License: MIT
+Project-URL: homepage, https://github.com/wexample/python-file
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pip-tools
+Requires-Dist: pydantic
+Requires-Dist: pytest
+Requires-Dist: wexample-config==0.0.41
+Requires-Dist: wexample-helpers==0.0.57
+Requires-Dist: wexample-prompt==0.0.38
+Dynamic: license-file
+
+# wexample-file
+
+Tools to manage the state of files and directories using simple YAML configuration files.
+
+- Project: https://github.com/wexample/python-file
+- License: MIT
+
+Install:
+```bash
+pip install wexample-file
+```
+
+Quick start:
+```python
+from wexample_file import *
+# TODO: usage examples will go here
+```

wexample_file-0.0.1/README.md

@@ -0,0 +1,17 @@
+# wexample-file
+
+Tools to manage the state of files and directories using simple YAML configuration files.
+
+- Project: https://github.com/wexample/python-file
+- License: MIT
+
+Install:
+```bash
+pip install wexample-file
+```
+
+Quick start:
+```python
+from wexample_file import *
+# TODO: usage examples will go here
+```

wexample_file-0.0.1/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = [
+    "setuptools",
+    "wheel",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wexample-file"
+version = "0.0.1"
+description = "Package that allows you to manage the state of files and directories using YAML configuration files."
+authors = [
+    { name = "weeger", email = "contact@wexample.com" },
+]
+requires-python = ">=3.6"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "pip-tools",
+    "pydantic",
+    "pytest",
+    "wexample-config==0.0.41",
+    "wexample-helpers==0.0.57",
+    "wexample-prompt==0.0.38",
+]
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+homepage = "https://github.com/wexample/python-file"
+
+[tool.setuptools.packages.find]
+include = [
+    "*",
+]

wexample_file-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wexample_file-0.0.1/tests/package/common/test_local_directory.py

@@ -0,0 +1,76 @@
+import pytest
+from pathlib import Path
+
+from wexample_file.common.local_directory import LocalDirectory
+from wexample_file.excpetion.not_a_directory_exception import NotADirectoryException
+from wexample_file.excpetion.directory_not_found_exception import DirectoryNotFoundException
+
+
+def test_local_directory_instantiation_with_str(tmp_path):
+    d = tmp_path / "adir"
+    d.mkdir()
+    ld = LocalDirectory(path=str(d))
+    assert isinstance(ld.path, Path)
+    assert ld.path == d.resolve()
+
+
+def test_local_directory_instantiation_with_path_nonexistent(tmp_path):
+    d = tmp_path / "missing_dir"
+    assert not d.exists()
+    ld = LocalDirectory(path=d)
+    assert ld.path == d.resolve()
+
+
+def test_local_directory_rejects_file(tmp_path):
+    f = tmp_path / "afile.txt"
+    f.write_text("hello")
+    with pytest.raises(NotADirectoryException):
+        LocalDirectory(path=f)
+
+
+def test_local_directory_check_exists_true_accepts_existing_dir(tmp_path):
+    d = tmp_path / "exists_dir"
+    d.mkdir()
+    ld = LocalDirectory(path=d, check_exists=True)
+    assert ld.path == d.resolve()
+
+
+def test_local_directory_check_exists_true_rejects_missing(tmp_path):
+    d = tmp_path / "missing_dir2"
+    assert not d.exists()
+    with pytest.raises(DirectoryNotFoundException):
+        LocalDirectory(path=d, check_exists=True)
+
+
+def test_local_directory_remove_deletes_directory_recursively(tmp_path):
+    d = tmp_path / "adir_to_remove"
+    sub = d / "sub"
+    sub.mkdir(parents=True)
+    (sub / "file.txt").write_text("hello")
+    ld = LocalDirectory(path=d, check_exists=True)
+    assert d.exists() and d.is_dir()
+    ld.remove()
+    assert not d.exists()
+
+
+def test_local_directory_remove_idempotent(tmp_path):
+    d = tmp_path / "missing_dir_after_remove"
+    ld = LocalDirectory(path=d)
+    # First remove on non-existent path should not raise
+    ld.remove()
+    assert not d.exists()
+    # Create then remove, then remove again
+    d.mkdir()
+    ld2 = LocalDirectory(path=d, check_exists=True)
+    ld2.remove()
+    assert not d.exists()
+    # Idempotent second call
+    ld2.remove()
+
+
+def test_local_directory_create_creates_directory_and_parents(tmp_path):
+    d = tmp_path / "a/b/c"
+    ld = LocalDirectory(path=d)
+    assert not d.exists()
+    ld.create()
+    assert d.exists() and d.is_dir()

wexample_file-0.0.1/tests/package/common/test_local_file.py

@@ -0,0 +1,134 @@
+import pytest
+from pathlib import Path
+from wexample_file.common.local_file import LocalFile
+from wexample_file.excpetion.not_a_file_exception import NotAFileException
+from wexample_file.excpetion.file_not_found_exception import FileNotFoundException
+
+
+def test_local_file_instantiation_with_str(tmp_path):
+    p = tmp_path / "file.txt"
+    p.write_text("hello")
+    lf = LocalFile(path=str(p))
+    assert isinstance(lf.path, Path)
+    assert lf.path == p.resolve()
+
+
+def test_local_file_instantiation_with_path_nonexistent(tmp_path):
+    p = tmp_path / "missing.txt"
+    assert not p.exists()
+    lf = LocalFile(path=p)
+    assert lf.path == p.resolve()
+
+
+def test_local_file_rejects_directory(tmp_path):
+    d = tmp_path / "adir"
+    d.mkdir()
+    with pytest.raises(NotAFileException):
+        LocalFile(path=d)
+
+
+def test_local_file_check_exists_true_accepts_existing_file(tmp_path):
+    p = tmp_path / "exists.txt"
+    p.write_text("data")
+    lf = LocalFile(path=p, check_exists=True)
+    assert lf.path == p.resolve()
+
+
+def test_local_file_check_exists_true_rejects_missing(tmp_path):
+    p = tmp_path / "missing2.txt"
+    assert not p.exists()
+    with pytest.raises(FileNotFoundException):
+        LocalFile(path=p, check_exists=True)
+
+
+def test_local_file_remove_deletes_file(tmp_path):
+    p = tmp_path / "toremove.txt"
+    p.write_text("data")
+    lf = LocalFile(path=p, check_exists=True)
+    assert p.exists()
+    lf.remove()
+    assert not p.exists()
+
+
+def test_local_file_remove_idempotent(tmp_path):
+    p = tmp_path / "missing_after_remove.txt"
+    lf = LocalFile(path=p)
+    # First remove on non-existent path should not raise
+    lf.remove()
+    assert not p.exists()
+    # Create then remove, then remove again
+    p.write_text("hello")
+    lf2 = LocalFile(path=p, check_exists=True)
+    lf2.remove()
+    assert not p.exists()
+    # Idempotent second call
+    lf2.remove()
+
+
+def test_local_file_read_returns_content_when_exists(tmp_path):
+    p = tmp_path / "readme.txt"
+    content = "héllo world"
+    p.write_text(content, encoding="utf-8")
+    lf = LocalFile(path=p)
+    assert lf.read() == content
+
+
+def test_local_file_read_returns_none_when_missing(tmp_path):
+    p = tmp_path / "missing_read.txt"
+    lf = LocalFile(path=p)
+    assert lf.read() is None
+
+
+def test_local_file_read_raises_if_not_a_file(tmp_path):
+    d = tmp_path / "not_a_file"
+    d.mkdir()
+    # Constructing LocalFile with a directory path would already raise NotAFileException
+    # So we simulate a race: create a file path then replace with directory
+    p = tmp_path / "was_file.txt"
+    p.write_text("x")
+    lf = LocalFile(path=p)
+    # Replace the path with a directory at same location
+    p.unlink()
+    d.rename(p)
+
+    assert lf.read() is None
+
+
+def test_local_file_touch_creates_file_and_parents(tmp_path):
+    nested = tmp_path / "a/b/c/file.txt"
+    lf = LocalFile(path=nested)
+    assert not nested.exists()
+    lf.touch()
+    assert nested.exists() and nested.is_file()
+
+
+def test_local_file_write_writes_content_and_creates_parents(tmp_path):
+    nested = tmp_path / "x/y/z/out.txt"
+    lf = LocalFile(path=nested)
+    text = "some content"
+    lf.write(text)
+    assert nested.exists() and nested.read_text() == text
+
+
+def test_local_file_get_extension_simple(tmp_path):
+    p = tmp_path / "report.pdf"
+    lf = LocalFile(path=p)
+    assert lf.get_extension() == "pdf"
+
+
+def test_local_file_get_extension_compound(tmp_path):
+    p = tmp_path / "archive.tar.gz"
+    lf = LocalFile(path=p)
+    assert lf.get_extension() == "gz"
+
+
+def test_local_file_get_extension_none(tmp_path):
+    p = tmp_path / "README"
+    lf = LocalFile(path=p)
+    assert lf.get_extension() == ""
+
+
+def test_local_file_get_extension_hidden_file(tmp_path):
+    p = tmp_path / ".gitignore"
+    lf = LocalFile(path=p)
+    assert lf.get_extension() == ""

wexample_file-0.0.1/wexample_file/common/abstract_local_item_path.py

@@ -0,0 +1,85 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+from wexample_file.excpetion.local_path_not_found_exception import LocalPathNotFoundException
+
+
+class AbstractLocalItemPath(BaseModel, ABC):
+    """Abstract base class for handling local file system paths.
+
+    Accepts either a string or a pathlib.Path for ``path`` and always stores a
+    resolved absolute Path (with user home expanded). This keeps comparisons and
+    downstream usage consistent regardless of how the input was provided.
+    """
+    path: Path = Field(description="The path to the file or directory")
+    check_exists: bool = False
+
+    @field_validator("path", mode="before")
+    @classmethod
+    def _coerce_and_resolve_path(cls, v):
+        """Coerce input into a resolved Path.
+
+        - Accepts str or Path
+        - Expands '~' and resolves to an absolute path with strict=False
+        """
+        if isinstance(v, str):
+            v = Path(v)
+        if isinstance(v, Path):
+            return v.expanduser().resolve(strict=False)
+        raise TypeError("path must be a str or pathlib.Path")
+
+    @model_validator(mode="after")
+    def _validate_existence(self):
+        """If check_exists is True, ensure the path exists."""
+        if self.check_exists and not self.path.exists():
+            # Defer to subclass to choose the most specific exception
+            exc = self._not_found_exc()
+            if exc is None:
+                # Fallback to a generic not-found exception
+                raise LocalPathNotFoundException(self.path)
+            raise exc
+        return self
+
+    @abstractmethod
+    def _kind(self) -> str:
+        """Return the kind of local item (e.g., 'file' or 'directory').
+
+        Subclasses must implement this to mark the class as abstract and to
+        provide a simple discriminator for debugging and representation.
+        """
+
+    @abstractmethod
+    def _not_found_exc(self) -> Exception | None:
+        """Return a specific 'not found' exception instance for this item type.
+
+        Subclasses should return an instance of a custom exception that best
+        represents the missing path for their type (e.g., FileNotFoundException
+        or DirectoryNotFoundException). Returning None will make the base class
+        fall back to LocalPathNotFoundException.
+        """
+
+    @abstractmethod
+    def remove(self) -> None:
+        """Remove the underlying path from the filesystem.
+
+        - For a file implementation, this should delete the file.
+        - For a directory implementation, this should delete the directory
+          recursively.
+        - This operation should be idempotent: if the path does not exist,
+          the method should complete without raising.
+        """
+
+    def __str__(self) -> str:
+        return str(self.path)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(path={repr(str(self.path))}, check_exists={self.check_exists})"
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, AbstractLocalItemPath):
+            return self.path == other.path
+        if isinstance(other, (str, Path)):
+            other_path = Path(other).expanduser().resolve(strict=False)
+            return self.path == other_path
+        return NotImplemented

wexample_file-0.0.1/wexample_file/common/local_directory.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+
+from pydantic import field_validator
+
+from wexample_file.excpetion.directory_not_found_exception import DirectoryNotFoundException
+from wexample_file.excpetion.not_a_directory_exception import NotADirectoryException
+from .abstract_local_item_path import AbstractLocalItemPath
+
+
+class LocalDirectory(AbstractLocalItemPath):
+    """Represents a local directory path.
+
+    The path is stored as a resolved absolute Path. If the path exists, it must
+    be a directory.
+    """
+
+    @field_validator("path")
+    @classmethod
+    def _validate_is_dir(cls, v: Path) -> Path:
+        if v.exists() and not v.is_dir():
+            raise NotADirectoryException(v)
+        return v
+
+    def _kind(self) -> str:
+        from wexample_file.const.globals import PATH_NAME_DIRECTORY
+
+        return PATH_NAME_DIRECTORY
+
+    def _not_found_exc(self):
+        return DirectoryNotFoundException(self.path)
+
+    def remove(self) -> None:
+        """Delete the directory recursively if it exists; no-op if it doesn't.
+
+        This method is idempotent and will not raise if the directory is missing.
+        """
+        if not self.path.exists():
+            return
+        if self.path.is_dir():
+            # Remove contents recursively
+            import shutil
+            shutil.rmtree(self.path)
+        else:
+            # If for some reason it's not a dir anymore, best-effort unlink
+            try:
+                self.path.unlink()
+            except FileNotFoundError:
+                pass
+
+    def create(self, parents: bool = True, exist_ok: bool = True) -> None:
+        if self.path.exists() and self.path.is_file():
+            return None
+
+        self.path.mkdir(parents=parents, exist_ok=exist_ok)

wexample_file-0.0.1/wexample_file/common/local_file.py

@@ -0,0 +1,95 @@
+from pathlib import Path
+
+from pydantic import field_validator
+
+from wexample_file.excpetion.file_not_found_exception import FileNotFoundException
+from wexample_file.excpetion.not_a_file_exception import NotAFileException
+from .abstract_local_item_path import AbstractLocalItemPath
+
+
+class LocalFile(AbstractLocalItemPath):
+    """Represents a local file path.
+
+    The path is stored as a resolved absolute Path. If the path exists, it must
+    be a file.
+    """
+
+    @field_validator("path")
+    @classmethod
+    def _validate_is_file(cls, v: Path) -> Path:
+        # Only validate type when it exists; creation workflows may pass a non-existent path
+        if v.exists() and not v.is_file():
+            raise NotAFileException(v)
+        return v
+
+    def _kind(self) -> str:
+        from wexample_file.const.globals import PATH_NAME_FILE
+
+        return PATH_NAME_FILE
+
+    def _not_found_exc(self):
+        return FileNotFoundException(self.path)
+
+    def remove(self) -> None:
+        """Delete the file if it exists; no-op if it doesn't.
+
+        This method is idempotent and will not raise if the file is missing.
+        """
+        try:
+            # unlink(missing_ok=True) is available in Python 3.8+
+            self.path.unlink(missing_ok=True)
+        except TypeError:
+            # Fallback for older Python: check existence first
+            if self.path.exists():
+                self.path.unlink()
+
+    def read(self, encoding: str = "utf-8") -> str | None:
+        """Read and return the file content as text, or None if it doesn't exist.
+
+        Parameters:
+            encoding: Text encoding used to decode file content. Defaults to 'utf-8'.
+        """
+        if not self.path.exists() or not self.path.is_file():
+            return None
+
+        return self.path.read_text(encoding=encoding)
+
+    def touch(self, parents: bool = True, exist_ok: bool = True) -> bool:
+        if parents:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+        if self.path.exists() or self.path.is_dir():
+            return False
+
+        self.path.touch(exist_ok=exist_ok)
+        return True
+
+    def write(self, content: str, encoding: str = "utf-8", make_parents: bool = True) -> None:
+        """Write text content to the file, creating it if necessary.
+        """
+        if make_parents:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+        if self.path.exists() and self.path.is_dir():
+            raise NotAFileException(self.path)
+        self.path.write_text(content, encoding=encoding)
+
+    def get_extension(self) -> str:
+        """Return the last suffix without the leading dot.
+
+        Examples:
+            "archive.tar.gz" -> "gz"
+            "report.pdf" -> "pdf"
+            "README" -> ""
+        """
+        suf = self.path.suffix
+        return suf[1:] if suf.startswith(".") else ""
+
+    def change_extension(self, new_extension: str) -> None:
+        # Normalize extension: allow callers to pass with or without dot
+        ext = new_extension.lstrip(".")
+        suffix = f".{ext}" if ext else ""
+        target = self.path.with_suffix(suffix)
+
+        self.path.replace(target)
+
+    def is_empty(self) -> bool:
+        return Path(self.path).stat().st_size == 0

wexample_file-0.0.1/wexample_file/const/globals.py

@@ -0,0 +1,2 @@
+PATH_NAME_FILE = 'file'
+PATH_NAME_DIRECTORY = 'directory'

wexample_file-0.0.1/wexample_file/const/types.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+from typing import Union
+
+PathOrString = Union[Path, str]

wexample_file-0.0.1/wexample_file/excpetion/directory_not_found_exception.py

@@ -0,0 +1,9 @@
+from wexample_file.excpetion.local_path_not_found_exception import LocalPathNotFoundException
+
+
+class DirectoryNotFoundException(LocalPathNotFoundException):
+    error_code: str = "DIRECTORY_NOT_FOUND"
+
+    def __init__(self, path, message: str | None = None):
+        msg = message or f"Directory does not exist: {path}"
+        super().__init__(path=path, message=msg)

wexample_file-0.0.1/wexample_file/excpetion/file_not_found_exception.py

@@ -0,0 +1,9 @@
+from wexample_file.excpetion.local_path_not_found_exception import LocalPathNotFoundException
+
+
+class FileNotFoundException(LocalPathNotFoundException):
+    error_code: str = "FILE_NOT_FOUND"
+
+    def __init__(self, path, message: str | None = None):
+        msg = message or f"File does not exist: {path}"
+        super().__init__(path=path, message=msg)

wexample_file-0.0.1/wexample_file/excpetion/local_path_not_found_exception.py

@@ -0,0 +1,9 @@
+from wexample_helpers.exception.undefined_exception import UndefinedException
+
+
+class LocalPathNotFoundException(UndefinedException):
+    error_code: str = "LOCAL_PATH_NOT_FOUND"
+
+    def __init__(self, path, message: str | None = None):
+        msg = message or f"Path does not exist: {path}"
+        super().__init__(msg, data={"path": str(path)})

wexample_file-0.0.1/wexample_file/excpetion/not_a_directory_exception.py

@@ -0,0 +1,9 @@
+from wexample_helpers.exception.undefined_exception import UndefinedException
+
+
+class NotADirectoryException(UndefinedException):
+    error_code: str = "DIRECTORY_EXPECTED"
+
+    def __init__(self, path, message: str | None = None):
+        msg = message or f"Path is not a directory: {path}"
+        super().__init__(msg, data={"path": str(path)})

wexample_file-0.0.1/wexample_file/excpetion/not_a_file_exception.py

@@ -0,0 +1,9 @@
+from wexample_helpers.exception.undefined_exception import UndefinedException
+
+
+class NotAFileException(UndefinedException):
+    error_code: str = "FILE_EXPECTED"
+
+    def __init__(self, path, message: str | None = None):
+        msg = message or f"Path is not a file: {path}"
+        super().__init__(msg, data={"path": str(path)})

wexample_file-0.0.1/wexample_file.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: wexample-file
+Version: 0.0.1
+Summary: Package that allows you to manage the state of files and directories using YAML configuration files.
+Author-email: weeger <contact@wexample.com>
+License: MIT
+Project-URL: homepage, https://github.com/wexample/python-file
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pip-tools
+Requires-Dist: pydantic
+Requires-Dist: pytest
+Requires-Dist: wexample-config==0.0.41
+Requires-Dist: wexample-helpers==0.0.57
+Requires-Dist: wexample-prompt==0.0.38
+Dynamic: license-file
+
+# wexample-file
+
+Tools to manage the state of files and directories using simple YAML configuration files.
+
+- Project: https://github.com/wexample/python-file
+- License: MIT
+
+Install:
+```bash
+pip install wexample-file
+```
+
+Quick start:
+```python
+from wexample_file import *
+# TODO: usage examples will go here
+```

wexample_file-0.0.1/wexample_file.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+tests/__init__.py
+tests/package/common/test_local_directory.py
+tests/package/common/test_local_file.py
+wexample_file/__init__.py
+wexample_file.egg-info/PKG-INFO
+wexample_file.egg-info/SOURCES.txt
+wexample_file.egg-info/dependency_links.txt
+wexample_file.egg-info/requires.txt
+wexample_file.egg-info/top_level.txt
+wexample_file/common/abstract_local_item_path.py
+wexample_file/common/local_directory.py
+wexample_file/common/local_file.py
+wexample_file/const/globals.py
+wexample_file/const/types.py
+wexample_file/excpetion/directory_not_found_exception.py
+wexample_file/excpetion/file_not_found_exception.py
+wexample_file/excpetion/local_path_not_found_exception.py
+wexample_file/excpetion/not_a_directory_exception.py
+wexample_file/excpetion/not_a_file_exception.py

wexample_file-0.0.1/wexample_file.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wexample_file-0.0.1/wexample_file.egg-info/requires.txt

@@ -0,0 +1,6 @@
+pip-tools
+pydantic
+pytest
+wexample-config==0.0.41
+wexample-helpers==0.0.57
+wexample-prompt==0.0.38

wexample_file-0.0.1/wexample_file.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+build
+dist
+tests
+wexample_file