dacktool Library

0.0.7 · active · verified Fri Apr 17

dacktool is a collection of miscellaneous Python utilities designed to simplify common tasks related to file operations, data conversion (specifically JSON to dictionary), regular expression matching, and basic security functions like password hashing. Currently at version 0.0.7, it appears to be in early development with an infrequent release cadence.

Common errors

```
ModuleNotFoundError: No module named 'dacktool'
```
cause The dacktool library is not installed in the current Python environment.

fix Install the library using pip: `pip install dacktool`
```
AttributeError: module 'dacktool' has no attribute 'read_file'
```
cause Attempting to import a function (like `read_file`) directly from the top-level `dacktool` package when it resides in a submodule (e.g., `dacktool.files`).

fix Import the function from its specific submodule: `from dacktool.files import read_file`.
```
json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)
```
cause The input string provided to `convert_json_to_dict` is not valid JSON.

fix Ensure the input string is a correctly formatted JSON string, e.g., `'{"key": "value"}'`.
```
FileNotFoundError: [Errno 2] No such file or directory: 'non_existent_file.txt'
```
cause The file path specified for `read_file` or `write_file` does not exist or is incorrect, and the operation requires the file to be present (e.g., `read_file`) or the directory to exist.

fix Verify the file path is correct and accessible. If reading, ensure the file exists. If writing, ensure the parent directory exists or create it first.

Warnings

gotcha The library is in early development (v0.0.7); APIs are subject to change without prior notice, potentially leading to breaking changes between minor versions as the project matures.
Fix: Review release notes for any API changes when upgrading, and pin to a specific patch version if stability is critical for your application.
gotcha The `security` module provides basic password hashing and verification. For production environments, ensure you understand and follow cryptographic best practices, including proper salting, iteration counts, and key stretching, as this module provides fundamental components rather than a complete security framework.
Fix: Consult security best practices for password storage and consider using more established security libraries like `argon2-cffi` or `bcrypt` for production-grade authentication systems.
gotcha Error handling in some utility functions might be basic. For instance, file operations may raise standard Python exceptions (`FileNotFoundError`, `PermissionError`) which should be handled explicitly by the caller in robust applications.
Fix: Wrap calls to `dacktool` functions in `try-except` blocks to gracefully handle potential errors, especially for file system or network operations.

Install

pip install dacktool Install latest version

Imports

read_file
wrong:
```
from dacktool import read_file
```
correct:
```
from dacktool.files import read_file
```
Functions like 'read_file' are nested within submodules like 'files'.
convert_json_to_dict
wrong:
```
from dacktool import convert_json_to_dict
```
correct:
```
from dacktool.convert import convert_json_to_dict
```
Functions are imported directly from their respective submodules.

hash_password

wrong:

import dacktool.security; dacktool.security.hash_password()

correct:

from dacktool.security import hash_password

Prefer direct import of the function for clarity over submodule access.

Quickstart

This quickstart demonstrates how to use the `convert_json_to_dict` function for JSON string conversion and `write_file`/`read_file` for basic file operations. It creates a temporary file and cleans it up afterwards.

from dacktool.convert import convert_json_to_dict

json_data_string = '{"name": "Alice", "age": 30, "city": "New York"}'
python_dict = convert_json_to_dict(json_data_string)

print(f"JSON String: {json_data_string}")
print(f"Python Dictionary: {python_dict}")
print(f"Type of result: {type(python_dict)}")

# Example using files module (requires creating a dummy file)
from dacktool.files import write_file, read_file
import os

file_path = 'my_temp_file.txt'
content = 'Hello from dacktool!'

write_file(file_path, content)
read_content = read_file(file_path)

print(f"\nContent written to '{file_path}': {content}")
print(f"Content read from '{file_path}': {read_content}")

os.remove(file_path) # Clean up the dummy file

view raw JSON →