Saravanan666/pypi-org huggingface dataset:
Package: airsspy
airsspyA package to help working with the Ab initio Random Structure Searching (AIRSS)
using Atomic simulation environment (ase).
Supports building a search seed for AIRSS in a interactive python environments.
One of the important steps for performing a successful search with AIRSS is to have sensible seed for generating
random structures, which are subsequently relaxed using the method of choice.
In general, AIRSS only relies on a few simple parameters to generate random structure, such as numbers of atoms,
numbers of species and cell volume.
However, for complicated search involving surfaces and/or interfaces, hand-building seed files becomes a
tedious or impossible job to do.
ASE has a suite of tools for manipulate atomic structure which can be very helpful for building structures,
and here, for building search seeds.AIRSS is a open source code licensed under GPLv2,
this package does not contain any source code of AIRSS nor links to it.What this doesAllow preparing seed for AIRSS using ASE'satomsinterfaceAllow ase's calculators to be used in AIRSS to do relaxationsTry interactivelyInteractive jupyter notebook examples can be found in theexamplesfolder.
Click thebinderbadge above to launch these examples in a pre-built environment and try it in your browser!Dependencesase: The atomic simulation environmentcastepinput: A light weight writer/reader for the input files ofCASTEP.InstallationThe package can be installed from pypi together with the dependencies:pip install airsspyAlternative, one can also install directly from the repository (defaults to the master branch):pip install git+https://github.com/zhubonan/airsspyUsageAssuming you are familiar withase, python and has some basic knowledge of AIRSS.
To prepare a seed for generating asensiblerandom structure:fromairsspyimportSeedAtomsseed=SeedAtoms('C6')seed.buiid.varvol=20seed.build.symmops=(2,4)# Can also access per `atom` tags/ketwords just like in ASEforiinrange(0,6,2):atom=seed[i]atom.tagname='CX'atom.posamp=2To write the seed file onto the disk:atoms.write_seed('C6.cell')# With IPython# Use the buildcell executable to generate the file!buildcell<C6.cell>C6-rand.cellTo generate a cell we can create aBuildcellinstance,
which is helping wrapper to thebuildcellprogram of AIRSS:fromairsspyimportBuildcellbuidcell=Buildcell(seed)random_atoms=builcell.generate()A shortcut is also available as an method of theSeedAtoms:random_atoms=seed.build_random_atoms()LimitationsDue to the lack oftimeoutargument ofPopen.communicatein python 2.7,
communication with thebuildcellis not available. Hence, direct generation and
retrieval of the random structure are not supported in python. However, it is
still possible to write the seed out and call the program externally.
Package: airstack
airstack-python-sdkThe Airstack Python SDK is a library that allows Python developers to integrate Airstack's blockchain functionalities into their applications. With this SDK, developers can perform various tasks, such as querying and fetching data from smart contracts, displaying NFT assets.Installationpip3 install airstackGetting startedTo use the SDK you will need airstack api-key, which you can find in your profile setting section in airstack web, once you have it you can initialise the Airstackclient with the api-key.fromairstack.execute_queryimportAirstackClientapi_client=AirstackClient(api_key='api-key')Methodsexecute_queryThe execute query method query the data and return the data in asynchronous, it returns query_response which has below dataquery_response.data: data returned by the queryquery_response.status_code: status code of the query responsequery_response.error: any error that occurred while loading the queryExamplefromairstack.execute_queryimportAirstackClientapi_client=AirstackClient(api_key='api-key')execute_query_client=api_client.create_execute_query_object(query=query,variables=variables)query_response=awaitexecute_query_client.execute_query()execute_paginated_queryNote:pagination methods only works with queries that has support for pagination, and the query passed to method must have a cursor as argument for it to work.Theexecute_paginated_querymethod provides a simple way to paginate the data returned by a query. It works the same as theexecute_querymethod, it returns query_response which has below data:query_response.data: data returned by the queryquery_response.status_code: status code of the query responsequery_response.error: any error that occurred while loading the queryquery_response.has_next_page: a boolean indicating whether there is another page of data after the current pagequery_response.has_prev_page: a boolean indicating whether there is another page of data before the current pagequery_response.get_next_page: a function that can be called to fetch the next page of dataquery_response.get_prev_page: a function that can be called to fetch the previous page of dataExamplefromairstack.execute_queryimportAirstackClientapi_client=AirstackClient(api_key='api-key')execute_query_client=api_client.create_execute_query_object(query=query,variables=variables)query_response=awaitexecute_query_client.execute_paginated_query()ifquery_response.has_next_page:next_page_response=awaitquery_response.get_next_pageifnext_page_response.has_prev_page:prev_page_response=awaitquery_response.get_prev_page
Package: airstorm
airstormAirstorm is a dynamic Python ORM forAirtable. It allows you to easily interact with any base using Python with minimal setup.Main FeaturesObject-oriented interface.Dynamic generation of data models from schema.Automatic foreign-key resolution.Caching layer to avoid abusing the Airtable API.InstallationpipinstallairstormUsagefromairstorm.baseimportBasejamba_juice=Base('your_base_id','your_api_key',{'your':'schema'})smoothy=jamba_juice.Smoothie('some_smoothie_id')# Get your table record.forfruitinsmoothy.fruits:# Get linked record in a breeze.print(fruit.name)# Access any field data.print(smoothy.fruits.names)# Access to mutliple record field data at once.Getting the SchemaUnfortunatly currently this part of the process is not ideal.
Because Airtable does not provide access to the schema via their API, you'll have to "download" the schema manually via a web browser of choice.The followinggistis a script that you can run on a Chrome console from the Airtable baseAPI pageto get back the JSON schema that airtstorm is expecting to be fed with.RoadmapField validation where possible.Push changes. Currently we are read-only.Downlading schema automatically using pyppeteer.Pythonic formulas.
Package: airsupply-django-shorturls
django-shorturlsA custom URL shortening app for Django, including easyrev=canonicalsupport.Most code was originally by Simon Willison; seehttps://simonwillison.net/2009/Apr/11/revcanonical/for details. Improved
slightly and packaged by Jacob Kaplan-Moss. Currently maintained by
Ben Firshman.Patches welcome:http://github.com/bfirsh/django-shorturlsUsageSo, you want to host your own short URLs on your Django site:In your settings, define a set of prefixes for short URLs:SHORTEN_MODELS={'A':'myapp.animal','V':'myapp.vegetable','M':'myapp.mineral'}The keys are string prefixes; they can be any string, actually,
but since we’re going for short a single character is probably good.Values are the (hopefully-familiar)"<app-name>.<model-class>"used
by Django to identify a model. Remember:app-nameis the
(case-sensitive) last bit of your app’s name inINSTALLED_APPS, and<model-class>is your model class’s name, lowercased.Make sure your models have aget_absolute_url()method defined.Wire up the redirect view by adding to your URLconf:('^short/',include('shorturls.urls'))If you’d like to quickly link to shortened URLs in your templates, stick"shorturls"inINSTALLED_APPS, and then in your templates do:{%loadshorturl%}<ahref="{%shorturlobject%}">...</a>(whereobjectis a model instance).Alternatively:{%loadshorturl%}{%revcanonicalobject%}This generates the whole<linkrev="canonical"href="...">tag for
you.That’s it.If you’d like more control, keep reading.SettingsAvailable settings are:SHORTEN_MODELSYou’ve seen this one.SHORT_BASE_URLIf defined, theshorturlandrevcanonicaltemplate tags will
prefix generated URLs with this value. Use this if you’ve got a shorter
domain name you’d like to use for small URLs.For example, givenSHORT_BASE_URL ='http://exm.pl/',{% shorturl obj %}would return something likehttp://exm.pl/AbCd.SHORTEN_FULL_BASE_URLThe domain to redirect to when redirecting away from the small URL.
Again, you’ll use this if your short URL base and your “real” site
differ.If not defined, the redirect view will try to guess the proper domain by
consulting thedjango.contrib.sitesframework, if installed, or the
requested domain, if not.SHORTURLS_DEFAULT_CONVERTERThe converter that is used to translate between short URLs and model IDs.
Defaults to the built in base 62 conversion.Available converters:shorturls.baseconv.base62Base 62 encoding.shorturls.baseconv.base32Douglas Crockford’s base 32.shorturls.baseconv.hexconvHex encoding.shorturls.baseconv.binBinary encoding, because why not.
Package: airtable-cacher
Airtable CacherThis plugin is fork of the work done by Ron Mountjoy onAirtable Cachinghttps://github.com/rmountjoy92/AirtableCachingCachingFirst you must setup a recurring script that will cache the table.from airtable_cacher import Base

airtable = Base(<AIRTABLE_BASE_ID>, <AIRTABLE_API_KEY>)

"""
Main Function
"""

airtable.cache_table(<AIRTABLE_PRODUCTS_TABLE>)You can optionally supply a third argument toBase()for setting the json folder like so:from airtable_cacher import Base

airtable = Base(<AIRTABLE_BASE_ID>, <AIRTABLE_API_KEY>, "my_json_folder")Caching imagesIf you'd like to cache images, you can do so by supplying an optional fourth argumentAccessing cached datafrom airtable_cacher import Table

products_table = Table(<AIRTABLE_BASE_ID>,<AIRTABLE_PRODUCTS_TABLE>)If you have supplied a custom JSON folder path in the caching, you supply that as an optional third argument inTable()from airtable_cacher import Table

products_table = Table(<AIRTABLE_BASE_ID>,<AIRTABLE_PRODUCTS_TABLE>, "my_json_folder")To get all records then userecords = products_table.all()
Package: airtable-caching
Airtable CachingUtility for caching api responses from the airtable-python-wrapper and provides an ORM style interface for querying cached records.Dummy api key and base keys provided below for testing. Please do not modify anything using this key, or I will have to take this option away.Installationpipinstallairtable-cachingStep 1 - Import classesfromairtable_cachingimportBase,TableStep 2 - cache a tablebase=Base(base_id="appjMwyFviPaM9I0L",api_key="keyqhxncgPbSySJQN")base.cache_table("Table 1")Step 3 - Access cached datatable=Table(base_id="appjMwyFviPaM9I0L",table_name="Table 1")# get single record by it's airtable record IDtable.get('rec4trz5QrB6aWJBw')# get all records in the tabletable.query().all()# get all records and resolve linked fieldstable.query(resolve_fields={"Table 2":"Link to Table 2"}).all()# get the first record in tabletable.query().first()# get the last record in tabletable.query().last()# filtering records in the querytable.query().filter_by({"Name":"Data entry 1 from Table 1 from Base 1"}).all()# ordering records in the querytable.query().order_by("Number").all()# ordering records in the query (descending)table.query().order_by("Number",desc=True).all()Defining a custom cache folder locationBy default this stores all cached data as .json files in airtable_caching/json. You can optionally pass a custom folder location to the Base and Table classes.importoscustom_json_folder=os.path.join(os.path.dirname(__file__),"custom_json")base=Base(base_id="appjMwyFviPaM9I0L",api_key="keyqhxncgPbSySJQN",json_folder=custom_json_folder,)table=Table(base_id="appjMwyFviPaM9I0L",table_name="Table 1",json_folder=self.custom_json_folder,)Changelog0.0.4UpdatedREADME and docstrings0.0.3Changed(BREAKING) Base and Table classes no longer use base name, now they use base id (see docs)added option for supplying custom cache locationAddedDocumentationTests0.0.1 - 0.0.2Initial release
Package: airtable-fdw
Airtable Foreign Data WrapperInstallationRequirementsPostgreSQL 9.1+ withMulticornextension installed.Loading extension and defining FDW serverEnsure multicorn is loaded and define Foreign Data Wrapper for airtablecreateextensionifnotexistsmulticorn;createserverifnotexistsmulticorn_airtable_srvforeigndatawrappermulticornoptions(wrapper'airtable_fdw.AirtableFDW');UsageDefine table ascreateforeigntableschema.table_name("_id"varcharoptions(rowid'true'),-- column used as rowid, may be any name,-- should appear only onece"Some text column"varchar,"Some numeric column"numeric,"Some date column"date,"Some complex column"json,-- can be used for complex fields but see example below"Some json nullable column"jsonoptions(nulljson'true'),-- keep nulls as json ('null'::json instead of null::json)"Some computed column"varcharoptions(computed'true')-- column that won't be modified with update-- may appear multiple times)servermulticorn_airtable_srvoptions(api_key'...',-- api access keybase_key'...',-- database identifiertable_name'...',-- name of table to read fromview_name'...',-- optional view name, if not present raw table will be readrowid_column'...'-- optional rowid column name will be used if no column has `rowid` option set);If complex column - likeCollaborator- appears in table it is read from AirTable API as ajsonand could be treated asjsonor as a complex, custom defined type.createtypeAirtableCollaboratoras(idvarchar,emailvarchar,"name"varchar);createforeigntableschema.table_name("_id"varcharoptions(rowid'true'),"editor"AirtableCollaboratoroptions(complextype_fields'id,email,name',complextype_send'email'))servermulticorn_airtable_srvoptions(api_key'...',base_key'...',table_name'...');where:complextype_fields 'id,email,name'indicates how record string should be constructed fromjson- so{"id": "someid", "email": "me@example.com", "name":"My Name"}will be converted to(someid,me@example.com,My Name)and will be correctly casted toAirtableCollaboratortype.complextype_send 'email'means that when this field is modified onlyemailfield will be sent to APIUsage TipsUseANDinWHEREclause whenever possible,ORs are not handled well (at all?) bymulticornso unconditional queries are sent to Airtable (watch the quota!).IfORis required try to replace it withIN (...)FeaturesConfigurable to read from given base / table / viewSQLWHEREclause transformed toformulaquery (so number of requests to API is optimized)BatchINSERT/UPDATE/DELETEsupport for complex types - json is parsed to complex type on read (SELECT), and single, selected field is set on write (INSERT,UPDATE)
Package: airtableio
Async API wrapper for Airtable.Powered by aiohttp.https://airtable.com/InstallationpipinstallairtableioSimple UsagefromairtableioimportAirtableimportasyncioTOKEN=""APP_ID=""my_airtable=Airtable(TOKEN,APP_ID)asyncdefcall():result=awaitmy_airtable.get_records("Table")print(result)if__name__=="__main__":loop=asyncio.get_event_loop()loop.create_task(call())loop.run_forever()
Package: airtablemock
A mock library to help test Python code accessing Airtable using thePython library.It keeps tables in RAM and can do basic operations.InstallationThe easiest way is using pip:pipinstallairtablemockUsageIn your test, you patch the whole airtable library:importunittestimportairtablemockimportmycode@airtablemock.patch(mycode.__name__+'.airtable')classTestMyCode(unittest.TestCase):deftest_foo():# This is a client for the base "baseID", it will not access the real# Airtable service but only the mock one which keeps data in RAM.client=airtablemock.Airtable('baseID','apiKey')# Populate the table.client.create('table-foo',{'field1':1,'field2':'two'})# Run your code that uses Airtable, it should transparently uses the table# above.mycode.run()# Access the table again to check if anything was modified.records=client.get('table-foo')…ReleaseTo create a new release of airtablemock, tag the Git repo and run:pythonsetup.pysdistbdist_wheeltwineuploaddist/airtablemock-*
Package: airtable-orm
Python ORM for Airtable tablesInstallationpip install airtable-ormUsagefromdataclassesimportdataclass# Importing libraryfromairtable_ormimportAirtableORM# Initialize the object and get the sessionorm=AirtableORM("airtable://:<YOUR API KEY>@<YOUR APP KEY>")session=orm.get_session()# Create your data class with properties same as your Airtable tables# The name of the class muse be matched to the Airtable table name@dataclassclassMyEntity:id:strname:str# Create new object for the dataclassnew_entity=MyEntity("id#1","My name")# Run add() to create new entrysession.add(new_entity)# Run commit() to save the data to Airtablesession.commit()To list all the data as objectdata=session.query(MyEntity).all()for_indata:print(_.name)
Package: airtable-python
airtable-pythonairtable-pythonis an API wrapper for Airtable, written in PythonUse this library if you are interested in Oauth authentication and webhook notifications.Installingpip install airtable-pythonUsagefrom airtable.client import Client
client = Client(client_id, client_secret, redirect_uri, code_verifier)Note: If you already have an access token, you can initiate Client without any parameters and directly set token with the access token you have as a dictionary client.set_token({"access_token": token})Get access_tokenTo get the access token using Oauth2 follow the next steps.
Checkhttps://airtable.com/developers/web/api/oauth-referencefor more info:Get authorization URL to receive codeurl = client.authorization_url(state)Get access token using codetoken = client.token_creation(code)Set access tokenclient.set_token(access_token)If your access token expired, you can get a new one using refresh_token:response = client.refresh_access_token(refresh_token)And then set access token again...Get current useruser = client.get_current_user()List Basesbases = client.list_bases()List Tablestables = client.list_base_tables(baseId)List recordsrecords = client.list_records(
    baseId, 
    tableId, 
    pageSize=None, 
    maxRecords=None, 
    filter_field=None, 
    filter_value=None, 
    sort_field=None, 
    sort_direction=None
)
# baseId and tableId are required
# sort_direction options are 'desc' or 'asc'Create Recordsrecords = [
    {
        "fields": {
          "Projects": "Project from python",
          "Status": "In progress",
          "Complete?": False
        }
    },
]
records = client.create_records(baseId, tableId, records)Update Recorddata = {
    "Status": "Complete",
    "Complete?": True
}
record = client.update_record(baseId, tableId, recordId, data)Update Multiple Recordsrecords = [
    {
        "id": "recB4UscNECOHnT7y",
        "fields": {
            "Number": 10000,
        },
    },
    {
        "id": "recFkktx671jlvyj8",
        "fields": {
            "Number": 20000,
        },
    },
]
updated_records = client.update_record(baseId, tableId, records)List Collaborators (needs enterprise scopes access)collabs = client.list_collaborators(baseId)
Package: airtable-python-wrapper
Airtable Python WrapperAirtable API Client Wrapper for PythonInstallingpip install airtable-python-wrapperDocumentationFull documentation here:http://airtable-python-wrapper.readthedocs.io/Usage ExampleBelow are some of the methods available in the wrapper.For the full list and documentation visit thedocsYou can see the wrapper in action in thisJupyter Notebook.airtable = Airtable('base_id', 'table_name')

airtable.get_all(view='MyView', maxRecords=20)

airtable.insert({'Name': 'Brian'})

airtable.search('Name', 'Tom')

airtable.update_by_field('Name', 'Tom', {'Phone': '1234-4445'})

airtable.delete_by_field('Name', 'Tom')LicenseMIT0.15.3Adds escaping formula field references #1200.15.2Added Batch update method0.15.1Fix:batch delete0.15.0Breaking: Drop Api config from ENV variable - useapi_keyarg insteadBreaking: Drop Python 2 / IronPython SupportFeature: On HTTP Errors, Raise Original Exception, but with Helpful Errors addedFix: #86 formulas with string values0.14.0Removed:mirror()method.Feature: Configurable request timeout0.13.0Fixed: Python 2 compatibility issuesStart CI testing on all supported Python versionsBreaking: Drop implicit support for Python 3.4, officially support 3.7 and 3.8.0.12.0Fixed: Rewrote testsFixed: Improve CI and deployment0.11.2Fixed: Add sdist and universal for 2.7 distFixed: Long dist set to markdown0.11.0Feature: Merged PR#17 - Added typecast to update, update_by_field, replace, replace_by_field0.10.1Feature: Added typcase option to batch_insert0.10.0Feature: Merged PR#17 - typecase kwarg0.9.1Feature: Better exception message for 422 (Issue #16)Fix: 2.7 Compat with sys.implementation0.9.0Docs: Revised Docs strings to show kebab case kwargsFix: Url Escape (PR#1)0.8.0Docs: New Documentation on Parameter filters DocsDocs: More documentation and examples.Feature: Search now uses filterByFormulaAdded Formula Generator0.7.3Removed Unencoded Debug Msg due to IronPython Bug #2420.7.2Merge Fix0.7.1-alphaMoved version to sep file to fix setup.py errorRemoved urlencode importAdded Explicit Raise for 422 errors with Decoded Urls0.7.0-dev1Feature: Added airtable.get() method to retrieve recordFix: sort/field string input to allow sting or listFix: AirtableAuth DocsFix: Keyargs Docs0.6.1-dev1Bugfix: Fix Setup to install six.pyBugfix: Fix AitableAuth Docs0.6.0-dev1Implemented Sort FilterImplemented FilterByFormulaImplemented all param filters as classesAdded Aliases for ParametersRenamed get() to get_iter()0.5.0-dev10.4.0Added replace()Added mirror()0.3.0Initial Work
Package: airtel-airflow-plugins
##### Airtel Airflow Plugins Library#####Table of ContentsOverview
Setup
UsageOverview
Airtel Airflow Plugins Library containing all custom operators, sensors, callbacks and hooks.Setup
first create virtual env in your local setup -
Note - make sure to create virtual env ending with _venv so the at the time of pushing code to git it must be ignored.python3 -m venv <virtual_env_name_venv>source <virtual_env_name_venv>/bin/activateChange the interpreter setting in your IDE to point it to correct virtual envFirst, clone this repo to your local system. After you clone the repo, make sure to run the setup.py file, so you can install any dependencies you may need. To run the setup.py file, run the following command in your terminal.Run requirement.txt in your virtual env. This will install all the dependencies listed in the requirements.txt filepip install -r requirements.txtBelow command will create wheel file.python setup.py bdist_wheelPlease make sure to have .pypirc file in your local home directory. We have attached sample in project home dir as well.
This file contains repository url along with credential which we would be needing while running below command to publish
the package on PYPI repository.Below command will publish the package on PyPI repositorytwine upload –repository nexus dist/*Usage
The plugins package can be used in any Airflow setup for custom modules (Operators / Plugins / Sensors / Callbacks).
Package: airtest_for_h9
#-- coding: utf-8 --This program is an extension of airtest for com.netease.H9.Thanks to the authors for their great work.About airtest, Please refer to “http://netease.github.io/airtest/overview/quick_start.html”
for complete information and details .Author: zheng wen
Mail  :wenzheng@whu.edu.cnTime  : 2014年12月17日 11:59:28