Saravanan666/pypi-org huggingface dataset:
Package: parasut-python
parasut-pythonParasut Python API Wrapper (Unoffical)WarningThis project is not offical library. It's unoffical python wrapper
This project is under heavy development. Please be aware before use
Query parameters not included for functionsInstallpip install parasut-pythonUsingimport os
from parasut.client import Client

CLIENT_ID = os.environ['PARASUT_CLIENT_ID']
CLIENT_SECRET = os.environ['PARASUT_CLIENT_SECRET']
USERNAME = os.environ['PARASUT_USERNAME']
PASSWORD = os.environ['PARASUT_PASSWORD']

# Remove sandbox=True when production.
# It's activating sandbox urls for testing
# Sandbox link: api.heroku-staging.parasut.com
client_obj = Client(client_id=CLIENT_ID,
                    client_secret=CLIENT_SECRET,
                    username=USERNAME,
                    password=PASSWORD,
                    sandbox=True)

# It's required
client_obj.initialize()

# You can get request parameters from
# https://apidocs.parasut.com/#operation/createContact
# All required request data examples can be found at
# https://apidocs.parasut.com
data = {
    "data": {
      "type": "contacts",
      "attributes": {
        "email": "user@example.com",
        "name": "string",
        "short_name": "string",
        "contact_type": "person",
        "tax_office": "string",
        "tax_number": "string",
        "district": "string",
        "city": "string",
        "address": "string",
        "phone": "string",
        "fax": "string",
        "is_abroad": True,
        "archived": True,
        "iban": "string",
        "account_type": "customer"
      },
      "relationships": {
        "category": {
          "data": {
            "type": "item_categories"
          }
        },
        "contact_people": {
          "data": [
            {
              "type": "contact_people",
              "attributes": {
                "name": "string",
                "email": "user@example.com",
                "phone": "string",
                "notes": "string"
              }
            }
          ]
        }
      }
    }
  }

obj = client_obj.functions.createContact(data)
print(obj.json())PackageBasic structure of package is├── .gitignore
├── .travis.yml
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── parasut
│   ├── __init__.py
│   ├── client.py
│   ├── functions.py
│   ├── urls.py
│   └── version.py
├── pytest.ini
├── requirements.txt
├── script
│   └── test
├── setup.py
└── tests
    ├── __init__.py
    ├── helpers
    │   ├── __init__.py
    │   └── my_helper.py
    ├── tests_helper.py
    └── unit
        ├── __init__.py
        ├── test_example.py
        └── test_version.pyRequirementsPackage requirements are handled using pip. To install them dopip install -r requirements.txtTestsTesting is set up usingpytestand coverage is handled
with the pytest-cov plugin.Run your tests withpy.testin the root directory.Coverage is ran by default and is set in thepytest.inifile.
To see an html output of coverage openhtmlcov/index.htmlafter running the tests.Travis CIThere is a.travis.ymlfile that is set up to run your tests for python 2.7
and python 3.2, should you choose to use it.LicenseMIT, Copyright (c) 2020 Burak Karahan
Package: parasweep
parasweepparasweep is a free and open-source Python utility for facilitating parallel
parameter sweeps with computational models. Instead of requiring parameters to
be passed by command-line, which can be error-prone and time-consuming,
parasweep leverages the model’s existing configuration files using a template
system, requiring minimal code changes. After the sweep values are specified,
a parallel job is dispatched for each parameter set, with support for common
high-performance computing job schedulers. Post-processing is facilitated by
providing a mapping between the parameter sets and the simulations.The following paper gives a description as well as a simple example to get started: https://arxiv.org/pdf/1905.03448.pdf. Please cite it if you find parasweep useful for your project!Free software: MIT licenseDocumentation:http://www.parasweep.ioCode:https://github.com/eviatarbach/parasweepDependenciesPython 3.6+xarraynumpyscipyMako (optional)drmaa-python (optional)CreditsDeveloped byEviatar Bach<eviatarbach@protonmail.com>. Special thanks to Daniel Philipps (danielphili) for a bug fix and feature suggestion.This package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History2021.01 (2021-01-06)Changing wait option to be True by defaultMinor fixes to Lorenz example2020.10 (2020-10-27)Adding option to exclude simulation IDsAllowing empty sweep ID2020.09 (2020-09-02)Incorporating sweep_id into SequentialNamer (thanks to danielphili)2020.02 (2020-02-17)Fixing bug with default sweep_id on Windows (thanks to danielphili)Unicode support for PythonFormatTemplate2019.02.3 (2019-02-20)Adding SetNamer naming2019.02.2 (2019-02-18)Adding process limit for subprocess dispatchingAdding RandomSweep sweep typeAdding HashNamer namingClarifying version dependenciesMore examples2019.02 (2019-02-07)Separating sweep logic into a separate moduleAdding FilteredCartesianSweep sweep typeNumerous documentation changes, including many more examples2019.01 (2019-01-21)First release on PyPI
Package: paratest
TestsDownloadsAboutStatusParallelizes test executions.It allows to parallelize the integration/acceptance tests execution in different environments. This way they will took much less time to finish.And it is based on plugins in order to support different languages or platforms.ParaTest can be run under any Continuous Integration Server, likeJenkins,TeamCity,Go-CD,Bamboo, etc.Why Paratest?Almost all test runners allow you to paralellize the test execution, so… why Paratest?Well… In some cases test execution cannot be parallelized because of depenencies: database access, legacy code, file creation, etc. Then, you need to create a full workspace whenever you want to test them.This may be a hard task, and sadly Paratest cannot help there.But with some scripts to clone an existent workspace, Paratest can divide the tests between any number of workspaces, creating them on demand, and running the tests on them. Resources put the limits.Another advantage of Paratest is the test order: Paratest remembers the time spent in each test and will reorder them to get the most of your infrastructure.And finally, Paratest can retry failed tests, in order to avoid unstable tests.UsageFirst of all, you need two things:a source. This means to have a source with instructions to create a workspacesome scripts to setup/teardown the workspaces. This should translate the source into a workspace.Then, Paratest will call the setup scripts in order to create the workspaces and will parallelize the test run between them.Current pluginsParaTest is in an early development stage and it still have no plugins to work. It is just a proof of concept.ContributePluginsWritting a plugin is quite easy. You can see theparatest-dummyas example. Just two steps are required:Write the plugin methodsCurrently, just one method is required:def find(path, test_pattern, file_pattern, output_path)It should return a dict or a generator for tuples.Register the entrypointThe second step is to create apippackage with the entrypointfindwithin the groupparatest. This should be done in thesetup.pyfile. Example:from setuptools import setup, find_packages

setup(
  name='whatever',
  version='0.0.1',
  entry_points={
    'paratest': 'find = whatever:find'
  }
)
Package: paratureapiclient
ParatureApiClient======================================ParatureApiClient is a python wrapper for working with the Parature RESTful API.The package exposes a class for the following API resources:* Ticket* CSR* Customer* Account## InstallationInstall via pip:`pip install paratureapiclient`Save to project requirements file:`pip freeze > requirements.txt`## Usage```from paratureapiclient import ParatureApiClientclient = ParatureApiClient(PARATURE_URL, PARATURE_TOKEN)# Get ticket datatickets = client.tickets.get_data()```## Licenseparatureapiclient is released under the MIT License.
Package: paraturegmailfeed
# Parature Gmail Feed## DescriptionThe Parature Gmail Feed:* Retrieves emails cc'd to a Gmail account originating from Parature* Extracts Parature specific content from each email* Creates a record from the extracted content* Loads the record to a MongoDB database## InstallationInstall with pip```pip install paraturegmailfeed```**Project requires MongoDB**[See MongoDB documentation for installation instructions](https://docs.mongodb.org/manual/installation/)## Getting Started### Setting up your config fileCreate a new .py file. For example `my_config.py````# Gmail API VariablesCLIENT_SECRET_FILE = 'Exported from your Google application account'SCOPES = 'Scopes for your Google application'APPLICATION_NAME = 'Name of your application'USER_ID = 'YOUR EMAIL ACCOUNT USER ID'TARGET_LABEL_QUERY = 'The label name '# MongoDB VariablesMONGO_URI = 'YOUR DB URI'DB_NAME = 'YOUR DB NAME'```### Example of usage:```from paraturegmailfeed import ParatureGmailFeeddef main():feed = ParatureGmailFeed('my_config.py')feed.run()main()```### Running for the first timeBe sure to have `mongod` running.You will be prompted to authorize the application to access your Gmail account.After accepting, the application will run automatically.[See official documentation for assistance](https://developers.google.com/gmail/api/quickstart/python)## Design Decisions### Why MongoDB?* Flexible schema. As requirement grow/change the data schema can to!* Native functionality. Simple upserts (unlike most SQL databses).### How are duplicate records prevented?* Gmail API message query is restricted to all messages that do NOT have the "Processed" label.* The pymongo `update_one` method is used with the `upsert` option. This means that if a record already exists based on the composite key (ticket number and timestamp) the action will simply update the record (essentially do nothing).
Package: parawrap
Theparawrapmodule is an extended version of the built-intextwrapmodule. Like the standard module, it provides two
convenience functions,wrap()andfill(). It also providesParagraphWrapper, which is the class that does all the work.
In addition, there is asplit()function that splits up
paragraphs.parawrap.wrap(text[,width[, …]])Wrapstext(a string) so every line is at mostwidthcharacters long. Respects paragraph breaks, which are lines
separated by multiple newlines. Returns a list of output lines,
without final newlines.Optional keyword arguments correspond to the instance attributes
ofParagraphWrapper, which mirrorstextwrap.TextWrapper.widthdefaults to 70.parawrap.fill(text[,width[, …]])Wrapstextand returns a single string containing the wrapped
paragraphs.fill()is shorthand for:"\n".join(wrap(text, ...))In particular,fill()accepts exactly the same keyword
arguments aswrap().parawrap.split(text)Splits text into multiple paragraphs, returning a list of paragraphs.InstallationTo install fromPyPi:$ pip install parawrapYou can get a copy of the source by using:$ git clone https://github.com/ecometrica/parawrap.gitNote that this program requires Python 2.6 or higher.Reporting bugs and submitting patchesPlease check ourissue trackerfor known bugs and feature requests.We accept pull requests for fixes and new features.CreditsSimon Law wrote this program, with the generous support ofEcometrica.
Package: parble
Parble Python SDKThis repo contains the source code of the official python SDK forParbleintelligent document processing API.To access the API you will need a Parble account. Sign up for free atsignup.DocumentationOur documentation is continuously updated, you can find it here:parblelabs.github.io/parble-python.Development of the librarySetup local environmentpip install hatchpip install .hatch run +py='3.10' test:covDocumentation generationRun:hatch run docs:build-html
Package: parc-checker-api
# Parc Checker API## Name
parc-checker-api## Version
1.5## History
- 1.5 Added status to check response JSON
- 1.4 Use newer parc-checker-core version (1.2)
- 1.3 Use newer parc-checker-core version (1.1)
- 1.2 Added CORS
- 1.1 Ready to run in container
- 1.0 Initial release## Purpose
The purpose of this library is to provide API for Parc Checker## InstallationUse the package manager [pip](https://pip.pypa.io/en/stable/) to install parc-checker-api`bash pip installparc-checker-api`## License
This package is private and not allowed to be used## Author
Dovydas Jančauskas
Package: parc-checker-core
# Parc Checker Core## Name
parc-checker-core## Version
1.2## History
- 1.2 Added CommercialFX agreement document type preview, renamed checkers, added new checkers for property array values
- 1.1 Fixed subpackages missing issue
- 1.0 Initial release## InstallationUse the package manager [pip](https://pip.pypa.io/en/stable/) to install parc-checker-core`bash pip installparc-checker-core`## License
This package is private and not allowed to be used
Package: parce
import parceHomepage•Development•Download•Documentation•LicenseThis Python package,parce, can be used to lex text into a tree structure
using a language definition. The tree structure can subsequently be queried and
transformed in various powerful ways.Theparcemodule is designed to be very fast, while being written in pure
Python, using native data structures as much as possible. Lexing and
transforming can be done in a background thread.A key feature of parce is that you can re-lex and re-transform only modified
parts of a text if you already have lexed it. This makes parce suitable for
text editors etc. that need to keep a tokenized structure of the text
up-to-date e.g. to support syntax highlighting as you type.The module is written and maintained by Wilbert Berendsen. Python 3.5 and
higher is supported. Besides Python itself there are no other dependencies.
Testing is done by runningpytest-3in the root directory.The logo is a public domain tree image with the name in the Gentium italic font.
Why the name? It’s short, sounds like ‘parse’, and has the meaning of
“friend”, “buddy”, “bro.” :-)
Package: parcel
Parcel: Pragmatic Python Webapp DeploymentParcel is a suite of classes and helper functions designed to be used in
conjunction with Fabric for building and deploying Python web
applications using native packages.Feature SupportParcel is under heavy development and initially supports:Debian targetsuWSGI deploymentParcel is written and maintained by Crispin Wellington and Andrew Macgregor:Development LeadCrispin Wellington <retrogradeorbit@gmail.com>Core DevelopersCrispin Wellington <retrogradeorbit@gmail.com>Andrew Macgregor <amacgregor@gmail.com>For further information see the Parcel BitBucket project page:https://bitbucket.org/andrewmacgregor/parcelFor documentation see:http://parcel.readthedocs.org/
Package: parcelbright
ParcelBright API wrapper. For full ParcelBright API reference go tohttps://github.com/parcelbright/api-docsFree software: BSD licenseDocumentation:https://parcelbright-python.readthedocs.org.Featurescreate new shipment to get rates fromfind previously created shipmentbook shipmentget tracking datacancel shipmentTODOCustoms supportCarriers liability supportHistory0.3.3 (2015-10-20)Remove assertions from API facade0.3.2 (2015-08-14)Added shipment.track to schema0.3.1 (2015-08-07)Added missingschematicsrequirements atsetup.py0.3.0 (2015-08-07)API CHANGED - Entities constructor takesdictinstead ofkwargsAPI CHANGED -Shipment.createbecames instance method instead of class methodAdded entities validation usingschematicspackage0.2.3 (2015-07-29)Support forpickup_dateparameter atShipment.book()methodAdded__repr__method toParcel,AddressandShipmententities0.2.2 (2015-07-29)RaiseTrackingErrorfromShipment.track()if shipment has not tracking
information available0.2.1 (2015-07-29)RemoveShipment.is_booked()method. UseShipment.stateinstead.RaiseShipmentNotCompletedExceptionfromShipment.track()method0.2.0 (2015-07-28)Added support to track and cancel shipments0.1.0 (2015-07-27)First release on PyPI.
Package: parcel-data-collector
Florida County Property Data Retrieval and ProcessingThis repository contains Python code for retrieving and processing property data for specific counties in Florida, using their Parcel ID number. The code is organized into a module that defines an abstract base class for county property data, concrete subclasses for specific counties, and helper functions for data processing.OverviewThe goal of this project is to create a Python-based tool that can retrieve and process property data for specific counties in Florida. The tool is designed to have a standardized way of downloading dataframes for each county that is specified with a county name, and URL. Once the dataframes are downloaded, they are unzipped (if applicable) and converted to gzip format. This ensures that the data is in a standardized format, which makes it easier to process and analyze.The tool can be used by individuals or organizations that need to retrieve property data for specific counties in Florida. This could include real estate agents, property investors, and local government officials. The tool is flexible and can be easily customized to meet the specific needs of each user.UsageTo use the tool, follow these steps:Clone the repository and navigate to the root directory in your terminal or command prompt.Open the Python interpreter or create a Python script in your preferred IDE or text editor.Import theParcelDataCollectionclass from the module:fromcounty_property_dataimportParcelDataCollectionCreate an instance of theParcelDataCollectionclass and pass in the Parcel ID number as a string:parcel_id="123456789"county_data=ParcelDataCollection(parcel_id)The ParcelDataCollection class will search through each county dataframe class in the module and return an instance of the county's dataframe class, if available. At the moment, there are two concrete dataframe classes available: Sarasota, and Manatee counties. The dataframe class will instantiate, and an instance variable dictionary parcel_data will be created. This variable contains much of the parcel's information.You can access the parcel data by calling the instance variableparcel_data. For example, to print the parcel's property address:print(county_data.parcel_data['address'])This will output the Property Address associated with the Parcel ID number you provided.That's it! With these simple steps, you can easily retrieve property data for specific counties in Florida using the Parcel ID number. For more advanced usage, please see the documentation.ContributingIf you are interested in contributing to the project, please see the CONTRIBUTING.md file for more information.LicenseThis project is licensed under the MIT License. See the LICENSE.md file for more information.ContactIf you have any questions or concerns, please contact me at [philipdiegel@gmail.com].
Package: parcelfile
parcelfileWelcome to the official Parcelfile python package. Parcelfile was made to "Properly Package Python Programs".PARCELstands for:PythonAranger withRenduringComplexElementLeafsParcelfileis good forconcatinating fileszipping filesseperating file contentsand much more!functions:These are the functions that are available inparcelfilewrapdefwrap(type:None,spacing=true,*args)->strwraptakes arguments and concatinates them.boxdefbox(file,intstartline,intendline)->anyboxtakes file contents and seperates them from the main file, while creating a new file.examples are available in theexamplesdirectoryDISCLAIMERS:Parcelfileis still under construction, so some functions may not work yet, and more are to come.Creation rights go to@malachi196. You can find me on github, discord, and replit.
Package: parcell
parcellhelps you to keep your work on your machine even when it
needs to be executed remotely. This is done by sending your project’s
code to one of your beefy worker servers, running the code, and sending
the results back. Multiple tasks can be run in parallel and on different
servers to balance the load. You can keep improving your code on your
machine without lag and get notified when submitted tasks have been
completed. No setup on the server side is required.Getting startedInstall the project via:pipinstallparcellChoose a working directory for your projects andcdinto it.Now runparcelladdPROJECTNAMEwherePROJECTNAMEis the name of the project you want to create.
Follow all instructions until the script creates your project.
If the command cannot be found try restarting the terminal or usepython -m parcell …instead.Then runparcellstartto start the web interface. Note that you can avoid retyping your passwords
for different servers using the--reuse-pwcommand line argument in
either command (given all the servers accept the same password).
Once the web interface is started you can interact with your project.
When finished you can stopparcellby typingquitin the
terminal or pressingCTRL-C. Typingrestartrestarts the web interface.Useparcell-horparcellCOMMAND-hto get further information about the command line capabilities.UninstallingSinceparcelladds local and remote files please runparcelldeletebefore uninstalling viapip. This makes sure that all local
and remote files are removed and all running tasks are stopped.
The command can also be used to remove specific
servers. Note that in order to be able to clean files on the server side
it must be possible to connect to the server at the time of removal.ContributingPull requests are highly appreciated :) Also, feel free to openissuesfor any
questions or bugs you may encounter.If you want to work on the code ofparcell. Set the project up as follows:gitclonehttps://github.com/JosuaKrause/parcell.gitcdparcellgitsubmoduleupdate--init--recursivepipinstall-e.This way you need to callparcellvia:python-mparcell...
Package: parcels
ParcelsParcels(ProbablyAReallyComputationallyEfficientLagrangianSimulator) is a set of Python classes and methods to create customisable particle tracking simulations using output from Ocean Circulation models. Parcels can be used to track passive and active particulates such as water, plankton,plasticandfish.Animation of virtual particles carried by ocean surface flow in the global oceans. The particles are advected withParcelsin data from theNEMO Ocean Model.Parcels manuscript and codeThe manuscript detailing the first release of Parcels, version 0.9, has been published inGeoscientific Model Developmentand can be cited asLange, M and E van Sebille (2017) Parcels v0.9: prototyping a Lagrangian Ocean Analysis framework for the petascale age. Geoscientific Model Development, 10, 4175-4186.https://doi.org/10.5194/gmd-2017-167The manuscript detailing version 2.0 of Parcels is available atGeoscientific Model Developmentand can be cited as:Delandmeter, P and E van Sebille (2019) The Parcels v2.0 Lagrangian framework: new field interpolation schemes. Geoscientific Model Development, 12, 3571-3584.https://doi.org/10.5194/gmd-12-3571-2019The manuscript detailing the performance of Parcels v2.4 is available atComputers & Geosciencesand can be cited as:Kehl, C, PD Nooteboom, MLA Kaandorp and E van Sebille (2023) Efficiently simulating Lagrangian particles in large-scale ocean flows — Data structures and their impact on geophysical applications, Computers and Geosciences, 175, 105322.https://doi.org/10.1016/j.cageo.2023.105322Further informationSeeoceanparcels.orgfor further information aboutinstallingandrunningthe Parcels code, as well as extendeddocumentationof the methods and classes.Launch Parcels Tutorials onmybinder.org
Package: parceqt
Small Python library to use parce with Qt’s QTextDocument.This module depends on parce (https://parce.info/) and PyQt(https://riverbankcomputing.com/software/pyqt)Homepage:https://github.com/wbsoft/parceqtDownload:https://pypi.org/project/parceqtDocumentation:https://parce.info/parceqtExample:fromPyQt5.QtWidgetsimportQApplication,QTextEditfromPyQt5.QtGuiimportQTextDocumentapp=QApplication([])doc=QTextDocument()e=QTextEdit()e.setDocument(doc)e.resize(600,400)e.show()importparceqtfromparce.lang.xmlimportXmlparceqt.set_root_lexicon(doc,Xml.root)parceqt.highlight(doc)parceqt.adjust_widget(e)# adjust widgets font and base colorsNow the text in the document is automatically highlighted using the specified
root lexicon; the highlighting is updated as the user modifies the text.