home / github

Menu
  • GraphQL API
  • Search all tables

issue_comments

Table actions
  • GraphQL API for issue_comments

5 rows where author_association = "CONTRIBUTOR" and issue = 95114700 sorted by updated_at descending

✎ View and edit SQL

This data as json, CSV (advanced)

Suggested facets: reactions, created_at (date), updated_at (date)

user 3

  • WeatherGod 2
  • burnpanck 2
  • duncanwp 1

issue 1

  • API design for pointwise indexing · 5 ✖

author_association 1

  • CONTRIBUTOR · 5 ✖
id html_url issue_url node_id user created_at updated_at ▲ author_association body reactions performed_via_github_app issue
356327572 https://github.com/pydata/xarray/issues/475#issuecomment-356327572 https://api.github.com/repos/pydata/xarray/issues/475 MDEyOklzc3VlQ29tbWVudDM1NjMyNzU3Mg== duncanwp 3169620 2018-01-09T16:01:16Z 2018-01-09T16:01:16Z CONTRIBUTOR

Further to the comment I made in a related issue #486 comment I've now taken a simplified version of the collocation approach in CIS and created a stand-alone package which works with xarray objects: https://github.com/cistools/collocate.

This works essentially the same as the nice example shown in the above blog, with some key differences: * The points within a certain distance (tolerance) of each sample point can be aggregated or selected from using the built-in kernels, allowing fast operations over many sample points. * The horizontal distance constraint can be supplemented with constraints in other dimensions (such as time or altitude). * The transform from Cartesian to Eucledian coordinates is not needed as we use our own KD-Tree implementation which builds haversine rectangles. Depending on use cases this isn't always the fastest approach, but it does sidestep some nasty dateline issues. * In the case where only the nearest points in the horizontal is needed the collocation falls back the fast single point lookup. * The KD-Tree implementation is (relatively well) separated so could easily be switched out for cKDtree or pyresample implementations * There are a some tests too, although no docs yet.

I'll try and put together a notebook building on the above blogpost so that the similarities and differences are a bit clearer.

I'm not familiar enough with xarray indexing to be able to say how well this would fit inside xarray, but hopefully it will be useful before we're able to crack KD-MultiIndexes!

{
    "total_count": 2,
    "+1": 2,
    "-1": 0,
    "laugh": 0,
    "hooray": 0,
    "confused": 0,
    "heart": 0,
    "rocket": 0,
    "eyes": 0
}
  API design for pointwise indexing 95114700
342576941 https://github.com/pydata/xarray/issues/475#issuecomment-342576941 https://api.github.com/repos/pydata/xarray/issues/475 MDEyOklzc3VlQ29tbWVudDM0MjU3Njk0MQ== WeatherGod 291576 2017-11-07T18:29:12Z 2017-11-07T18:29:12Z CONTRIBUTOR

Yeah, we need to move something forward, because the main benefit of xarray is the ability to manage datasets from multiple sources in a consistent way. And data from different sources will almost always be in different projections.

My current problem that I need to solve right now is that I am ingesting model data that is in a LCC projection and ingesting radar data that is in a simple regular lat/lon grid. Both dataset objects have latitude and longitude coordinate arrays, I just need to get both datasets to have the same lat/lon grid.

I guess I could continue using my old scipy-based solution (using map_coordinates() or RectBivariateSpline), but at the very least, it would make sense to have some documentation demonstrating how one might go about this very common problem, even if it is showing how to use the scipy-based tools with xarrays. If that is of interest, I can see what I can write up after I am done my immediate task.

{
    "total_count": 0,
    "+1": 0,
    "-1": 0,
    "laugh": 0,
    "hooray": 0,
    "confused": 0,
    "heart": 0,
    "rocket": 0,
    "eyes": 0
}
  API design for pointwise indexing 95114700
342553465 https://github.com/pydata/xarray/issues/475#issuecomment-342553465 https://api.github.com/repos/pydata/xarray/issues/475 MDEyOklzc3VlQ29tbWVudDM0MjU1MzQ2NQ== WeatherGod 291576 2017-11-07T17:11:49Z 2017-11-07T17:11:49Z CONTRIBUTOR

So, what has become the consensus for performing regridding/resampling? I see a lot of suggestions, but I have no sense of what is mature enough to use in production-level code. I also haven't seen anything in the documentation about this topic, even if it just refers people to another project.

{
    "total_count": 0,
    "+1": 0,
    "-1": 0,
    "laugh": 0,
    "hooray": 0,
    "confused": 0,
    "heart": 0,
    "rocket": 0,
    "eyes": 0
}
  API design for pointwise indexing 95114700
256206191 https://github.com/pydata/xarray/issues/475#issuecomment-256206191 https://api.github.com/repos/pydata/xarray/issues/475 MDEyOklzc3VlQ29tbWVudDI1NjIwNjE5MQ== burnpanck 1310437 2016-10-25T23:13:37Z 2016-10-25T23:17:40Z CONTRIBUTOR

Really? I get a ValueError: Indexers must be 1 dimensional (xarray/core/dataset.py:1031 in isel_points(self, dim, **indexers) when I try. That is xarray 0.8.2, in fact from my fork recently cloned (~2-3 weeks ago), where I changed one or two asarray to asanyarray to work with units. Was there a recent change in this area? EDIT: xarray/core/dataset.py looks very similar also here on master, and there are quite a few lines hinting that really only 1D indexers are supported.

{
    "total_count": 0,
    "+1": 0,
    "-1": 0,
    "laugh": 0,
    "hooray": 0,
    "confused": 0,
    "heart": 0,
    "rocket": 0,
    "eyes": 0
}
  API design for pointwise indexing 95114700
256199958 https://github.com/pydata/xarray/issues/475#issuecomment-256199958 https://api.github.com/repos/pydata/xarray/issues/475 MDEyOklzc3VlQ29tbWVudDI1NjE5OTk1OA== burnpanck 1310437 2016-10-25T22:44:30Z 2016-10-25T22:44:30Z CONTRIBUTOR

Without following the discussion in detail, what is the status here? In particular, I would like to do pointwise selection on multiple 1D coordinates using multidimensional indexer arrays. I can do this with the current isel_points: 1. construct the multidimensional indexers 2. flatten them 3. create a corresponding MultiIndex 4. apply the flattened indexers using isel_points, and assign the multi-index as the new dimension 5. use unstack on the newly created dimension The first three points can be somewhat simplified by instead putting all of the multidimensional indexer into a Dataset and then stack it to create consistent flat versions and their multi-index.

Given this conceptually easy but somewhat tedious procedure, couldn't that be something that could quite easily be implemented into the current isel_points? Would a PR along that direction have a chance of being accepted?

{
    "total_count": 0,
    "+1": 0,
    "-1": 0,
    "laugh": 0,
    "hooray": 0,
    "confused": 0,
    "heart": 0,
    "rocket": 0,
    "eyes": 0
}
  API design for pointwise indexing 95114700

Advanced export

JSON shape: default, array, newline-delimited, object

CSV options:

CREATE TABLE [issue_comments] (
   [html_url] TEXT,
   [issue_url] TEXT,
   [id] INTEGER PRIMARY KEY,
   [node_id] TEXT,
   [user] INTEGER REFERENCES [users]([id]),
   [created_at] TEXT,
   [updated_at] TEXT,
   [author_association] TEXT,
   [body] TEXT,
   [reactions] TEXT,
   [performed_via_github_app] TEXT,
   [issue] INTEGER REFERENCES [issues]([id])
);
CREATE INDEX [idx_issue_comments_issue]
    ON [issue_comments] ([issue]);
CREATE INDEX [idx_issue_comments_user]
    ON [issue_comments] ([user]);
Powered by Datasette · Queries took 332.889ms · About: xarray-datasette