Metadata-Version: 1.1
Name: salesforce-bulk-yplan
Version: 1.2.0
Summary: Python interface to the Salesforce.com Bulk API.
Home-page: https://github.com/YPlan/salesforce-bulk
Author: YPlan
Author-email: julius@yplanapp.com
License: Copyright (c) 2013 Scott Persinger

MIT License

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Description: Salesforce Bulk
        ===============
        
        Python client library for accessing the asynchronous Salesforce.com Bulk
        API.
        
        
        Installation
        ------------
        
        .. code-block:: python
        
            pip install salesforce-bulk-yplan
        
        
        Authentication
        --------------
        
        To access the Bulk API you need to authenticate a user into Salesforce.
        The easiest way to do this is just to supply ``username`` and
        ``password``. This library will use the ``salesforce-oauth-request``
        package (which you must install) to run the Salesforce OAUTH2 Web flow
        and return an access token.
        
        .. code-block:: python
        
            from salesforce_bulk import SalesforceBulk
            bulk = SalesforceBulk(username=username,password=password)
        
        Alternatively if you run have access to a session ID and instance\_url
        you can use those directly:
        
        .. code-block:: python
        
            from urlparse import urlparse
            from salesforce_bulk import SalesforceBulk
            bulk = SalesforceBulk(sessionId=sessionId, host=urlparse(instance_url).hostname)
        
        
        Operations
        ----------
        
        The basic sequence for driving the Bulk API is:
        
        1. Create a new job
        2. Add one or more batches to the job
        3. Wait for each batch to finish
        4. Close the job
        
        
        Bulk Query
        ----------
        
        .. code-block:: python
        
           SalesforceBulk.create_query_job(object_name, contentType='CSV', concurrency=None)
        
        Example
        
        .. code-block:: python
        
            job = bulk.create_query_job("Contact", contentType='CSV')
            batch = bulk.query(job, "select Id,LastName from Contact")
            while not bulk.is_batch_done(job, batch):
                sleep(10)
            bulk.close_job(job)
            >>>
            for row in bulk.get_batch_result_iter(job, batch, parse_csv=True):
            ...    print row   #row is a dict
        
        
        Bulk Insert, Update, Delete
        ---------------------------
        
        All Bulk upload operations work the same. You set the operation when you
        create the job. Then you submit one or more documents that specify
        records with columns to insert/update/delete. When deleting you should
        only submit the Id for each record.
        
        For efficiency you should use the ``post_bulk_batch`` method to post
        each batch of data. (Note that a batch can have a maximum 10,000 records
        and be 1GB in size.) You pass a generator or iterator into this function
        and it will stream data via POST to Salesforce. For help sending CSV
        formatted data you can use the salesforce\_bulk.CsvDictsAdapter class.
        It takes an iterator returning dictionaries and returns an iterator
        which produces CSV data.
        
        Full example:
        
        .. code-block:: python
        
            from salesforce_bulk import CsvDictsAdapter
            job = bulk.create_insert_job("Account", contentType='CSV')
            accounts = [dict(Name="Account%d" % idx) for idx in xrange(5)]
            csv_iter = CsvDictsAdapter(iter(accounts))
            batch = bulk.post_bulk_batch(job, csv_iter)
            bulk.wait_for_batch(job, batch)
            bulk.close_job(job)
            print "Done. Accounts uploaded."
        
        
        Concurrency mode
        ~~~~~~~~~~~~~~~~
        
        When creating the job, pass ``concurrency=Serial`` or
        ``concurrency=Parallel`` to set the concurrency mode for the job.
        
        
        
        
        History
        -------
        
        1.2.0 (2016-07-14)
        ------------------
        
        * Brought back ``HISTORY.rst``.
        * Python2 and Python3 compatibility.
        * Forked ``salesforce-bulk-yplan`` package.
        * Depends on ``salesforce-oauth-request-yplan`` from now on.
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
