Skip to content

search_usedirect

Search Implementation: Reserve California

SearchAlabamaStateParks #

Bases: SearchUseDirect

Searches on ReserveAlaPark.com for Campsites

Source code in camply/search/search_usedirect.py 
274
275
276
277
278
279
class SearchAlabamaStateParks(SearchUseDirect):
    """
    Searches on ReserveAlaPark.com for Campsites
    """

    provider_class = AlabamaStateParks

SearchArizonaStateParks #

Bases: SearchUseDirect

Searches on AZStateParks.com for Campsites

Source code in camply/search/search_usedirect.py 
250
251
252
253
254
255
class SearchArizonaStateParks(SearchUseDirect):
    """
    Searches on AZStateParks.com for Campsites
    """

    provider_class = ArizonaStateParks

SearchFairfaxCountyParks #

Bases: SearchUseDirect

Searches on fairfax.usedirect.com for Campsites (Virginia)

Source code in camply/search/search_usedirect.py 
282
283
284
285
286
287
class SearchFairfaxCountyParks(SearchUseDirect):
    """
    Searches on fairfax.usedirect.com for Campsites (Virginia)
    """

    provider_class = FairfaxCountyParks

SearchFloridaStateParks #

Bases: SearchUseDirect

Searches on FloridaStateParks.org for Campsites

Source code in camply/search/search_usedirect.py 
218
219
220
221
222
223
class SearchFloridaStateParks(SearchUseDirect):
    """
    Searches on FloridaStateParks.org for Campsites
    """

    provider_class = FloridaStateParks

SearchMaricopaCountyParks #

Bases: SearchUseDirect

Searches on MaricopaCountyParks.org for Campsites (Arizona)

Source code in camply/search/search_usedirect.py 
258
259
260
261
262
263
class SearchMaricopaCountyParks(SearchUseDirect):
    """
    Searches on MaricopaCountyParks.org for Campsites (Arizona)
    """

    provider_class = MaricopaCountyParks

SearchMinnesotaStateParks #

Bases: SearchUseDirect

Searches on ReserveMN.usedirect.com for Campsites

Source code in camply/search/search_usedirect.py 
290
291
292
293
294
295
class SearchMinnesotaStateParks(SearchUseDirect):
    """
    Searches on ReserveMN.usedirect.com for Campsites
    """

    provider_class = MinnesotaStateParks

SearchMissouriStateParks #

Bases: SearchUseDirect

Searches on icampmo1.usedirect.com for Campsites

Source code in camply/search/search_usedirect.py 
266
267
268
269
270
271
class SearchMissouriStateParks(SearchUseDirect):
    """
    Searches on icampmo1.usedirect.com for Campsites
    """

    provider_class = MissouriStateParks

SearchNorthernTerritory #

Bases: SearchUseDirect

Searches the Australian Northern Territory for Campsites

Source code in camply/search/search_usedirect.py 
210
211
212
213
214
215
class SearchNorthernTerritory(SearchUseDirect):
    """
    Searches the Australian Northern Territory for Campsites
    """

    provider_class = NorthernTerritory

SearchOhioStateParks #

Bases: SearchUseDirect

Searches on ReserveOhio.com for Campsites

Source code in camply/search/search_usedirect.py 
234
235
236
237
238
239
class SearchOhioStateParks(SearchUseDirect):
    """
    Searches on ReserveOhio.com for Campsites
    """

    provider_class = OhioStateParks

SearchOregonMetro #

Bases: SearchUseDirect

Searches on OregonMetro.gov for Campsites (Portland Metro)

Source code in camply/search/search_usedirect.py 
226
227
228
229
230
231
class SearchOregonMetro(SearchUseDirect):
    """
    Searches on OregonMetro.gov for Campsites (Portland Metro)
    """

    provider_class = OregonMetro

SearchReserveCalifornia #

Bases: SearchUseDirect

Search ReserveCalifornia

Source code in camply/search/search_usedirect.py 
202
203
204
205
206
207
class SearchReserveCalifornia(SearchUseDirect):
    """
    Search ReserveCalifornia
    """

    provider_class = ReserveCalifornia

SearchUseDirect #

Bases: BaseCampingSearch, ABC

Searches on UseDirect.com for Campsites

Source code in camply/search/search_usedirect.py 
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
class SearchUseDirect(BaseCampingSearch, ABC):
    """
    Searches on UseDirect.com for Campsites
    """

    @property
    @abstractmethod
    def provider_class(self) -> Type[BaseCampingSearch]:
        """
        Provider Class to be used for Search
        """
        pass

    def __init__(
        self,
        search_window: Union[SearchWindow, List[SearchWindow]],
        recreation_area: List[int],
        weekends_only: bool = False,
        campgrounds: Optional[Union[List[str], str]] = None,
        nights: int = 1,
        **kwargs,
    ) -> None:
        """
        Initialize with Search Parameters

        Parameters
        ----------
        search_window: Union[SearchWindow, List[SearchWindow]]
            Search Window tuple containing start date and End Date
        recreation_area: List[int]
            The IDs of the recreation area to be searched.
        weekends_only: bool
            Whether to only search for Camping availabilities on the weekends (Friday /
            Saturday nights)
        campgrounds: Union[List[int], int]
            Campground ID or List of Campground IDs
        nights: int
            minimum number of consecutive nights to search per campsite,defaults to 1
        """
        super().__init__(
            search_window=search_window,
            weekends_only=weekends_only,
            nights=nights,
            **kwargs,
        )
        self._recreation_area_ids: List[int] = make_list(recreation_area, coerce=int)
        self._campground_ids: List[int] = make_list(campgrounds, coerce=int)
        campsites = make_list(kwargs.get("campsites", []), coerce=int) or []
        if len(campsites) > 0:
            self.campsite_finder.validate_campsites(
                campsites=campsites, facility_ids=self._campground_ids
            )
        try:
            assert any(
                [
                    self._campground_ids not in (None, []),
                    self._recreation_area_ids not in (None, []),
                ]
            )
        except AssertionError:
            logger.error(
                f"You must provide a Campground ID or a Recreation Area ID to {self.provider_class.__name__}"
            )
            sys.exit(1)
        if self._campground_ids:
            self.campgrounds = self.campsite_finder.find_campgrounds(
                campground_id=self._campground_ids,
                verbose=False,
            )
        else:
            self.campgrounds = self.campsite_finder.find_campgrounds(
                rec_area_id=self._recreation_area_ids,
                verbose=False,
            )
        self.campground_ids = [item.facility_id for item in self.campgrounds]
        if len(self.campground_ids) == 0:
            logger.error("No Campsites Found Matching Your Search Criteria")
            sys.exit(1)
        if kwargs.get("equipment", ()):
            logger.warning(
                "%s Doesn't Support Equipment, yet 🙂", self.provider_class.__name__
            )

    def get_all_campsites(self, **kwargs: Dict[str, Any]) -> List[AvailableCampsite]:
        """
        Retrieve All Campsites from the UseDirect API

        Parameters
        ----------
        kwargs: Dict[str, Any]

        Returns
        -------
        List[AvailableCampsite]
        """
        logger.info(f"Searching across {len(self.campgrounds)} campgrounds")
        for campground in self.campgrounds:
            log_str = format_log_string(campground)
            logger.info("    %s", log_str)
        campsites_found: List[AvailableCampsite] = []
        for month in self.search_months:
            for campground in self.campgrounds:
                logger.info(
                    f"Searching {campground.facility_name}, {campground.recreation_area} "
                    f"({campground.facility_id}) for availability: "
                    f"{month.strftime('%B, %Y')}"
                )
                end_date = month + relativedelta(months=1) - timedelta(days=1)
                campsites = self.campsite_finder.get_campsites(
                    campground_id=campground.facility_id,
                    start_date=month,
                    end_date=end_date,
                )
                logger.info(
                    f"\t{logging_utils.get_emoji(campsites)}\t"
                    f"{len(campsites)} total sites found in month of "
                    f"{month.strftime('%B')}"
                )
                campsites_found += campsites
        campsite_df = self.campsites_to_df(campsites=campsites_found)
        campsite_df_validated = self._filter_date_overlap(campsites=campsite_df)
        consolidated_campsites = self._consolidate_campsites(
            campsite_df=campsite_df_validated, nights=self.nights
        )
        compiled_campsites = self.df_to_campsites(campsite_df=consolidated_campsites)
        return compiled_campsites

    @classmethod
    def find_recreation_areas(
        cls, search_string: str, **kwargs
    ) -> List[RecreationArea]:
        """
        Return the UseDirect Recreation Areas
        """
        rec_areas = cls.provider_class().search_for_recreation_areas(
            query=search_string, state=kwargs.get("state")
        )
        logger.info(f"{len(rec_areas)} Matching Recreation Areas Found")
        log_sorted_response(rec_areas)
        return rec_areas

    def list_campsite_units(self) -> List[ListedCampsite]:
        """
        List Campsite Units

        Returns
        -------
        List[ListedCampsite]
        """
        if not self.campsite_finder.usedirect_campsites:
            self.campsite_finder.get_campsite_metadata(facility_ids=self.campground_ids)
        sorted_campsites = sorted(
            self.campsite_finder.usedirect_campsites.values(),
            key=lambda x: x.OrderByRaw,
        )
        logged_campsites = [
            ListedCampsite(id=item.UnitId, name=item.Name, facility_id=item.FacilityId)
            for item in sorted_campsites
        ]
        self.log_listed_campsites(
            campsites=logged_campsites,
            facilities=self.campgrounds,
        )
        return logged_campsites

provider_class: Type[BaseCampingSearch] abstractmethod property #

Provider Class to be used for Search

__init__(search_window, recreation_area, weekends_only=False, campgrounds=None, nights=1, **kwargs) #

Initialize with Search Parameters

Parameters:

Name Type Description Default
search_window Union[SearchWindow, List[SearchWindow]]

Search Window tuple containing start date and End Date

 required
recreation_area List[int]

The IDs of the recreation area to be searched.

 required
weekends_only bool

Whether to only search for Camping availabilities on the weekends (Friday / Saturday nights)

 False
campgrounds Optional[Union[List[str], str]]

Campground ID or List of Campground IDs

 None
nights int

minimum number of consecutive nights to search per campsite,defaults to 1

 1
Source code in camply/search/search_usedirect.py 
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def __init__(
    self,
    search_window: Union[SearchWindow, List[SearchWindow]],
    recreation_area: List[int],
    weekends_only: bool = False,
    campgrounds: Optional[Union[List[str], str]] = None,
    nights: int = 1,
    **kwargs,
) -> None:
    """
    Initialize with Search Parameters

    Parameters
    ----------
    search_window: Union[SearchWindow, List[SearchWindow]]
        Search Window tuple containing start date and End Date
    recreation_area: List[int]
        The IDs of the recreation area to be searched.
    weekends_only: bool
        Whether to only search for Camping availabilities on the weekends (Friday /
        Saturday nights)
    campgrounds: Union[List[int], int]
        Campground ID or List of Campground IDs
    nights: int
        minimum number of consecutive nights to search per campsite,defaults to 1
    """
    super().__init__(
        search_window=search_window,
        weekends_only=weekends_only,
        nights=nights,
        **kwargs,
    )
    self._recreation_area_ids: List[int] = make_list(recreation_area, coerce=int)
    self._campground_ids: List[int] = make_list(campgrounds, coerce=int)
    campsites = make_list(kwargs.get("campsites", []), coerce=int) or []
    if len(campsites) > 0:
        self.campsite_finder.validate_campsites(
            campsites=campsites, facility_ids=self._campground_ids
        )
    try:
        assert any(
            [
                self._campground_ids not in (None, []),
                self._recreation_area_ids not in (None, []),
            ]
        )
    except AssertionError:
        logger.error(
            f"You must provide a Campground ID or a Recreation Area ID to {self.provider_class.__name__}"
        )
        sys.exit(1)
    if self._campground_ids:
        self.campgrounds = self.campsite_finder.find_campgrounds(
            campground_id=self._campground_ids,
            verbose=False,
        )
    else:
        self.campgrounds = self.campsite_finder.find_campgrounds(
            rec_area_id=self._recreation_area_ids,
            verbose=False,
        )
    self.campground_ids = [item.facility_id for item in self.campgrounds]
    if len(self.campground_ids) == 0:
        logger.error("No Campsites Found Matching Your Search Criteria")
        sys.exit(1)
    if kwargs.get("equipment", ()):
        logger.warning(
            "%s Doesn't Support Equipment, yet 🙂", self.provider_class.__name__
        )

find_recreation_areas(search_string, **kwargs) classmethod #

Return the UseDirect Recreation Areas

Source code in camply/search/search_usedirect.py 
163
164
165
166
167
168
169
170
171
172
173
174
175
@classmethod
def find_recreation_areas(
    cls, search_string: str, **kwargs
) -> List[RecreationArea]:
    """
    Return the UseDirect Recreation Areas
    """
    rec_areas = cls.provider_class().search_for_recreation_areas(
        query=search_string, state=kwargs.get("state")
    )
    logger.info(f"{len(rec_areas)} Matching Recreation Areas Found")
    log_sorted_response(rec_areas)
    return rec_areas

get_all_campsites(**kwargs) #

Retrieve All Campsites from the UseDirect API

Parameters:

Name Type Description Default
kwargs Dict[str, Any]
{}

Returns:

Type Description
List[AvailableCampsite]
Source code in camply/search/search_usedirect.py 
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
def get_all_campsites(self, **kwargs: Dict[str, Any]) -> List[AvailableCampsite]:
    """
    Retrieve All Campsites from the UseDirect API

    Parameters
    ----------
    kwargs: Dict[str, Any]

    Returns
    -------
    List[AvailableCampsite]
    """
    logger.info(f"Searching across {len(self.campgrounds)} campgrounds")
    for campground in self.campgrounds:
        log_str = format_log_string(campground)
        logger.info("    %s", log_str)
    campsites_found: List[AvailableCampsite] = []
    for month in self.search_months:
        for campground in self.campgrounds:
            logger.info(
                f"Searching {campground.facility_name}, {campground.recreation_area} "
                f"({campground.facility_id}) for availability: "
                f"{month.strftime('%B, %Y')}"
            )
            end_date = month + relativedelta(months=1) - timedelta(days=1)
            campsites = self.campsite_finder.get_campsites(
                campground_id=campground.facility_id,
                start_date=month,
                end_date=end_date,
            )
            logger.info(
                f"\t{logging_utils.get_emoji(campsites)}\t"
                f"{len(campsites)} total sites found in month of "
                f"{month.strftime('%B')}"
            )
            campsites_found += campsites
    campsite_df = self.campsites_to_df(campsites=campsites_found)
    campsite_df_validated = self._filter_date_overlap(campsites=campsite_df)
    consolidated_campsites = self._consolidate_campsites(
        campsite_df=campsite_df_validated, nights=self.nights
    )
    compiled_campsites = self.df_to_campsites(campsite_df=consolidated_campsites)
    return compiled_campsites

list_campsite_units() #

List Campsite Units

Returns:

Type Description
List[ListedCampsite]
Source code in camply/search/search_usedirect.py 
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
def list_campsite_units(self) -> List[ListedCampsite]:
    """
    List Campsite Units

    Returns
    -------
    List[ListedCampsite]
    """
    if not self.campsite_finder.usedirect_campsites:
        self.campsite_finder.get_campsite_metadata(facility_ids=self.campground_ids)
    sorted_campsites = sorted(
        self.campsite_finder.usedirect_campsites.values(),
        key=lambda x: x.OrderByRaw,
    )
    logged_campsites = [
        ListedCampsite(id=item.UnitId, name=item.Name, facility_id=item.FacilityId)
        for item in sorted_campsites
    ]
    self.log_listed_campsites(
        campsites=logged_campsites,
        facilities=self.campgrounds,
    )
    return logged_campsites

SearchVirginiaStateParks #

Bases: SearchUseDirect

Searches on ReserveVAParks.com for Campsites

Source code in camply/search/search_usedirect.py 
242
243
244
245
246
247
class SearchVirginiaStateParks(SearchUseDirect):
    """
    Searches on ReserveVAParks.com for Campsites
    """

    provider_class = VirginiaStateParks