pycocowriter 0.0.1__py2.py3-none-any.whl

pycocowriter/coco.py

@@ -0,0 +1,348 @@
+import datetime
+import json
+from collections.abc import Iterable
+import numpy as np
+from . import utils
+
+class COCOBase(object):
+    '''
+    base class to facilitate conversion of COCO stuff to a dictionary.
+
+    TODO: refactor COCO classes to extend pycocotools' COCO
+
+    TODO: refactor COCO classes to use AttrDict
+    '''
+    def _to_dict_fields(self, fields:list[str]) -> dict:
+        return {field: self.__dict__[field] for field in fields if self.__dict__[field] is not None}
+    def to_dict(self):
+        '''convert COCO object to dictionary'''
+        raise NotImplementedError('must implement a to_dict method!')
+
+
+class COCOAnnotation(COCOBase):
+    '''
+        see https://cocodataset.org/#format-data
+
+        see https://github.com/cocodataset/cocoapi/issues/184
+
+            annotation {
+                "id": int,
+                "image_id": int,
+                "category_id": int,
+                "segmentation": RLE or [polygon],
+                "area": float,
+                "bbox": [x,y,width,height],
+                "iscrowd": 0 or 1,
+                "keypoints": [x1,y1,v1...],
+                "num_keypoints": int
+            }
+
+        keypoints should be 3*len(keypoints_category), where keypoints_category is the keypoints in the corresponding category
+    '''
+    def __init__(self, image_id:int, eye_d:int, category_id:int, bbox:tuple[int]=None, area:float=None, segmentation=None, iscrowd:int=None, keypoints:list[int]=None):
+        self.image_id = image_id
+        self.id = eye_d
+        self.category_id = category_id
+        self.bbox = bbox
+        area = area or self._compute_area()
+        self.area = area
+        self.segmentation = segmentation
+        self.iscrowd = iscrowd or 0
+        self.keypoints = keypoints
+        self.num_keypoints = self._compute_num_keypoints()
+            
+    def _compute_num_keypoints(self):
+        if self.keypoints is not None:
+            # the number of keypoints is the number of "visible" keypoints.
+            return sum([v > 0 for v in self.keypoints[::3]])
+        return None
+
+    def _compute_area(self):
+        if self.bbox is not None:
+            return self.bbox[-1] * self.bbox[-2]
+        return None
+
+    def to_dict(self):
+        return self._to_dict_fields(
+            ['image_id', 'id', 'category_id', 'bbox', 
+             'area', 'segmentation', 'iscrowd', 
+             'keypoints', 'num_keypoints'])
+        
+
+class COCOCategory(COCOBase):
+    '''
+        see https://cocodataset.org/#format-data
+        
+        see https://github.com/facebookresearch/Detectron/issues/640
+        
+            category {
+                "id": int,
+                "name": str,
+                "supercategory": str,
+                "keypoints": [str],
+                "skeleton": [edge]
+            }
+        
+        An edge is a tuple [a,b] where a,b are 1-indexed indices in the keypoints list.  So if keypoints is ["a", "b"], then [1,2] is an edge between "a" and "b"
+    '''
+    def __init__(self, name:str, eye_d:int, supercategory:str=None, keypoints:list[str]=None, skeleton:list[list[int]]=None):
+        self.name = name
+        self.id = eye_d
+        self.supercategory = supercategory
+        self.keypoints = keypoints
+        self.skeleton = skeleton
+
+    def to_dict(self):
+        return self._to_dict_fields(
+            ['name', 'id', 'supercategory', 'keypoints', 'skeleton']
+        )
+
+
+class COCOLicense(COCOBase):
+    '''
+        see https://cocodataset.org/#format-data
+        
+            license {
+                "id": int,
+                "name": str,
+                "url": str,
+            }
+    '''
+    def __init__(self, name:str, eye_d:int, url:str=None):
+        self.name = name
+        self.id = eye_d
+        self.url = url
+
+    def to_dict(self):
+        return self._to_dict_fields(
+            ['name', 'id', 'url']
+        )
+
+
+class COCOImage(COCOBase):
+    '''
+        see https://cocodataset.org/#format-data
+        
+            image {
+                "id": int,
+                "width": int,
+                "height": int,
+                "file_name": str,
+                "license": int,
+                "flickr_url": str,
+                "coco_url": str,
+                "date_captured": datetime,
+            }
+    '''
+    def __init__(self, 
+                 eye_d:int, file_name:str, 
+                 width:int=None, height:int=None, 
+                 license:int=None, coco_url:str=None, 
+                 date_captured:datetime.datetime=None):
+        self.id = eye_d
+        self.file_name = file_name
+        self.width = width
+        self.height = height
+        self.license = license
+        self.coco_url = coco_url
+        self.date_captured = date_captured
+
+    def to_dict(self) -> dict:
+        the_dict = self._to_dict_fields(
+            ['id', 'file_name', 'width', 'height', 'license', 'coco_url']
+        )
+        if self.date_captured:
+            the_dict['date_captured'] = self.date_captured.isoformat()
+        return the_dict
+
+class COCOInfo(COCOBase):
+    '''
+        see https://cocodataset.org/#format-data
+            
+            info {
+                "year": int,
+                "version": str,
+                "description": str,
+                "contributor": str,
+                "url": str,
+                "date_created": datetime,
+            }
+    '''
+    def __init__(self, year:int=None, version:str=None, description:str=None, contributor:str=None, url:str=None, date_created:datetime.datetime=None):
+        self.year = year
+        self.version = version
+        self.description = description
+        self.contributor = contributor
+        self.url = url
+        self.date_created = date_created
+
+    def to_dict(self) -> dict:
+        the_dict = self._to_dict_fields(
+            ['year', 'version', 'description', 'contributor', 'url']
+        )
+        if self.date_created:
+            the_dict['date_created'] = self.date_created.isoformat()
+        return the_dict
+
+
+
+class COCOCategories(object):
+    '''
+    helper class to hold the index on categories so that we can find categories by name or by index
+
+    Parameters
+    ----------
+    categories: list[COCOCategory]
+        existing list of COCOCategories if available
+
+    Attributes
+    ----------
+    categories: list[COCOCategory]
+        a list of unique categories
+    category_map: dict[str, COCOCategory]
+        maps category names to categories
+    '''
+    def __init__(self, categories: list[COCOCategory] | None = None):
+        categories = categories or []
+        # category ids MUST match their index in the category list!
+        self.categories = categories
+        for i, category in enumerate(self.categories):
+            assert category.id == i
+        self.category_map = {category.name: category.id for category in self.categories}
+
+    def add(self, label:str, keypoints:list[str]=None, skeleton:list[list[int]]=None) -> COCOCategory:
+        '''
+        Add a new category to the list.  Updates the map as well
+
+        Parameters
+        ----------
+        label: str
+            the string name of this category
+        keypoints: list[str]
+            the list of keypoint names for this category, if applicable
+        skeleton: list[list[int]]
+            the skeleton for this category, if applicable
+
+        Returns
+        -------
+        category: COCOCategory
+            returns the built COCOCategory
+        '''
+        if label not in self.category_map:
+            category = COCOCategory(label, len(self.categories), keypoints=keypoints, skeleton=skeleton)
+            self.categories.append(category)
+            self.category_map[self.categories[-1].name] = self.categories[-1].id
+        return self.category_map[label]
+
+    def __len__(self):
+        return len(self.categories)
+
+class COCOImages(object):
+    '''
+    helper class to hold the index on images so that we can find images by name or by index
+
+    Parameters
+    ----------
+    images: list[COCOImage]
+        existing list of COCOImages if available
+
+    Attributes
+    ----------
+    images: list[COCOImage]
+        a list of unique images
+    image_map: dict[str, COCOImage]
+        maps image names to images
+    '''
+    def __init__(self, images: list[COCOImage] | None = None):
+        images = images or []
+        # image ids MUST match their index in the image list!
+        self.images = images
+        for i, image in enumerate(self.images):
+            assert image.id == i
+        self.image_map = {image.filename: image.id for image in self.images}
+
+    def add(self, filename:str, width:int=None, height:int=None, 
+            url:str=None, license:int=None, date_captured:datetime.datetime=None):
+        '''
+        Add a new image to the list.  Updates the map as well
+
+        Parameters
+        ----------
+        filename: str
+            the filename of this image
+        width: int
+            the width of this image, if known
+        height: int
+            the height of this image, if known
+        url: str
+            the url at which this image can be downloaded
+        license: int
+            the index in the list of COCOLicense with the applicable license
+        date_captured: datetime.datetime
+            the date and time when the image was captured
+
+        Returns
+        -------
+        image: COCOImage
+            returns the built COCOImage
+        '''
+        if filename not in self.image_map:
+            image = COCOImage(len(self.images), filename, 
+                              width=width, height=height, coco_url=url, 
+                              license=license, date_captured=date_captured)
+            self.images.append(image)
+            self.image_map[self.images[-1].file_name] = self.images[-1].id
+        return self.image_map[filename]
+
+    def __len__(self):
+        return len(self.images)
+
+
+class COCOData(COCOBase):
+    '''
+        see https://cocodataset.org/#format-data
+        
+            coco {
+                "info": info,
+                "images": [image],
+                "annotations": [annotation],
+                "licenses": [license],
+                "categories": [category]
+            }
+    '''
+    
+    def __init__(self, info:COCOInfo, images:list[COCOImage], annotations:list[COCOAnnotation], licenses:list[COCOLicense], categories:list[COCOCategory]):
+        self.info = info
+        self.images = images
+        self.annotations = annotations
+        self.licenses = licenses
+        self.categories = categories
+
+    def to_dict(self) -> dict:
+        return {
+            'info': self.info.to_dict(),
+            'images': [image.to_dict() for image in self.images],
+            'annotations': [annotation.to_dict() for annotation in self.annotations],
+            'licenses': [license.to_dict() for license in self.licenses],
+            'categories': [category.to_dict() for category in self.categories]
+        }
+
+    def to_json(self, filename:str=None):
+        '''
+        dumps this COCO to json.  If a filename is provided, writes to disk, else, returns
+        the string JSON
+
+        Parameters
+        ----------
+        filename: str
+            the optional location to which we should write the json
+    
+        Returns
+        -------
+        json: str | None
+            if no filename is provided, returns the JSON COCO data as a string
+        '''
+        if filename is None:
+            return json.dumps(self.to_dict(), cls=utils.NPEncoder)
+        with open(filename, 'w') as f:
+            json.dump(self.to_dict(), f, cls=utils.NPEncoder)

pycocowriter/csv2coco.py

@@ -0,0 +1,359 @@
+import json
+import jsonschema
+from . import coco, utils
+import csv
+from collections.abc import Sequence, Iterable
+
+
+def parse_csv(config: dict, filename: str) -> tuple[
+    list[coco.COCOImage], list[coco.COCOAnnotation], list[coco.COCOCategory]]:
+    """Helper method to open a csv file and pass it row-by-row into the COCO builder
+
+    Parameters
+    ----------
+    config : dict
+        a dictionary conforming to the Iterable2COCOConfig.SCHEMA
+    filename : str
+        a csv file to be read and converted to COCO
+
+    Returns
+    -------
+    images : list[COCOImage]
+        a list of COCOImage reflecting the images from the csv file
+    annotations : list[COCOAnnotation]
+        a list of COCOAnnotation reflecting the annotations from the csv file
+    categories : list[COCOCategory]
+        a list of COCOCategory reflecting the categories of the annotations
+    """
+    csv2coco = Iterable2COCO(Iterable2COCOConfig(config))
+    with open(filename) as f:
+        reader = csv.reader(f)
+        images, annotations, categories = csv2coco.parse(reader)
+    return images, annotations, categories
+
+
+def bbox_tlbr2xywh(bbox: tuple[int, int, int, int]) -> tuple[int, int, int, int]:
+    '''
+    Convert a bounding box in "top left, bottom right" format 
+    to a bounding box in "top left, width height" format
+
+    Parameters
+    ----------
+    bbox: tuple[int,int,int,int]
+        a four-tuple of [top_left_x, top_left_y, bottom_right_x, bottom_right_y]
+
+    Returns
+    -------
+    bbox: tuple[int,int,int,int]    
+        a four-tuple of [top_left_x, top_left_y, width, height]
+    '''
+    return (bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1])
+
+
+class Iterable2COCOConfig(utils.AttrDict):
+    '''
+    This class validates a configuration to convert a "flat" iterable type into COCO.
+    Because COCO has complex nested and optional types, it is not possible to have a 
+    "one-size-fits-all" flat iterable to COCO conversion.  This configuration tells
+    the converter which fields are present, and in which columns they are located.
+    This class exists only to validate a dict as a valid configuration.
+
+    Parameters
+    ----------
+    config: dict
+        a configuration dictionary adhering to SCHEMA.  Set up this way to be read from .json
+
+    Attributes
+    ----------
+    SCHEMA: dict
+        a jsonschema representing a valid configuration
+    '''
+
+    # TODO: This is the 'anything' schema.  Update to reflect the actual rules
+    SCHEMA = {}
+
+    def __init__(self, config: dict):
+        self._validate_config(config)
+        super().__init__(config)
+
+    def _validate_config(self, config: dict):
+        jsonschema.validate(config, Iterable2COCOConfig.SCHEMA)
+
+
+class IterableBBoxParser(object):
+    '''
+    This class is to help parse bounding boxes from "row" data.  Sometimes these data
+    are in different formats, so this class is intended to assist in dealing with these nuances
+
+    Parameters
+    ----------
+    config: Iterable2COCOConfig
+        this configuration should define how (and if) bounding boxes are present in each row
+    '''
+
+    def __init__(self, config: Iterable2COCOConfig):
+        self.config = config
+        self._init_bbox_method()
+
+    def _init_bbox_tlbr(self):
+        '''
+        configures the `get_bbox` method to get bounding boxes in "top left, width/height" 
+        format, given bounding boxes in "top left, bottom right" format
+        '''
+        self.get_bbox = self._get_bbox_tlbr
+        self.bbox_cols = [
+            self.config.bbox_tlbr.tlx,
+            self.config.bbox_tlbr.tly,
+            self.config.bbox_tlbr.brx,
+            self.config.bbox_tlbr.bry,
+        ]
+
+    def _init_bbox_xywh(self):
+        '''
+        configures the `get_bbox` method to get bounding boxes in "top left, width/height" 
+        format, given bounding boxes in "top left, width/height" format
+        '''
+        self.get_bbox = self._get_bbox_xywh
+        self.bbox_cols = [
+            self.config.bbox_xywh.x,
+            self.config.bbox_xywh.y,
+            self.config.bbox_xywh.w,
+            self.config.bbox_xywh.h,
+        ]
+
+    def _init_bbox_method(self):
+        '''
+        dispatches configuration of the `get_bbox` method depending on the 
+        contents of the configuration file.
+        '''
+        if 'bbox_tlbr' in self.config:
+            self._init_bbox_tlbr()
+        elif 'bbox_xywh' in self.config:
+            self._init_bbox_xywh()
+
+    def get_bbox(self, row: Sequence) -> list[int, int, int, int] | None:
+        '''
+        this method gets overwritten in __init__ if the config has a bbox option
+
+        Parameters
+        ----------
+        row: Sequence
+            a row, e.g. from a csv.  The bounding box should be in some columns of this row
+            as defined in the configuration
+
+        Returns
+        -------
+        bbox: list[int,int,int,int]
+            the bounding box as [top_left_x, top_left_y, width, height]
+        '''
+        return None
+
+    def _get_bbox_tlbr(self, row: Sequence) -> list[int, int, int, int]:
+        '''
+        gets a bounding box in "top left, width/height" format given bounding box subsetted from a  
+        row from, e.g. a csv.  The subset of columns in the input row should be defined in the config, 
+        and should contain a bounding box in "top left, bottom right" format.
+
+        Parameters
+        ----------
+        row: Sequence
+            a row, e.g. from a csv.  The bounding box should be in some columns of this row
+            as defined in the configuration
+
+        Returns
+        -------
+        bbox: list[int,int,int,int]
+            the bounding box as [top_left_x, top_left_y, width, height]
+        '''
+        return bbox_tlbr2xywh([int(float(row[i])) for i in self.bbox_cols])
+
+    def _get_bbox_xywh(self, row: Sequence) -> list[int, int, int, int]:
+        '''
+        gets a bounding box in "top left, width/height" format given bounding box subsetted from a  
+        row from, e.g. a csv.  The subset of columns in the input row should be defined in the config, 
+        and should contain a bounding box in "top left, width/height" format.
+
+        Parameters
+        ----------
+        row: Sequence
+            a row, e.g. from a csv.  The bounding box should be in some columns of this row
+            as defined in the configuration
+
+        Returns
+        -------
+        bbox: list[int,int,int,int]
+            the bounding box as [top_left_x, top_left_y, width, height]
+        '''
+        return [int(float(row[i])) for i in self.bbox_cols]
+
+
+class IterableKeypointParser(object):
+    '''
+    This class is to help parse keypoints from "row" data.  Sometimes these data
+    are in different formats, so this class is intended to assist in dealing with these nuances
+
+    Parameters
+    ----------
+    config: Iterable2COCOConfig
+        this configuration should define how (and if) bounding boxes are present in each row
+    '''
+    FULLY_VISIBLE_COCO_KEYPOINT = 2
+
+    def __init__(self, config: Iterable2COCOConfig):
+        self.config = config
+
+    def keypoint_config(self) -> tuple[list[str], list[list[int]]]:
+        '''
+        get the keypoint layout from the configuration file.  the coco keypoint layout is
+        ['kpname1', 'kpname2', ...]
+        and also a skeleton
+        [edge1, edge2, ...]
+        where edges are two-tuples of 1-indexed indexes of keypoints.  For example, if keypoints are:
+        ['hip', 'knee', 'ankle'],
+        the skeleton would be:
+        [[1,2],[2,3]] because the hip has an edge with the knee, and the knee has an edge to the ankle.
+
+        both of these items should be defined in the configuration
+
+        TODO: we only support ONE keypoint structure per configuration right now....
+        if you have multiple possible keypoint structures
+        e.g. hands and also human poses, then we need to rework this to be more general
+
+        Returns
+        -------
+        keypoints: list[str]
+            the list of keypoint names
+        skeleton: list[list[int]]
+            the skeleton corresponding to the keypoint names
+        '''
+        return (
+            [
+                keypoint.name for keypoint in self.config.keypoints
+            ],
+            self.config.keypoint_skeleton
+        )
+
+    def get_keypoints(self, row: Sequence) -> list[int]:
+        '''
+        get keypoints from a "flat" row using expected indices in the row of keypoints 
+        defined in self.config
+
+        Parameters
+        ----------
+        row: Sequence
+            a row, e.g. from a csv.  The keypoints should be in some columns of this row
+            as defined in the configuration
+
+        Returns
+        -------
+        keypoints: list[int]
+            keypoint locations in form [x1,y1,v1,x2,y2,v2,....] where x,y are the location and v is the
+            "visibility" according to the COCO docs
+        '''
+        if 'keypoints' not in self.config:
+            return None
+        return sum(
+            [
+                [
+                    int(float(row[keypoint.x])),
+                    int(float(row[int(keypoint.y)])),
+                    IterableKeypointParser.FULLY_VISIBLE_COCO_KEYPOINT if 'visibility' not in keypoint else int(float(row[keypoint.visibility]))
+                ]
+                for keypoint in self.config.keypoints
+            ],
+            []
+        )
+
+
+class Iterable2COCO(object):
+    '''
+    class providing methods for parsing a "flat" iterable (e.g. a csv) of annotations into COCO
+    format.  Each "row" should contain things such as the image filename, 
+    and the annotation information (e.g a bounding box or keypoints and a category label)
+
+    Parameters
+    ----------
+    config: Iterable2COCOConfig
+        a configuration dictionary detailing which columns in each row correspond to various COCO
+        features such as filename and bounding box coordinates.
+
+    Attributes
+    ----------
+    bbox_parser: IterableBBoxParser
+        a helper for parsing bounding boxes and the concomitant configuration
+    keypoint_parser: IterableKeypointParser
+        a helper for parsing keypoints and the concomitant configuration
+    '''
+
+    def __init__(self, config: Iterable2COCOConfig):
+        self.config = config
+        self.bbox_parser = IterableBBoxParser(config)
+        self.keypoint_parser = IterableKeypointParser(config)
+
+    def _get_scalar(self, field: str, row: Sequence):
+        '''
+        get a single value from a row given the field name in the configuration
+
+        Parameters
+        ----------
+        field: str
+            the field name as expected in the configuration, and should point to a column index.
+            viz. self.config[field] should provide an index into row
+        row: Sequence
+            an indexable "row" e.g. from a csv file
+
+        Returns
+        -------
+        scalar: any
+           a single value expected for that field. 
+        '''
+        if field not in self.config:
+            return None
+        return row[self.config[field]]
+
+    def parse(self, row_iterable: Iterable[Sequence]) -> tuple[
+        list[coco.COCOImage], list[coco.COCOAnnotation], list[coco.COCOCategory]
+    ]:
+        '''
+        parse an iterable of rows (e.g. from a csv file) containing image annotation information into
+        COCO format.
+
+        Parameters
+        ----------
+        row_iterable: Iterable[Sequence]
+            an iterable of rows containing annotation information
+
+        Returns
+        -------
+        images: list[COCOImage]
+            a list of all unique images listed in the iterable, in COCO format
+        annotations: list[COCOAnnotation]
+            a list of all annotations listed in the iterable, correctly indexed
+            against the images and categories lists
+        categories: list[COCOCategory]
+            a list of all unique categories listed in the iterable, in COCO format        
+        '''
+        categories = coco.COCOCategories()
+        images = coco.COCOImages()
+        annotations = []
+        utils.skiprows(row_iterable, self.config.meta.skiprows)
+        keypoint_names, keypoint_skeleton = self.keypoint_parser.keypoint_config()
+        for row in row_iterable:
+            bbox = self.bbox_parser.get_bbox(row)
+            keypoints = self.keypoint_parser.get_keypoints(row)
+            filename = self._get_scalar('filename', row)
+            width = self._get_scalar('width', row)
+            height = self._get_scalar('height', row)
+            label = self._get_scalar('label', row)
+            images.add(filename, width, height)
+            categories.add(label, keypoint_names, keypoint_skeleton)
+            annotations.append(
+                coco.COCOAnnotation(
+                    images.image_map[filename],
+                    len(annotations),
+                    categories.category_map[label],
+                    bbox=bbox,
+                    keypoints=keypoints
+                )
+            )
+        return images.images, annotations, categories.categories

pycocowriter/utils.py

@@ -0,0 +1,89 @@
+from collections.abc import Iterable
+import json
+import numpy as np
+
+class AttrDict(dict):
+    '''
+    This class allows javascript-like attribute access for dictionaries.
+    Pass in a nested dictionary and recursively access members as attributes.
+
+    Examples
+    --------
+    >>> attr_dict = AttrDict({'foo': [{'bar': [1,2]}]})
+    >>> attr_dict.foo[0].bar[1] == 2
+    True
+    '''
+    def __init__(self, some_dict:dict):
+        super().__init__(some_dict)
+        self.__dict__ = {
+            k: _to_attrdict(v) for k,v in some_dict.items()
+        }
+
+def _to_attrdict(el) -> AttrDict:
+    '''
+    This method facilitates recursive application of AttrDict.
+    Probably you don't want to call this method on its own -
+    instead, instantiate an `AttrDict`
+
+    Parameters
+    ----------
+    el: any
+        element to recursively convert to AttrDict.
+    
+    Returns
+    -------
+    any
+        the element, possibly converted to an AttrDict depending on type 
+    '''
+    # cast dictionaries at AttrDict
+    if isinstance(el, dict):
+        return AttrDict(el)
+    # return strings
+    if isinstance(el, str):
+        return el
+    # try to recurse into other iterable types
+    if isinstance(el, Iterable):
+        return type(el)((
+            _to_attrdict(v) for v in el
+        ))
+    # return simple types unchanged
+    return el
+
+class NPEncoder(json.JSONEncoder):
+    '''
+    json encoder class used to convert numpy types into plain python types during json.dumps.
+    
+    Examples
+    --------
+    >>> json.dumps({'array': np.array([1,2,3])}, cls=NPEncoder)
+    '{"array": [1, 2, 3]}'
+
+    '''
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super(NPEncoder, self).default(obj)
+    
+def skiprows(iterable: Iterable, n: int) -> Iterable:
+    '''
+    skips the first n rows of iterable.  returns iterable as a convenience
+
+    Parameters
+    ----------
+    iterable: Iterable
+        the iterable to skip rows of
+    n: int
+        the number of rows to skip
+
+    Returns
+    -------
+    iterable: Iterable
+        the original iterable, but now with n rows having been skipped
+    '''
+    for i in range(n):
+        next(iterable)
+    return iterable

pycocowriter-0.0.1.dist-info/LICENSE

@@ -0,0 +1,132 @@
+FOR ALL WORK SUBMITTED BY FEDERAL EMPLOYEES:
+
+Software code created by U.S. Government employees is not subject to copyright in the United States
+(17 U.S.C. §105). The United States/Department of Commerce reserve all rights to seek and obtain
+copyright protection in countries other than the United States for Software authored in its entirety by the
+Department of Commerce. To this end, the Department of Commerce hereby grants to Recipient a
+royalty-free, nonexclusive license to use, copy, and create derivative works of the Software outside of the
+United States.
+
+FOR ALL WORK SUBMITTED BY NON-FEDERAL EMPLOYEES:
+
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

pycocowriter-0.0.1.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.3
+Name: pycocowriter
+Version: 0.0.1
+Summary: tools for writing coco files
+Author: scott brown
+Description-Content-Type: text/markdown
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: numpy
+Requires-Dist: jsonschema
+
+# pycocowriter
+
+This library contains tools to assist in writing COCO-format annotation files.  Contains [typing and constructors](nodd-tools.github.io/pycocotools/api/coco) to assist in building a COCO-format file from scratch and then [dump it to json]()
+
+
+# Disclaimer
+
+This repository is a scientific product and is not official communication of the National Oceanic and
+Atmospheric Administration, or the United States Department of Commerce. All NOAA GitHub project
+code is provided on an ‘as is’ basis and the user assumes responsibility for its use. Any claims against the
+Department of Commerce or Department of Commerce bureaus stemming from the use of this GitHub
+project will be governed by all applicable Federal law. Any reference to specific commercial products,
+processes, or services by service mark, trademark, manufacturer, or otherwise, does not constitute or
+imply their endorsement, recommendation or favoring by the Department of Commerce. The Department
+of Commerce seal and logo, or the seal and logo of a DOC bureau, shall not be used in any manner to
+imply endorsement of any commercial product or activity by DOC or the United States Government.
+

pycocowriter-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+pycocowriter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycocowriter/coco.py,sha256=kjNVZmFRqO07rjhF4Vzk0JCUkippoAnf1eBb4ClMRgY,11529
+pycocowriter/csv2coco.py,sha256=UntYVmIfNNfIqE1ml17qNlhCtbjuvb7YvEZG1iaqgyw,13010
+pycocowriter/utils.py,sha256=e94E2gAE2IIjBePkIL7hlrNsz6HhwCY8PnyeweVhAio,2376
+pycocowriter-0.0.1.dist-info/LICENSE,sha256=WqdJz_L8LA3dvoxyqR-a2tVUBsuAIa5C8Kf1HBQB9QA,7667
+pycocowriter-0.0.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+pycocowriter-0.0.1.dist-info/METADATA,sha256=pOey7DhAJ1-yJ9scxgs1JZA-gt5EEzO8072-G-ERiwE,1429
+pycocowriter-0.0.1.dist-info/RECORD,,

pycocowriter-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any