Version 1.1 #400
Version 1.1 #400
Conversation
18 add screenoverlay support
updates: - [github.com/astral-sh/ruff-pre-commit: v0.7.4 → v0.8.0](astral-sh/ruff-pre-commit@v0.7.4...v0.8.0)
[pre-commit.ci] pre-commit autoupdate
…arity and simplicity
…lify file handling
… network_link_control
396 kml model
Network LInk Control
…and add Hypothesis tests for validation
390 network link control
Reviewer's Guide by SourceryThis pull request implements version 1.1 of the FastKML library, introducing several new features and improvements. The main changes include adding support for Model elements, NetworkLinkControl, and ScreenOverlay, along with various code quality improvements and documentation updates. Class diagram for new Model elementsclassDiagram
class Model {
+Optional~AltitudeMode~ altitude_mode
+Optional~Location~ location
+Optional~Orientation~ orientation
+Optional~Scale~ scale
+Optional~Link~ link
+Optional~ResourceMap~ resource_map
}
class Location {
+Optional~float~ latitude
+Optional~float~ longitude
+Optional~float~ altitude
}
class Orientation {
+Optional~float~ heading
+Optional~float~ tilt
+Optional~float~ roll
}
class Scale {
+Optional~float~ x
+Optional~float~ y
+Optional~float~ z
}
class Link {
+str href
}
class ResourceMap {
+List~Alias~ aliases
}
class Alias {
+Optional~str~ target_href
+Optional~str~ source_href
}
Model --> Location
Model --> Orientation
Model --> Scale
Model --> Link
Model --> ResourceMap
ResourceMap --> Alias
Class diagram for new ScreenOverlay elementsclassDiagram
class ScreenOverlay {
+Optional~OverlayXY~ overlay_xy
+Optional~ScreenXY~ screen_xy
+Optional~RotationXY~ rotation_xy
+Optional~Size~ size
+Optional~float~ rotation
}
class OverlayXY {
+Optional~float~ x
+Optional~float~ y
+Optional~Units~ x_units
+Optional~Units~ y_units
}
class ScreenXY {
+Optional~float~ x
+Optional~float~ y
+Optional~Units~ x_units
+Optional~Units~ y_units
}
class RotationXY {
+Optional~float~ x
+Optional~float~ y
+Optional~Units~ x_units
+Optional~Units~ y_units
}
class Size {
+Optional~float~ x
+Optional~float~ y
+Optional~Units~ x_units
+Optional~Units~ y_units
}
ScreenOverlay --> OverlayXY
ScreenOverlay --> ScreenXY
ScreenOverlay --> RotationXY
ScreenOverlay --> Size
Class diagram for new NetworkLinkControl elementsclassDiagram
class NetworkLinkControl {
+Optional~float~ min_refresh_period
+Optional~float~ max_session_length
+Optional~str~ cookie
+Optional~str~ message
+Optional~str~ link_name
+Optional~str~ link_description
+Optional~str~ link_snippet
+Optional~KmlDateTime~ expires
+Union~Camera, LookAt, None~ view
}
class Camera {
+float longitude
+float latitude
+float altitude
+float heading
+float tilt
+float roll
}
class LookAt {
+float longitude
+float latitude
+float altitude
+float heading
+float tilt
+float range
}
NetworkLinkControl --> Camera
NetworkLinkControl --> LookAt
File-Level Changes
Tips and commandsInteracting with Sourcery
Customizing Your ExperienceAccess your dashboard to:
Getting Help
|
WalkthroughThe pull request encompasses a series of updates across multiple files in the FastKML library. Key changes include version updates for the Changes
Possibly related PRs
Suggested labels
📜 Recent review detailsConfiguration used: .coderabbit.yaml 📒 Files selected for processing (1)
🔇 Additional comments (4)fastkml/__init__.py (4)
The copyright year has been updated to include 2024, which is correct for new contributions.
The following entries appear twice in the
Additionally, consider maintaining alphabetical order for better readability. - "Point",
"PolyStyle",
- "Polygon",
"ResourceMap",
+ "Point",
+ "Polygon",
The new imports align with the PR objectives and are properly organized by submodule. Let's verify that all imports are actually needed and used in the codebase. ✅ Verification successfulAll new imports are actively used in the codebase Based on the verification results, all the newly imported classes and functions are actively used throughout the codebase:
🏁 Scripts executedThe following scripts were executed for the analysis: Script: #!/bin/bash
# Description: Verify usage of newly imported classes/functions
# Check for actual usage of new imports in the codebase
echo "Checking usage of new imports..."
for class in SimpleData SimpleField NetworkLink Snippet Coordinates Model Location Orientation Scale Alias ImagePyramid LatLonBox OverlayXY RotationXY ScreenOverlay ScreenXY Size ViewVolume; do
echo "Checking $class..."
rg "\b${class}\b" --type py --glob '!fastkml/__init__.py'
done
echo "Checking utility functions..."
for func in find find_all get_schema_parser validate create_kml_geometry; do
echo "Checking $func..."
rg "\b${func}\b" --type py --glob '!fastkml/__init__.py'
done
Length of output: 45562 Line range hint The changes introduce significant API additions. Please ensure:
✅ Verification successfulVersion and documentation are properly aligned with changes. The changes are well documented:
The version number is appropriately bumped from 1.0 to 1.1.0 following semantic versioning, as these are feature additions without breaking changes. 🏁 Scripts executedThe following scripts were executed for the analysis: Script: #!/bin/bash
# Description: Check for version and changelog updates
echo "Checking version..."
rg "version" pyproject.toml setup.py setup.cfg
echo "Checking changelog..."
fd -g "CHANGELOG*" -g "HISTORY*" -g "CHANGES*"
Length of output: 615 Script: #!/bin/bash
# Let's check the version file and look for changelog in docs directory
# Check version in about.py
echo "Checking version in about.py..."
cat fastkml/about.py
# Look for changelog in docs or root
echo -e "\nLooking for changelog..."
fd -t f -g "*CHANGELOG*" -g "*HISTORY*" -g "*CHANGES*" -g "*.md" -g "*.rst"
# Check git diff for version changes
echo -e "\nChecking version-related changes..."
git diff origin/main -- fastkml/about.py
Length of output: 1613 Script: #!/bin/bash
# Let's check for documentation and changelog in different locations
# Look for docs and changelog files
echo "Looking for documentation and changelog files..."
find . -type f \( -name "*.md" -o -name "*.rst" -o -name "CHANGELOG*" -o -name "HISTORY*" -o -name "CHANGES*" \) -not -path "*/\.*"
# Check README for version info
echo -e "\nChecking README.md..."
cat README.md
# Check docs directory if it exists
echo -e "\nChecking docs directory..."
ls -la docs/ 2>/dev/null || echo "No docs directory found"
Length of output: 2335 Script: #!/bin/bash
# Let's check the history and readme files
# Check HISTORY.rst for version info
echo "Checking HISTORY.rst..."
cat docs/HISTORY.rst
# Check README.rst since we found it instead of README.md
echo -e "\nChecking README.rst..."
cat README.rst
Length of output: 7904 Thank you for using CodeRabbit. We offer it for free to the OSS community and would appreciate your support in helping us grow. If you find it useful, would you consider giving us a shout-out on your favorite social media? 🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
Documentation and Community
|
|
Hello @cleder! Thanks for updating this PR. We checked the lines you've touched for PEP 8 issues, and found:
Comment last updated at 2024-12-02 09:21:43 UTC |
CI Failure Feedback 🧐(Checks updated until commit 1c346fe)
✨ CI feedback usage guide:The CI feedback tool (
In addition to being automatically triggered, the tool can also be invoked manually by commenting on a PR: where Configuration options
See more information about the |
![sourcery-ai[bot]](https://avatars.githubusercontent.com/in/48477?s=60&v=4){kind=small}
There was a problem hiding this comment.
Hey @cleder - I've reviewed your changes and they look great!
Here's what I looked at during the review
- 🟢 General issues: all looks good
- 🟢 Security: all looks good
- 🟡 Testing: 3 issues found
- 🟡 Complexity: 1 issue found
- 🟢 Documentation: all looks good
Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.
| def test_screen_overlay_from_string(self) -> None: | ||
| """Create a ScreenOverlay object with all optional parameters.""" | ||
| doc = ( | ||
| '<ScreenOverlay xmlns="http://www.opengis.net/kml/2.2">' | ||
| "<name>Simple crosshairs</name>" | ||
| "<visibility>0</visibility>" | ||
| "<description>This screen overlay uses fractional positioning to put the " | ||
| "image in the exact center of the screen</description>" | ||
| "<Icon>" | ||
| "<href>http://developers.google.com/kml/images/crosshairs.png</href>" |
There was a problem hiding this comment.
suggestion (testing): Add test cases for invalid ScreenOverlay configurations
The current test only covers a valid ScreenOverlay configuration. Consider adding test cases for invalid configurations like missing required fields, invalid coordinates, or out-of-range values for rotation to ensure proper error handling.
def test_screen_overlay_from_string(self) -> None:
"""Test creating ScreenOverlay objects with valid and invalid configurations."""
self._test_valid_screen_overlay()
self._test_invalid_coordinates()
self._test_missing_required_fields()
self._test_invalid_rotation()| def test_network_link_control_kml(self) -> None: | ||
| doc = ( | ||
| '<kml:NetworkLinkControl xmlns:kml="http://www.opengis.net/kml/2.2">' | ||
| "<kml:minRefreshPeriod>432000</kml:minRefreshPeriod>" | ||
| "<kml:maxSessionLength>-1</kml:maxSessionLength>" | ||
| "<kml:linkSnippet>A Snippet</kml:linkSnippet>" | ||
| "<kml:expires>2008-05-30</kml:expires>" | ||
| "</kml:NetworkLinkControl>" | ||
| ) | ||
|
|
There was a problem hiding this comment.
suggestion (testing): Add test coverage for NetworkLinkControl view handling
The test should include cases for both Camera and LookAt view types, as well as verify proper handling when view is not specified. This ensures the view property behaves correctly in all scenarios.
def test_network_link_control_kml(self) -> None:
camera = Camera(latitude=37.42, longitude=-122.08, altitude=400)
look_at = LookAt(latitude=37.42, longitude=-122.08, altitude=400)
for view in [camera, look_at, None]:
doc = (
f'<kml:NetworkLinkControl xmlns:kml="http://www.opengis.net/kml/2.2">'
f'{"" if view is None else view.to_string()}'
"</kml:NetworkLinkControl>"
)
assert NetworkLinkControl.from_string(doc).view == view|
|
||
| assert model.altitude_mode == AltitudeMode.absolute | ||
| assert model.geometry is None | ||
| assert not model |
There was a problem hiding this comment.
suggestion (testing): Expand invalid location test cases
Consider adding more test cases for different types of invalid locations (e.g., invalid latitude/longitude ranges, non-numeric values) to ensure robust error handling.
def test_from_string_invalid_location(self) -> None:
with self.assertRaises(ValueError):
Location.from_string("91.0,45.0") # latitude > 90
with self.assertRaises(ValueError):
Location.from_string("-91.0,45.0") # latitude < -90
with self.assertRaises(ValueError):
Location.from_string("45.0,181.0") # longitude > 180
with self.assertRaises(ValueError):
Location.from_string("45.0,abc") # non-numeric|
|
||
| y_units: Optional[Units] | ||
|
|
||
| def __init__( |
There was a problem hiding this comment.
issue (complexity): Consider grouping overlay-specific parameters into a separate dataclass to improve the interface's usability
The large number of init parameters makes the ScreenOverlay class difficult to use correctly. Consider extracting overlay-specific parameters into a dataclass while keeping the KML structure:
@dataclass
class OverlayParams:
overlay_xy: Optional[OverlayXY] = None
screen_xy: Optional[ScreenXY] = None
rotation_xy: Optional[RotationXY] = None
size: Optional[Size] = None
rotation: Optional[float] = None
color: Optional[str] = None
draw_order: Optional[int] = None
icon: Optional[Icon] = None
class ScreenOverlay(_Overlay):
def __init__(
self,
overlay_params: Optional[OverlayParams] = None,
# Base Feature params
ns: Optional[str] = None,
name: Optional[str] = None,
# etc...
):
super().__init__(ns=ns, name=name, ...)
params = overlay_params or OverlayParams()
self.overlay_xy = params.overlay_xy
self.screen_xy = params.screen_xy
# etc...This maintains the KML structure while making the interface more manageable. The dataclass provides a natural grouping for overlay-specific parameters that can be reused across overlay types.
| import fastkml.enums | ||
| import fastkml.links | ||
| import fastkml.model | ||
| from tests.base import Lxml |
There was a problem hiding this comment.
issue (code-quality): Don't import test modules. (dont-import-test-modules)
Explanation
Don't import test modules.Tests should be self-contained and don't depend on each other.
If a helper function is used by multiple tests,
define it in a helper module,
instead of importing one test from the other.
| @@ -31,6 +32,7 @@ | |||
| from tests.hypothesis.common import assert_str_roundtrip | |||
| from tests.hypothesis.common import assert_str_roundtrip_terse | |||
| from tests.hypothesis.common import assert_str_roundtrip_verbose | |||
| from tests.hypothesis.strategies import xy | |||
There was a problem hiding this comment.
issue (code-quality): Don't import test modules. (dont-import-test-modules)
Explanation
Don't import test modules.Tests should be self-contained and don't depend on each other.
If a helper function is used by multiple tests,
define it in a helper module,
instead of importing one test from the other.
| import fastkml.links | ||
| import fastkml.model | ||
| from fastkml.enums import AltitudeMode | ||
| from tests.base import Lxml |
There was a problem hiding this comment.
issue (code-quality): Don't import test modules. (dont-import-test-modules)
Explanation
Don't import test modules.Tests should be self-contained and don't depend on each other.
If a helper function is used by multiple tests,
define it in a helper module,
instead of importing one test from the other.
| import fastkml.model | ||
| from fastkml.enums import AltitudeMode | ||
| from tests.base import Lxml | ||
| from tests.base import StdLibrary |
There was a problem hiding this comment.
issue (code-quality): Don't import test modules. (dont-import-test-modules)
Explanation
Don't import test modules.Tests should be self-contained and don't depend on each other.
If a helper function is used by multiple tests,
define it in a helper module,
instead of importing one test from the other.
| from fastkml import views | ||
| from fastkml.network_link_control import NetworkLinkControl | ||
| from fastkml.times import KmlDateTime | ||
| from tests.base import StdLibrary |
There was a problem hiding this comment.
issue (code-quality): Don't import test modules. (dont-import-test-modules)
Explanation
Don't import test modules.Tests should be self-contained and don't depend on each other.
If a helper function is used by multiple tests,
define it in a helper module,
instead of importing one test from the other.
| # -- General configuration ------------------------------------------------ | ||
| # General information about the project. | ||
| project = "FastKML" | ||
| copyright = "2014 -2024, Christian Ledermann & Ian Lee" # noqa: A001 |
There was a problem hiding this comment.
issue (code-quality): Don't assign to builtin variable copyright (avoid-builtin-shadow)
Explanation
Python has a number ofbuiltin variables: functions and constants thatform a part of the language, such as
list, getattr, and type(See https://docs.python.org/3/library/functions.html).
It is valid, in the language, to re-bind such variables:
list = [1, 2, 3]However, this is considered poor practice.
- It will confuse other developers.
- It will confuse syntax highlighters and linters.
- It means you can no longer use that builtin for its original purpose.
How can you solve this?
Rename the variable something more specific, such as integers.
In a pinch, my_list and similar names are colloquially-recognized
placeholders.
PR Reviewer Guide 🔍Here are some key observations to aid the review process:
|
|
Preparing review... |
PR Code Suggestions ✨Explore these optional code suggestions:
|
|
Preparing review... |
![ellipsis-dev[bot]](https://avatars.githubusercontent.com/in/64358?s=60&v=4){kind=small}
There was a problem hiding this comment.
👍 Looks good to me! Reviewed everything up to 19a165d in 2 minutes and 54 seconds
More details
- Looked at
5005lines of code in43files - Skipped
0files when reviewing. - Skipped posting
3drafted comments based on config settings.
1. fastkml/styles.py:526
- Draft comment:
The__bool__method should check if bothxandyare notNoneto returnTrue. This ensures theHotSpotobject is valid only when both coordinates are set. - Reason this comment was not posted:
Comment was not on a valid diff hunk.
2. fastkml/styles.py:780
- Draft comment:
The__bool__method should check if bothxandyare notNoneto returnTrue. This ensures theHotSpotobject is valid only when both coordinates are set. - Reason this comment was not posted:
Marked as duplicate.
3. fastkml/styles.py:1046
- Draft comment:
The__bool__method should check if bothxandyare notNoneto returnTrue. This ensures theHotSpotobject is valid only when both coordinates are set. - Reason this comment was not posted:
Marked as duplicate.
Workflow ID: wflow_L92DoW3cUj83hi3O
You can customize Ellipsis with 👍 / 👎 feedback, review rules, user-specific overrides, quiet mode, and more.
|
Failed to generate code suggestions for PR |
![llamapreview[bot]](https://avatars.githubusercontent.com/in/1023541?s=60&v=4){kind=small}
There was a problem hiding this comment.
Auto Pull Request Review from LlamaPReview
Large PR Notification
Dear contributor,
Thank you for your substantial contribution to this project. LlamaPReview has detected that this Pull Request contains a large volume of changes, which exceeds our current processing capacity.
Details:
- PR and related contents total size: Approximately 158,238 characters
- Current limit: 50,000 characters
Next steps:
- Consider breaking this PR into smaller, more focused changes if possible.
- For manual review, please reach out to your team members or maintainers.
We appreciate your understanding and commitment to improving this project. Your contributions are valuable, and we want to ensure they receive the attention they deserve.
LlamaPReview is continuously evolving to better serve the community. Share your thoughts on handling large PRs in our GitHub Discussions - your feedback helps us improve and expand our capabilities.
If you have any questions or need assistance, our community and support team are here to help.
Best regards,
LlamaPReview Team
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 5
🧹 Outside diff range and nitpick comments (29)
fastkml/network_link_control.py (2)
153-154: Remove unnecessary trailing comma in__repr__methodIn the
__repr__method ofNetworkLinkControl, there's an unnecessary trailing comma before the closing parenthesis, which may result in an unintended comma in the output string.Apply this diff to remove the extra comma:
def __repr__(self) -> str: """ Return a string representation of the NetworkLinkControl object. Returns ------- str: A string representation of the NetworkLinkControl object. """ return ( f"{self.__class__.__module__}.{self.__class__.__name__}(" f"ns={self.ns!r}, " f"name_spaces={self.name_spaces!r}, " f"min_refresh_period={self.min_refresh_period!r}, " f"max_session_length={self.max_session_length!r}, " f"cookie={self.cookie!r}, " f"message={self.message!r}, " f"link_name={self.link_name!r}, " f"link_description={self.link_description!r}, " f"link_snippet={self.link_snippet!r}, " f"expires={self.expires!r}, " f"view={self.view!r}, " - f"**{self._get_splat()!r}," + f"**{self._get_splat()!r}" ")" )
73-81: Consider setting default values in__init__consistent with registry defaultsIn the
__init__method, the default values formin_refresh_periodandmax_session_lengthare set toNone, but in the registry, they default to0and-1, respectively. For consistency and to avoid potential confusion, consider setting the default values in the__init__method to match those in the registry.Apply this diff to update the default values:
def __init__( self, ns: Optional[str] = None, name_spaces: Optional[Dict[str, str]] = None, - min_refresh_period: Optional[float] = None, - max_session_length: Optional[float] = None, + min_refresh_period: Optional[float] = 0.0, + max_session_length: Optional[float] = -1.0, cookie: Optional[str] = None, message: Optional[str] = None, link_name: Optional[str] = None, link_description: Optional[str] = None, link_snippet: Optional[str] = None, expires: Optional[KmlDateTime] = None, view: Optional[Union[Camera, LookAt]] = None, **kwargs: Any, ) -> None:fastkml/model.py (1)
84-96: Remove unnecessary trailing commas in__repr__methodsThe
__repr__methods in classesLocation,Orientation,Scale,Alias,ResourceMap, andModelcontain unnecessary trailing commas before the closing parenthesis. This may result in unintended commas in the output strings.Update the
__repr__methods to remove the extra commas:# Example for one of the classes, apply similarly to others def __repr__(self) -> str: """Create a string representation for the class.""" return ( f"{self.__class__.__module__}.{self.__class__.__name__}(" f"ns={self.ns!r}, " f"name_spaces={self.name_spaces!r}, " f"attribute_1={self.attribute_1!r}, " f"attribute_2={self.attribute_2!r}, " - f"**{self._get_splat()!r}," + f"**{self._get_splat()!r}" ")" )Also applies to: 173-185, 253-265, 330-341, 389-398, 457-473
fastkml/geometry.py (1)
Line range hint
268-283: Remove unnecessary trailing commas in__repr__methodsThe
__repr__methods in classesCoordinates,Point,LineString,LinearRing,BoundaryIs,Polygon, andMultiGeometrycontain unnecessary trailing commas before the closing parenthesis. This may lead to unintended commas in the output strings.Update the
__repr__methods as follows:# Example for one of the classes, apply similarly to others def __repr__(self) -> str: """Create a string representation for the class.""" return ( f"{self.__class__.__module__}.{self.__class__.__name__}(" f"ns={self.ns!r}, " f"name_spaces={self.name_spaces!r}, " f"attribute_1={self.attribute_1!r}, " f"attribute_2={self.attribute_2!r}, " - f"**{self._get_splat()!r}," + f"**{self._get_splat()!r}" ")" )Also applies to: 361-382, 576-591, 885-903, 1056-1072, 1145-1161, 1343-1359
fastkml/overlays.py (1)
Line range hint
349-357: Remove unnecessary trailing commas in__repr__methodsThe
__repr__methods in classesViewVolume,ImagePyramid,PhotoOverlay,LatLonBox,_XY, andScreenOverlaycontain unnecessary trailing commas before the closing parenthesis. This can result in unintended commas in the output strings.Apply the following diff to the affected
__repr__methods:# Example for one of the classes, apply similarly to others def __repr__(self) -> str: """Create a string representation for the class.""" return ( f"{self.__class__.__module__}.{self.__class__.__name__}(" f"ns={self.ns!r}, " f"name_spaces={self.name_spaces!r}, " f"attribute_1={self.attribute_1!r}, " f"attribute_2={self.attribute_2!r}, " - f"**{self._get_splat()!r}," + f"**{self._get_splat()!r}" ")" )Also applies to: 495-504, 792-834, 920-935, 1326-1338, 1586-1619
_typos.toml (1)
2-6: Remove redundant ignore patternsThe patterns "Lod" and "lod" are already handled in the
[default.extend-words]section, making their inclusion inextend-ignore-identifiers-reredundant. Theextend-wordssection is more appropriate for legitimate words, whileextend-ignore-identifiers-reis better suited for patterns like hashes and identifiers.Consider this simplified configuration:
[default] extend-ignore-identifiers-re = [ "04AFE6060F147CE66FBD", - "Lod", - "lod", ]docs/index.rst (1)
29-32: LGTM! Consider adding version compatibility notes.The addition of "upgrading" and "kml" sections to the documentation is valuable, especially during a version update.
Consider adding a note about version compatibility at the top of the documentation, such as "This documentation applies to FastKML 1.1 and later versions."
docs/upgrading.rst (2)
1-18: Enhance validation explanation with more context.The explanation of validation changes is clear, but could benefit from additional context.
Consider adding:
- Why validation was introduced in version 1.0
- When users might want to use
strict=Falsevs.validate=False- Best practices for handling invalid KML files
19-28: Add version numbers to code examples.The code examples clearly show the API changes, but could be more explicit about versions.
Consider updating the examples to include version numbers in the comments:
-In fastkml 0.x:: +In fastkml 0.12 and earlier:: -Becomes in 1.0:: +In fastkml 1.0 and later::examples/shp2kml.py (1)
71-71: Consider adding error handling for file writing.The file writing operation could benefit from error handling.
-kml.write(outfile, prettyprint=True, precision=3) +try: + kml.write(outfile, prettyprint=True, precision=3) +except IOError as e: + print(f"Error writing KML file: {e}") + raisedocs/conf.py (2)
23-29: Update copyright year rangeThe copyright year range "2014 -2024" contains an extra space after the hyphen.
-copyright = "2014 -2024, Christian Ledermann & Ian Lee" +copyright = "2014-2024, Christian Ledermann & Ian Lee"
Line range hint
57-65: Consider making RTD theme the defaultThe current configuration attempts to use
sphinx_rtd_themebut falls back toalabaster. Since Read the Docs theme is widely used and provides better navigation, consider making it a required dependency.-html_theme = "alabaster" -html_static_path = ["_static"] -try: - import sphinx_rtd_theme - - html_theme = "sphinx_rtd_theme" - html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] -except ImportError: - pass +html_theme = "sphinx_rtd_theme" +html_static_path = ["_static"]docs/HISTORY.rst (2)
4-10: Add release date placeholderThe version entry should include a release date placeholder to maintain consistency with previous entries.
-1.1.0 (unreleased) +1.1.0 (YYYY/MM/DD)Also, consider adding more details about the new features, particularly:
- Specific capabilities added with ScreenOverlay and Model support
- Impact of namespace-declaration-free KML parsing
- NetworkLinkControl functionality and use cases
7-9: Standardize changelog entry formatFor consistency with other entries, consider:
- Adding bullet points for each change
- Including contributor names in square brackets for all entries
-- Add support for ScreenOverlay and Model. -- allow parsing kml files without namespace declarations. -- Add support for NetworkLinkControl. [Apurva Banka] +- Add support for ScreenOverlay and Model [Christian Ledermann] +- Allow parsing KML files without namespace declarations [Christian Ledermann] +- Add support for NetworkLinkControl [Apurva Banka]examples/shp2kml_timed.py (1)
92-93: Consider adding compression level controlThe switch to KMZ output (compressed KML) is good for large files, but consider adding a compression level parameter for fine-tuning the size/performance trade-off.
-kml.write(outfile, prettyprint=True, precision=3) +def write_kmz(kml, outfile: pathlib.Path, compression_level: int = 9) -> None: + """Write KMZ file with configurable compression.""" + kml.write(outfile, prettyprint=True, precision=3, compression=compression_level) + +write_kmz(kml, outfile)tests/network_link_control_test.py (2)
32-58: Enhance test coverage with edge casesWhile the basic attribute testing is good, consider adding tests for:
- Edge cases (negative values, empty strings)
- Invalid datetime formats
- None values for optional fields
def test_network_link_control_edge_cases(self) -> None: """Test NetworkLinkControl with edge cases.""" # Test with negative refresh period with self.assertRaises(ValueError): NetworkLinkControl(min_refresh_period=-1.0) # Test with None values nc = NetworkLinkControl( link_name=None, link_description=None ) assert nc.link_name is None assert nc.link_description is None
59-81: Consider using parameterized testsThe KML parsing test could be expanded using parameterized tests to cover various KML formats and structures.
@pytest.mark.parametrize("kml_input,expected", [ ( '<kml:NetworkLinkControl xmlns:kml="http://www.opengis.net/kml/2.2">' '<kml:minRefreshPeriod>432000</kml:minRefreshPeriod>' '</kml:NetworkLinkControl>', NetworkLinkControl(min_refresh_period=432000) ), # Add more test cases ]) def test_network_link_control_kml_variants(self, kml_input: str, expected: NetworkLinkControl) -> None: nc = NetworkLinkControl.from_string(kml_input) assert nc == expectedtests/hypothesis/network_link_control_test.py (1)
36-122: Consider enhancing test assertions.While the test comprehensively generates valid test cases using hypothesis, consider adding assertions to verify that the created
NetworkLinkControlobject's attributes match the input parameters.Add assertions after line 117:
) + # Verify object attributes + assert nlc.min_refresh_period == min_refresh_period + assert nlc.max_session_length == max_session_length + assert nlc.cookie == cookie + assert nlc.message == message + assert nlc.link_name == link_name + assert nlc.link_description == link_description + assert nlc.link_snippet == link_snippet + assert nlc.expires == expires + assert nlc.view == view + assert_repr_roundtrip(nlc)tests/model_test.py (3)
17-17: Fix incorrect docstring descriptionThe docstring states "Test the kml overlay classes" but this file tests model classes.
-"""Test the kml overlay classes.""" +"""Test the kml model classes."""
39-43: Replace internal domain URLs with example.comThe test data contains URLs with internal domain (barcelona.galdos.local). Use example.com for test data.
- "<Link><href>http://barcelona.galdos.local/files/PublicLibrary.dae</href></Link>" - '<ResourceMap id="map01">' - "<Alias>" - "<targetHref>http://barcelona.galdos.local/images/Concrete2.jpg</targetHref>" - "<sourceHref>../images/Concrete.jpg</sourceHref>" + "<Link><href>http://example.com/files/PublicLibrary.dae</href></Link>" + '<ResourceMap id="map01">' + "<Alias>" + "<targetHref>http://example.com/images/Concrete2.jpg</targetHref>" + "<sourceHref>../images/Concrete.jpg</sourceHref>"
28-145: Consider using parameterized testsThe test cases contain similar XML structures with slight variations. Consider using parameterized tests to reduce code duplication and make it easier to add new test cases.
Additionally, consider adding test cases for:
- Negative coordinates
- Maximum/minimum coordinate values
- Invalid scale values
- Missing optional elements
Example of parameterized test:
import pytest @pytest.mark.parametrize("location_xml,expected_result", [ ("""<Location> <longitude>-123.115776547816</longitude> <latitude>49.279804095564</latitude> <altitude>21.614010375743</altitude> </Location>""", {"valid": True, "coords": (-123.115776547816, 49.279804095564, 21.614010375743)}), ("""<Location> <longitude></longitude> <latitude>49.279804095564</latitude> <altitude>21.614010375743</altitude> </Location>""", {"valid": False, "coords": None}), # Add more test cases here ]) def test_location_parsing(location_xml: str, expected_result: dict) -> None: location = fastkml.model.Location.from_string(location_xml) assert bool(location) == expected_result["valid"] assert location.geometry == expected_result["coords"]fastkml/registry.py (2)
84-84: Enhancement: Added XML element setting capabilityThe addition of the
set_elementfield toRegistryItemimproves the mapping capabilities between XML and Python objects.This enhancement provides better control over XML serialization, ensuring consistent handling of KML elements.
183-194: Documentation improvement: Clear guidance on registry usageThe added documentation clearly explains why users should use the global
registry.registryinstance instead of creating new instances.This guidance helps prevent potential issues with multiple registry instances and ensures consistent KML element handling across the application.
fastkml/links.py (2)
129-129: Enhancement: Broader namespace support in Link attributesThe update of
ns_idsfrom("kml",)to("kml", "")across all Link attributes improves compatibility with various KML documents.This change allows the parser to handle KML elements both with and without explicit namespaces, making the library more robust when dealing with different KML document styles.
Also applies to: 140-140, 152-152, 164-164, 176-176, 188-188, 200-200, 212-212
Line range hint
238-247: Consider implementing the TODO for icon palette supportThe TODO comment indicates missing support for icon palette features (
gx:x,gx:y,gx:w,gx:h).Would you like me to help implement the icon palette support or create a GitHub issue to track this enhancement?
fastkml/kml.py (1)
297-309: LGTM: Proper registration of NetworkLinkControl featureThe NetworkLinkControl has been correctly registered in the KML registry, maintaining consistency with other KML features.
However, consider breaking the long string of node names into multiple lines for better readability.
node_name=( - "Document,Folder,Placemark,GroundOverlay,PhotoOverlay,NetworkLink," - "NetworkLinkControl" + "Document," + "Folder," + "Placemark," + "GroundOverlay," + "PhotoOverlay," + "NetworkLink," + "NetworkLinkControl" ),fastkml/base.py (1)
86-87: LGTM! Performance improvement in kwargs handling.The change to use
kwargs.items()is more efficient as it avoids redundant dictionary lookups that would occur when accessingkwargs[arg]in a separate step.tests/hypothesis/feature_test.py (1)
423-459: LGTM! Well-structured property-based test.The test effectively:
- Uses hypothesis strategies to generate valid test data
- Includes proper boundary checks for coordinates
- Validates model parameters comprehensively
- Tests serialization/deserialization roundtrip
Consider adding edge cases for:
# Add these test cases st.builds( fastkml.model.Model, altitude_mode=st.none(), # Test with None altitude_mode location=st.none(), # Test with None location link=st.none(), # Test with None link )tests/overlays_test.py (1)
34-93: LGTM! Comprehensive test coverage for ScreenOverlay.The test effectively:
- Validates all ScreenOverlay attributes
- Tests XML serialization/deserialization
- Includes proper error handling
- Uses clear test data with meaningful values
Consider adding tests for:
- Invalid input handling
- Edge cases for coordinate values
- Different units combinations
📜 Review details
Configuration used: .coderabbit.yaml
Review profile: CHILL
⛔ Files ignored due to path filters (1)
examples/owid-co2-data.csvis excluded by!**/*.csv
📒 Files selected for processing (42)
.pre-commit-config.yaml(1 hunks)README.rst(5 hunks)_typos.toml(1 hunks)docs/HISTORY.rst(2 hunks)docs/Makefile(1 hunks)docs/conf.py(2 hunks)docs/create_kml_files.rst(2 hunks)docs/fastkml.rst(2 hunks)docs/index.rst(1 hunks)docs/kml.rst(1 hunks)docs/network.kml(1 hunks)docs/quickstart.rst(3 hunks)docs/upgrading.rst(1 hunks)docs/working_with_kml.rst(3 hunks)examples/shp2kml.py(4 hunks)examples/shp2kml_timed.py(5 hunks)examples/simple_example.py(1 hunks)fastkml/__init__.py(2 hunks)fastkml/about.py(1 hunks)fastkml/base.py(1 hunks)fastkml/containers.py(3 hunks)fastkml/data.py(5 hunks)fastkml/features.py(21 hunks)fastkml/geometry.py(16 hunks)fastkml/kml.py(3 hunks)fastkml/links.py(9 hunks)fastkml/model.py(1 hunks)fastkml/network_link_control.py(1 hunks)fastkml/overlays.py(26 hunks)fastkml/registry.py(2 hunks)fastkml/styles.py(20 hunks)fastkml/times.py(1 hunks)fastkml/views.py(19 hunks)pyproject.toml(1 hunks)tests/hypothesis/feature_test.py(2 hunks)tests/hypothesis/model_test.py(1 hunks)tests/hypothesis/network_link_control_test.py(1 hunks)tests/hypothesis/overlay_test.py(3 hunks)tests/hypothesis/strategies.py(1 hunks)tests/model_test.py(1 hunks)tests/network_link_control_test.py(1 hunks)tests/overlays_test.py(3 hunks)
✅ Files skipped from review due to trivial changes (4)
- fastkml/about.py
- docs/kml.rst
- docs/network.kml
- fastkml/views.py
🔇 Additional comments (42)
tests/hypothesis/model_test.py (1)
36-288: Well-structured Hypothesis tests with comprehensive coverage
The test methods using Hypothesis strategies are correctly implemented and provide comprehensive coverage for the fastkml.model module. The use of various strategies and filters ensures robust testing of edge cases.
docs/Makefile (1)
4-8: LGTM! Well-structured Makefile changes
The changes follow Make best practices:
- Using
?=for overridable variables - Clear documentation of variable purpose
- Well-implemented help target
- Flexible catch-all target for unknown make targets
Also applies to: 11-20
examples/shp2kml.py (1)
Line range hint 47-59: LGTM! Style creation looks good.
The style creation with ISO codes is implemented correctly.
docs/conf.py (1)
10-19: Verify path handling changes
The switch from os.path to pathlib is a good modernization, but we should ensure the path resolution works correctly for all documentation build scenarios.
✅ Verification successful
Path handling changes are correctly implemented
The path handling implementation in conf.py is correct and follows best practices:
- Uses
pathlibfor modern, cross-platform path handling - Correctly resolves the documentation root using
__file__ - Properly adds the project root to
sys.pathfor importing the package - Successfully imports
fastkml.aboutfor version information - The path structure is verified by the presence of the expected documentation files and proper imports throughout the codebase
🏁 Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash
# Verify the documentation build paths
cd docs
python3 -c "
import pathlib
import sys
DOC_ROOT = pathlib.Path('.').resolve()
PROJECT_ROOT = DOC_ROOT.parent
sys.path.insert(0, str(PROJECT_ROOT))
try:
import fastkml.about
print('✓ Path resolution successful')
except ImportError as e:
print(f'✗ Import failed: {e}')
"
Length of output: 408
Script:
#!/bin/bash
# Let's verify the path structure and imports using different approaches
# Check if the docs directory exists and its structure
ls -la docs/
# Check the content of conf.py to verify the imports and path handling
cat docs/conf.py
# Look for any other Python files that might import fastkml
rg "import.*fastkml" --type py
# Check if there are any other configuration files or build scripts
fd -e py -e ini -e cfg -e txt -e rst . docs/
Length of output: 8215
.pre-commit-config.yaml (1)
46-46: Verify ruff version compatibility
The update to ruff v0.8.0 may introduce new lint rules or breaking changes. Please ensure all existing code passes the updated checks.
examples/shp2kml_timed.py (3)
28-28: LGTM: Type annotation improves code clarity
The explicit type annotation for co2_pa as dict[str, dict[str, float]] enhances code readability and type safety.
59-61: LGTM: Improved numeric precision
The change from integer to float initialization for co2_growth and consistent use of float default in co2_pa lookup improves numeric precision.
41-41: Verify compatibility with shapefile data
The change from ADM0_A3 to ADM0_ISO for the ISO code key might affect compatibility with existing shapefiles.
docs/fastkml.rst (2)
33-38: LGTM: Improved registry documentation specificity
The explicit listing of RegistryItem and Registry members, along with the registry autodata directive, improves documentation clarity.
160-167: LGTM: Well-structured model module documentation
The new fastkml.model module documentation follows the established pattern and includes all necessary directives.
pyproject.toml (1)
25-26: LGTM! Enhanced project metadata.
The added classifiers for CPython and PyPy implementations, along with the Software Development Libraries topics, improve the project's discoverability and accurately reflect its capabilities.
Also applies to: 28-29
tests/hypothesis/network_link_control_test.py (1)
1-34: LGTM! Well-structured test setup.
The file has proper copyright notice, clear documentation, and well-organized imports necessary for hypothesis testing.
README.rst (3)
6-7: LGTM! Improved documentation clarity.
The reformatted KML description and enhanced geometry compatibility explanation improve the documentation's clarity and completeness.
Also applies to: 23-24
26-28: LGTM! Clear Python implementation support documentation.
The new section clearly documents the supported Python implementations and version requirements, aligning with the project's classifiers.
96-98: LGTM! Added conda-forge badge.
The addition of the conda-forge badge improves package visibility and follows the established badge format.
docs/quickstart.rst (2)
141-150: Documentation enhancement: Clear file reading instructions
The added note about using the parse method provides clear guidance for reading KML files directly.
217-224: Documentation enhancement: Clear file writing instructions
The added note about using the write method provides clear guidance for saving KML objects to files.
fastkml/links.py (1)
35-36: API clarity: Added explicit exports
The addition of __all__ improves the module's interface by clearly defining publicly accessible entities.
docs/create_kml_files.rst (1)
112-113: LGTM: Documentation accurately reflects the new KML writing approach
The documentation has been updated to use the new write method consistently, which is the recommended way to write KML files. This change improves clarity and promotes best practices.
Also applies to: 233-233
docs/working_with_kml.rst (2)
53-58: LGTM: Clear explanation of the find method behavior
The added note effectively clarifies the relationship between find and find_all methods, helping users understand when to use each method appropriately.
159-162: LGTM: Important validation note for handling gx:CascadingStyle
The added note provides crucial information about skipping validation when parsing documents with gx:CascadingStyle, preventing potential issues with XSD Schema validation.
fastkml/kml.py (1)
54-54: LGTM: Clean integration of NetworkLinkControl
The NetworkLinkControl feature has been properly integrated into the type system through the updated Union type and import statement.
Also applies to: 63-70
tests/hypothesis/overlay_test.py (2)
248-281: LGTM! Well-structured test method with comprehensive coverage.
The test method effectively uses parametrization to test multiple overlay classes while maintaining good type safety and comprehensive parameter testing.
283-311: LGTM! Comprehensive test coverage for ScreenOverlay.
The test method effectively validates the ScreenOverlay class with appropriate parameter combinations and serialization checks.
fastkml/containers.py (3)
44-44: LGTM! Proper module exports and imports.
The changes correctly expose the public API and import the necessary components.
Also applies to: 59-59
332-346: LGTM! Proper integration of ScreenOverlay into container registry.
The registry updates correctly integrate the ScreenOverlay class into the container system.
354-354: LGTM! Consistent namespace handling update.
The addition of an empty string to ns_ids aligns with the container registry changes.
fastkml/times.py (1)
44-48: Verify external usage of adjust_date_to_resolution.
The function has been removed from all, making it internal. While this improves API clarity, we should verify that this change doesn't break existing code.
✅ Verification successful
Removing adjust_date_to_resolution from all is safe
The function is only used internally within the times.py module itself and is not imported or used anywhere else in the codebase. All external imports of the times module only reference the public classes (KmlDateTime, TimeSpan, TimeStamp) that are still included in __all__. Making this function internal is a safe change that won't break existing code.
🏁 Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash
# Description: Check for external usage of adjust_date_to_resolution
# Search for direct imports of adjust_date_to_resolution
rg "from fastkml.times import adjust_date_to_resolution" --type py
# Search for potential usage through import *
rg "from fastkml.times import \*" --type py
Length of output: 114
Script:
#!/bin/bash
# Let's search for any usage of adjust_date_to_resolution in the codebase
rg "adjust_date_to_resolution" --type py
# Also search for potential usage through fastkml.times
rg "fastkml\.times" --type py
Length of output: 1884
tests/hypothesis/feature_test.py (1)
32-32: LGTM! Clean import addition.
The import of fastkml.model is properly placed with other fastkml imports.
tests/overlays_test.py (2)
29-29: LGTM! Clean import addition.
The import of Units from fastkml.enums is properly placed with other enum imports.
426-427: LGTM! Proper test class inheritance.
The Lxml test class properly inherits from both Lxml and TestScreenOverlay, following the established pattern.
fastkml/data.py (4)
53-53: LGTM: SimpleData correctly added to public API
The SimpleData class is appropriately exposed in the module's public interface.
314-314: LGTM: Namespace handling improved
The namespace registration now correctly handles both namespaced and non-namespaced KML elements.
647-647: LGTM: Consistent namespace handling
The namespace registration aligns with the codebase-wide standardization of namespace handling.
728-728: LGTM: Namespace standardization complete
The namespace registration completes the standardization of namespace handling across the module.
fastkml/features.py (3)
61-61: LGTM: Model support properly integrated
The changes correctly:
- Import the new Model class
- Remove the internal KmlGeometry type from public API
- Add Model to the supported geometry types
Also applies to: 73-73, 82-82
Line range hint 667-682: LGTM: Model geometry support added to Placemark
The Placemark registration correctly includes Model as a supported geometry type while maintaining proper namespace handling.
Line range hint 897-921: LGTM: NetworkLink namespace handling standardized
The namespace registrations for NetworkLink attributes have been properly standardized to support both namespaced and non-namespaced elements.
fastkml/styles.py (4)
65-76: LGTM: Public API properly defined
The module's public interface is well-defined with a comprehensive and alphabetically sorted list of style-related classes.
Line range hint 159-257: LGTM: Style base classes properly standardized
The namespace handling for StyleUrl and _ColorStyle has been standardized with appropriate default values.
Line range hint 529-1072: LGTM: Concrete style classes properly configured
The namespace handling and default values for all concrete style classes have been standardized consistently.
Line range hint 1164-1407: LGTM: StyleMap framework properly standardized
The namespace handling for Style, Pair, and StyleMap classes has been standardized consistently with the rest of the codebase.
| assert self.longitude is not None # noqa: S101 | ||
| assert self.latitude is not None # noqa: S101 | ||
| return Point(self.longitude, self.latitude, self.altitude) |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Avoid using assert statements for runtime value checks
Using assert statements for value checking in production code is not recommended, as they can be disabled with Python optimization flags. Consider replacing them with explicit checks and raising appropriate exceptions.
Modify the geometry property in the Location class:
def geometry(self) -> Optional[Point]:
"""Return a Point representation of the geometry."""
if not self:
return None
- assert self.longitude is not None # noqa: S101
- assert self.latitude is not None # noqa: S101
+ if self.longitude is None or self.latitude is None:
+ raise ValueError("Longitude and latitude must not be None")
return Point(self.longitude, self.latitude, self.altitude)📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| assert self.longitude is not None # noqa: S101 | |
| assert self.latitude is not None # noqa: S101 | |
| return Point(self.longitude, self.latitude, self.altitude) | |
| if self.longitude is None or self.latitude is None: | |
| raise ValueError("Longitude and latitude must not be None") | |
| return Point(self.longitude, self.latitude, self.altitude) |
| @@ -17,7 +17,6 @@ def print_child_features(element, depth=0): | |||
| examples_dir = pathlib.Path(__file__).parent | |||
| fname = pathlib.Path(examples_dir / "KML_Samples.kml") | |||
|
|
|||
| with fname.open(encoding="utf-8") as kml_file: | |||
| k = kml.KML.from_string(kml_file.read().encode("utf-8")) | |||
| k = kml.KML.parse(fname) | |||
There was a problem hiding this comment.
🛠️ Refactor suggestion
Add error handling for file operations
While the simplified parsing is good, the code should handle potential file operation errors.
Consider adding error handling:
- k = kml.KML.parse(fname)
+ try:
+ k = kml.KML.parse(fname)
+ except (FileNotFoundError, PermissionError) as e:
+ print(f"Error reading KML file: {e}")
+ sys.exit(1)
+ except Exception as e:
+ print(f"Error parsing KML file: {e}")
+ sys.exit(1)Don't forget to add import sys at the top of the file.
Committable suggestion skipped: line range outside the PR's diff.
| @@ -35,7 +35,7 @@ | |||
|
|
|||
| for feature in shp.__geo_interface__["features"]: | |||
| geometry = shape(feature["geometry"]) | |||
| co2_emission = co2_data.get(feature["properties"]["ADM0_A3"], 0) | |||
| co2_emission = co2_data.get(feature["properties"]["ADM0_ISO"], 0) | |||
There was a problem hiding this comment.
🛠️ Refactor suggestion
Add error handling for missing ISO codes.
The code assumes the ISO code will be present in the properties. Consider adding more robust error handling.
- co2_emission = co2_data.get(feature["properties"]["ADM0_ISO"], 0)
+ iso_code = feature["properties"].get("ADM0_ISO")
+ if not iso_code:
+ print(f"Warning: Missing ISO code for {feature['properties'].get('NAME', 'Unknown country')}")
+ co2_emission = co2_data.get(iso_code, 0)📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| co2_emission = co2_data.get(feature["properties"]["ADM0_ISO"], 0) | |
| iso_code = feature["properties"].get("ADM0_ISO") | |
| if not iso_code: | |
| print(f"Warning: Missing ISO code for {feature['properties'].get('NAME', 'Unknown country')}") | |
| co2_emission = co2_data.get(iso_code, 0) |
| xy = partial( | ||
| st.builds, | ||
| x=st.floats(allow_nan=False, allow_infinity=False), | ||
| y=st.floats(allow_nan=False, allow_infinity=False), | ||
| x_units=st.sampled_from(fastkml.enums.Units), | ||
| y_units=st.sampled_from(fastkml.enums.Units), | ||
| ) |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Add type hints and docstring to the xy function
The xy partial function is missing:
- Type hints for the return type and the class it's building
- A docstring explaining its purpose and usage
xy = partial(
st.builds,
+ # Add the class being built here, e.g., XYCoordinate
x=st.floats(allow_nan=False, allow_infinity=False),
y=st.floats(allow_nan=False, allow_infinity=False),
x_units=st.sampled_from(fastkml.enums.Units),
y_units=st.sampled_from(fastkml.enums.Units),
-)
+) -> st.SearchStrategy[XYCoordinate]:
+ """Generate a strategy for XY coordinates with units.
+
+ Returns:
+ A strategy that generates XYCoordinate instances with random x, y values
+ and their corresponding units.
+ """Committable suggestion skipped: line range outside the PR's diff.
|
Preparing review... |
User description
PR Type
Enhancement, Documentation, Tests, Configuration changes, Dependencies
Description
ScreenOverlay,NetworkLinkControl, and 3D model representation.ruff-pre-commitandpyproject.toml.Changes walkthrough 📝
16 files
overlays.py
Introduced Screen Overlay and XY Positioning Classesfastkml/overlays.py
fastkml.enumsandfastkml.helpers._XY,OverlayXY,ScreenXY,RotationXY,Size,and
ScreenOverlay.__all__to include new classes.model.py
Added Model and Related Classes for 3D Representationfastkml/model.py
Location,Orientation,Scale,Alias,ResourceMap,and
Model.__all__to include new classes.network_link_control.py
Added NetworkLinkControl Class for Network Managementfastkml/network_link_control.py
NetworkLinkControlclass for managing network linkbehavior.
__all__to includeNetworkLinkControl.features.py
Integrated Model with Features and Updated Registrationsfastkml/features.py
Modelfromfastkml.model.__all__to removeKmlGeometry.ModelwithPlacemark.styles.py
Updated Style Module with Explicit Exports and Registrationsfastkml/styles.py
__all__to include all style-related classes.geometry.py
Enhanced Geometry Module with Boundary and Creation Functionsfastkml/geometry.py
__all__to include boundary classes and geometry creationfunctions.
views.py
Updated Namespace Identifiers in Views Modulefastkml/views.py
__init__.py
Expanded Module Exports and Updated Metadatafastkml/init.py
__all__to include new classes and functions.links.py
Updated Links Module with Explicit Exports and Registrationsfastkml/links.py
__all__to includeIconandLink.shp2kml_timed.py
Updated Example Script for Timed KML Conversionexamples/shp2kml_timed.py
ADM0_ISOfor ISO code.shp2kml.py
Updated Example Script for KML Conversionexamples/shp2kml.py
ADM0_ISOfor ISO code.containers.py
Updated Containers Module with Exports and Registrationsfastkml/containers.py
__all__to includeDocumentandFolder.ScreenOverlayto registry.kml.py
Integrated NetworkLinkControl into KML Modulefastkml/kml.py
NetworkLinkControlto KML children.NetworkLinkControl.data.py
Introduced SimpleData Class for Custom Data Fieldsfastkml/data.py
SimpleDataclass with documentation.SimpleDatawithSchemaData.base.py
Refactor attribute setting in `base.py` constructorfastkml/base.py
items()for setting attributes fromkwargs.simple_example.py
Simplify KML file parsing in example scriptexamples/simple_example.py
parsemethod directly.12 files
conf.py
Updated Sphinx Configuration for Documentationdocs/conf.py
registry.py
Clarified Documentation for Registry Usagefastkml/registry.py
README.rst
Improve README clarity and add conda-forge badgeREADME.rst
quickstart.rst
Update quickstart guide with simplified examples and notesdocs/quickstart.rst
working_with_kml.rst
Add notes and update examples in working with KMLdocs/working_with_kml.rst
findmethod and parsing without validation.create_kml_files.rst
Simplify KML file writing examplesdocs/create_kml_files.rst
writemethod.upgrading.rst
Add upgrading guide for FastKMLdocs/upgrading.rst
network.kml
Add NetworkLinkControl KML exampledocs/network.kml
fastkml.rst
Update fastkml.rst to include specific membersdocs/fastkml.rst
HISTORY.rst
Update changelog for version 1.1.0docs/HISTORY.rst
kml.rst
Add KML resources and tutorials sectiondocs/kml.rst
index.rst
Update index with new sectionsdocs/index.rst
8 files
model_test.py
Added Hypothesis Tests for Model Moduletests/hypothesis/model_test.py
fastkml.modelmodule.Location,Orientation,Scale,Alias,ResourceMap, andModel.model_test.py
Added Unit Tests for Model Classtests/model_test.py
Modelclass and its components.network_link_control_test.py
Added Hypothesis Tests for NetworkLinkControltests/hypothesis/network_link_control_test.py
NetworkLinkControl.overlays_test.py
Added Unit Tests for ScreenOverlay Classtests/overlays_test.py
ScreenOverlayclass.overlay_test.py
Added Hypothesis Tests for Overlay Classestests/hypothesis/overlay_test.py
OverlayXY,RotationXY,ScreenXY, andSize.network_link_control_test.py
Added Unit Tests for NetworkLinkControl Classtests/network_link_control_test.py
NetworkLinkControlclass.feature_test.py
Added Hypothesis Tests for Placemark with Modeltests/hypothesis/feature_test.py
PlacemarkwithModel.strategies.py
Added XY Strategy for Hypothesis Testingtests/hypothesis/strategies.py
xystrategy for generating XY coordinates.1 files
times.py
Update `__all__` in `times.py` to remove unused exportfastkml/times.py
__all__to removeadjust_date_to_resolution.4 files
about.py
Update version number to 1.1.0fastkml/about.py
Makefile
Simplify Sphinx Makefile with catch-all targetdocs/Makefile
pyproject.toml
Update project classifiers in pyproject.tomlpyproject.toml
_typos.toml
Update typos configuration with new identifiers_typos.toml
1 files
.pre-commit-config.yaml
Update ruff-pre-commit version.pre-commit-config.yaml
ruff-pre-commitversion from v0.7.4 to v0.8.0.Summary by CodeRabbit
Release Notes
New Features
NetworkLinkControl, enhancing KML network link functionality.Location,Orientation,Scale, andModel.Documentation Improvements
Bug Fixes
Tests
fastkml.modelandNetworkLinkControlmodules, ensuring reliability and correctness of KML handling.