Saravanan666/pypi-org huggingface dataset:
Package: atom3
Processing of 3D atomic data.Installation$pipinstallatom3UsageProcess a PDB file to a pickled pandas dataframe.$atom3parsesample/11as.pdb1.gzsample/parsedDerive subunits of a parsed dataframe.$atom3complexsample/parsedsample/complexes.dillSplit subunits into interacting pairs.$atom3pairssample/complexes.dillsample/pairsFor help on commands.$atom3-h$atom3parse-h
Package: atom3d
ATOM3D: Tasks On Molecules in 3 DimensionsATOM3Denables machine learning on three-dimensional molecular structure.FeaturesAccess to several datasets involving 3D molecular structure.LMDB data format for storing lots of molecules (and associated metadata).Utilities for splitting/filtering data based on many criteria.For more detailed information,read the documentation.InstallationInstall with:pip install atom3dTo use rdkit functionality, please install within conda:conda create -n atom3d python=3.6 pip rdkit
conda activate atom3d
pip install atom3dUsageDownloading a datasetFrom python:import atom3d.datasets as da
da.download_dataset('lba', PATH_TO_DATASET) # Download LBA dataset.Or, download and unzip from thewebsite.Loading a datasetFrom python:import atom3d.datasets as da
dataset = da.load_dataset(PATH_TO_DATASET, {'lmdb','pdb','silent','sdf','xyz','xyz-gdb'})
print(len(dataset))  # Print length
print(dataset[0].keys())  # Print keysLMDB datasetsLMDB allows for compressed, fast, random access to your structures, all within a
single database.  Currently, we support creating LMDB datasets from PDB files, silent files, and xyz files.Creating an LMDB datasetFrom command line:python -m atom3d.datasets PATH_TO_PDB_DIR PATH_TO_DATASET --filetype {pdb,silent,xyz,xyz-gdb}For more usage, please see thedocumentation.ContributeAs a living repository, we welcome contributions of additional datasets, methods, and functionality!  See theContributingsection of the documentation for details.SupportFor support, please file an issue athttps://github.com/drorlab/atom3d/issues.LicenseThe project is licensed under theMIT license.ReferenceWe provide an overview on ATOM3D and details on the preparation of all datasets in our preprint:R. J. L. Townshend, M. Vögele, P. Suriana, A. Derry, A. Powers, Y. Laloudakis, S. Balachandar, B. Jing, B. Anderson, S. Eismann, R. Kondor, R. B. Altman, R. O. Dror "ATOM3D: Tasks On Molecules in Three Dimensions",arXiv:2012.04035Please cite this work if some of the ATOM3D code or datasets are helpful in your scientific endeavours. For specific datasets, please also cite the respective original source(s), given in the preprint.
Package: atom3-py3
Processing of 3D atomic data (Python 3 version).Installation$pip3installatom3-py3UsageProcess a PDB file to a pickled pandas dataframe.$atom3parsesample/11as.pdb1.gzsample/parsedDerive subunits of a parsed dataframe.$atom3complexsample/parsedsample/complexes.dillSplit subunits into interacting pairs.$atom3pairssample/complexes.dillsample/pairsFor help on commands.$atom3-h$atom3parse-h
Package: atoma
Atom, RSS and JSON feed parser for Python 3.QuickstartInstall Atoma with pip:pip install atomaLoad and parse an Atom XML file:>>>importatoma>>>feed=atoma.parse_rss_file('rss-feed.xml')>>>feed.description'The blog relating the daily life of web agency developers'>>>len(feed.items)5Parsing feeds from the Internet is easy as well:>>>importatoma,requests>>>response=requests.get('http://lucumr.pocoo.org/feed.atom')>>>feed=atoma.parse_atom_bytes(response.content)>>>feed.title.value"Armin Ronacher's Thoughts and Writings"FeaturesRSS 2.0 -RSS 2.0 SpecificationAtom Syndication Format v1 -RFC4287JSON Feed v1 -JSON Feed specificationOPML 2.0, to share lists of feeds -OPML 2.0Typed: feeds decomposed into meaningful Python objectsSecure: uses defusedxml to load untrusted feedsCompatible with Python 3.6+Security warningIf you use this library to display content from feeds in a web page, you NEED
to clean the HTML contained in the feeds to preventCross-site scripting (XSS). Thebleachlibrary is recommended for cleaning feeds.Useful ResourcesTo use this library a basic understanding of feeds is required. For Atom, theIntroduction to Atomis a must
read. TheRFC 4287can help lift some
ambiguities. Finally thefeed validatoris
great to test hand-crafted feeds.For RSS, theRSS specificationandrssboard.orghave a ton of information and
examples.For OPML, theOPML specificationhas a paragraph dedicated
to its usage for syndicationNon-implemented FeaturesSome seldom used features are not implemented:XML signature and encryptionSome Atom and RSS extensionsAtom content other thantext,htmlandxhtmlLicenseMIT
Copyright (c) 2018 Nicolas Le ManchetPermission 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.
Package: atom-access
atom_accessis a python package for assessing the steric hindrance at any atom in a molecule or molecular fragment.We request that any results obtained through the use ofatom_accessare accompanied by the following reference:Gransbury, G. K.; Corner, S. C.; Kragskow, J. G. C., Evans, P.; Yeung, H. M.; Blackmore, W. J. A.; Whitehead, G. F. S.; Vitorica-Yrezabal, I. J.; Chilton, N. F.; Mills, D. P.AtomAccess: A predictive tool for molecular design and its application to the targeted synthesis of dysprosium single-molecule magnets.ChemRxiv2023, DOI: 10.26434/chemrxiv-2023-28z84.This code was developed under the ERC CoG-816268 grant with PIDavid P. Mills. We acknowledge Ken Gransbury for help conceptualising theatom_accesslogo.Web interfaceTheatom_accessweb interface is available on theMagnetism Toolswebsite and has all the features of the command line interface and package, plus the ability to visualise rays/clusters on top of molecular models.Installation viapipThe easiest way to install atom_access is to usepippipinstallatom_accesssome users, such as those on shared machines, may need to use the--userargument afterinstallUpdating viapipUpdate the code usingpippipinstall--upgradeatom_accesssome users, such as those on shared machines, may need to use the--userargument afterinstallUsageatom_accesstakes an xyz file as the input and can be run in the command lineatom_access<molecule.xyz>Useatom_access -hto see all available optionsDevelopers: Installation withpipeditable installClone a copy of this repository, preferably while within a directory called gitmkdir-pgit;cdgit
gitclonehttps://gitlab.com/chilton-group/atom_accessNavigate to the package directorycdatom_accessand install the package in editable modepipinstall-e.some users, such as those on shared machines, may need to use the--userargument afterinstallTo uninstall this editable copy, usepipuninstallatom_accessBuilding a.whlfile (Advanced)To build a copy of theatom_access.whlfile, move to thepackagedirectory.Now run./build_binaries.shThen install the.whlfile withpippipinstalldist/*.whlsome users, such as those on shared machines, may need to use the--userargument afterinstallDocumentationThedocumentationfor this package is hosted by gitlab, and is automatically generated whenever new code is committed to themainbranch.BugsIf you believe you have a bug,please check that you are using the most up to date version of the code.If that does not fix the problem, please create an issue on GitLab detailing the following:The commands you enteredThe error messageIf possible, try to simplify the problem as much as possible, e.g. providing an example for a small molecule rather than one with 1000 atoms.
Package: atom-alter-api
This is an unofficial python API for Atomars and Alterdice exchanges.InstallInstall using pip$pipinstallatom-alter-apiUsageNote: Many of the functions in the API are async. So you have to use await or ensure_future etc… To use the API in another python program, first import asyncio and the API, then login using your username and password, then call whatever function you would like. Because the API is asyncio, we will need to do this within a class so that we can “await” for functions to complete. Here is a simple example to get the balances:importasynciofromatom_alter_API.apiimportAtomarsAlterdiceAPIclassTestClass():def__init__(self):self.api=AtomarsAlterdiceAPI(API_login_username,API_login_password)asyncdefrun(self):awaitself.api.login()balances=awaitself.api.get_balances()print(balances)if__name__=="__main__":testClass=TestClass()asyncio.ensure_future(testClass.run())loop=asyncio.get_event_loop()loop.run_forever()loop.close()See the docs folder for more info. Also see tests for some more code examples.Install for developmentClone this repo$cd~/$gitclonehttps://github.com/hyperevo/Atomars-alterdice-APIInstall using pip$cdAtomars-alterdice-API$pip3install-e.
Package: atomap
AtomapWebpage:https://atomap.orgWebpage (development version), click the atomap.gitlab.io link:https://gitlab.com/atomap/atomap/builds/artifacts/master/file/public_development/index.html?job=pages_developmentAtomap is a Python library for analysing atomic resolution
scanning transmission electron microscopy images.
It relies on fitting 2-D Gaussian functions to every atomic
column in an image, and automatically finding all the atomic
planes with the largest spacings.InstallingThe easiest way is via the Anaconda Python distribution, and installing with:condainstallatomap-cconda-forgeIt can also be installed via PyPI:pip3installatomapMore install instructions:https://atomap.org/install.htmlUsingimportatomap.apiasamsublattice=am.dummy_data.get_simple_cubic_sublattice()sublattice.construct_zone_axes()sublattice.refine_atom_positions_using_center_of_mass()sublattice.plot()More information on how to use Atomap:https://atomap.org/start_atomap.html
Package: atomapi
Python AtoM APIThis is a simple library for interacting with anAtoMarchive within Python. This library works with Python version 3, and has been tested with AtoM version 2.5. All of the API interactions specified in theAtoM documentationall have easy-to-call python functions associated with them in
this library. This includes:Browsing TaxonomiesBrowsing Information ObjectsReading Information ObjectsThis library also implements a virtual endpoint that can be used to retrieve all of the authorities stored in the archive. It does this by treating the front-end application as an API endpoint. For this reason, this operation is more fragile than calling the API directly and is not guaranteed to work with every version of AtoM and every theme.Installpython-mpipinstallatomapiUsageTo use the API, you will require anAtoM API key. To get data from the API, create an instance of theAtomclass:importatomapiatom=atomapi.Atom('https://youratom.com',api_key='1234567890')Fetch taxonomies, and view information objects like so:subjects=atom.taxonomies.browse('subjects')info_obj=atom.taxonomies.read('some-reference-code')results=atom.taxonomies.browse(sq={'sq0':'School'},so={},sf={'sf0':'title'},filters={})For more examples, check out theexamplesfolder.
Package: atomate
atomate is a software for computational materials science that contains pre-built workflows to compute and analyze the properties of materials.Website (including documentation):https://hackingmaterials.github.io/atomate/Help/Support:https://discuss.matsci.org/c/atomateSource:https://github.com/hackingmaterials/atomateIf you find atomate useful, please encourage its development by citing the following paper in your research output:Mathew, K., Montoya, J. H., Faghaninia, A., Dwarakanath, S., Aykol,
M., Tang, H., Chu, I., Smidt, T., Bocklund, B., Horton, M., Dagdelen,
J., Wood, B., Liu, Z.-K., Neaton, J., Ong, S. P., Persson, K., Jain,
A., Atomate: A high-level interface to generate, execute, and analyze
computational materials science workflows. Comput. Mater. Sci. 139,
140-152 (2017).
Package: atomcache
IntroductionAsynchronous cache manager designed for horizontally scaled web applications.NOTE:Currently has implementation only for FastAPI using Redis.RequirementsPython 3.7+redisfor cache implementation.FastAPIfor the web parts.Installation$pipinstallatomcache---> 100%Explanation schemaAs UML@startuml
    !theme materia
    participant Redis
    participant Instance_A as A
    participant Instance_B as B
    participant Instance_N as C


    B <-> Redis: GET: Cache=null & GET: Lock=null

    B <-> Redis: SET: Lock = true

    activate B #Red
    A <--> Redis: GET: Cache=null & GET: Lock=true
    activate A #Transparent
    C <--> Redis: GET: Cache=null & GET: Lock=true
    activate C #Transparent
    B <--> B: Do the computation
    B -> Redis: SET: Cache={...}
    deactivate B

    group Notify Cache SET
        Redis -> C
        Redis -> A
    end
    group GET Cache
        Redis <-> C
    deactivate C
        Redis <-> A
    deactivate A
    end
@endumlExamples:Usage as FastAPI DependencyCreate a fileevents.pywith:fromtypingimportOptional,Callablefromredis.asyncioimportRedisfromfastapiimportFastAPI,DependsfromatomcacheimportCachedefcreate_start_app_handler(app:FastAPI)->Callable:asyncdefstart_app()->None:redis:Redis=awaitRedis.from_url(url="redis://localhost",encoding="utf-8")awaitCache.init(app,redis)returnstart_appdefcreate_stop_app_handler(app:FastAPI)->Callable:asyncdefstop_app()->None:awaitCache.backend.close()returnstop_appCreate a filemain.pywith:fromtypingimportOptionalfromfastapiimportFastAPI,DependsfromatomcacheimportCachefrom.eventsimportcreate_start_app_handler,create_stop_app_handlerapp=FastAPI()app.add_event_handler("startup",create_start_app_handler(app))app.add_event_handler("shutdown",create_stop_app_handler(app))@router.get("/resources",response_model=List[TheResponseModel],name="main:test-example")asyncdefresources(offset:int=0,items:int=10,cache:Cache=Depends(Cache(exp=600)):cache_id=f"{offset}-{items}"# Build cache identifierawaitcache.raise_try(cache_id)# Try to respond from cacheresponse=awaitdb.find(TheResponseModel,skip=offset,limit=items)awaitasyncio.sleep(10)# Do some heavy work for 10 sec, see `lock_timeout`returncache.set(response,cache_id=cache_id)Direct cache usage for avoiding repetitive calling on external resources:fromaiohttpimportClientSessionfromatomcacheimportCachecache=Cache(exp=1200,namespace="my-namespace:")asyncdefrequesting_helper(ref:str)->List[dict]:cached_value=awaitcache.get(cache_id=ref)ifcached_valueisnotNone:returncached_valueasyncwithClientSession()assession:asyncwithsession.get(f"https://external-api.io/{ref}")asresponse:ifresponse.ok:cached_value=response.json()returncache.set(cached_value,cache_id=ref)return[]
Package: atomcalc
About AtomCalcAtomCalc simulates the interaction between multi-level atoms and laser fields. It calculates how the population of the electronic levels of an atom changes if laser pulses are applied. To allow for realistic simulations, the motional state of the atom and decay channels can be taken into account.
A system is defined by the levels, the lasers, and decay paths. For each of them exists one class that owns the corresponding properties.
The time evolution of the population of each level is then calculated with thesimulatefunction that uses a Lindblad master equation approach.This project is supposed to be expanded and should be seen as a construction fundament.
The methods used in the code are explained in my master thesis which can be obtained via the 5th institute of physics of the university of Stuttgart.InstallationAtomCalc can be installed withpip install atomcalc. Its dependencies are Matplotlib, SciPy, NumPy and QuTiP.
Package: atomcloud
AtomCloud is a Python package designed to streamline the fitting of atom cloud images. While single function atom cloud fits can be manageable, things can become more challenging when dealing with complex multi-function fits and multiple stages of fitting. This is where AtomCloud shines. It creates an easy-to-use interface for these fits and abstracts away unnecessary details—all while providing the user with a high degree of control over the fitting process.AtomCloud is built on top of the JAXFit fitting library, which provides GPU-accelerated fitting. This means fit speed-ups can be 10-100 times faster than traditional CPU-based fitting.AtomCloud offers a wide spectrum of fitting capabilities. These include built-in 1D and 2D fit functions for common atom cloud distributions such as thermal clouds, condensates, and bimodal clouds. It also provides the flexibility to constrain fit parameters in multi-function fits. In the realm of multi-level fits, users can easily stack multiple fit functions together to create a custom-tailored fit.However, the functionality of AtomCloud doesn't stop at fitting. We've also integrated a variety of analysis tools, such as fit parameter rescaling, integration of fitted density distributions, and temperature extraction.Lastly, all the fitting and analysis tools natively incorporate error propagation, making experimental error analysis a breeze.https://github.com/lucashofer/atomcloud
Package: atomd
atomdVersion 0.2.5A markdown lexer and parser which gives the developer atomic control over markdown parsing to html.Atomd first tokenizes the markdown with the lexer.Using the tokenized markdown, parsers for various different markup languages (HTML, XML, etc) are easier to implement, since it more or less becomes a game of find and replace.Installpython3 -m pip install atomdUsageFunctions inatomd.pycalledmd2<target_language>()combine the lexer and parser to provide an easier calling convention.In the case of the HTML parser, this ismd2html().If you want to parse a markdown file, do the following:fromatomdimportmd2htmlhtml=md2html(filename="path/to/myfile.md").decode('utf-8')If you want to parse a string of markdown, do the following:fromatomdimportmd2htmlhtml=md2html(md=b"# My markdown ByteString!").decode('utf-8')LexerThis portion of the program tokenizes the markdown based on the lexicon, which is a mapping of markdown syntax items to tokens that will represent the specific syntax.Tokenization is done with a series of regular expressions.If there are bugs in the program, it is likely they exist in the regular expressions and can be fixed without significant design changes to the program, which allows for quick turnaround on bugfixes.ParsersCurrently, atomd supports the following:HTML (html.py)
Package: atomdateparser
AtoM Event Date ParserDate parser for eventDates, eventStartDates, eventEndDates inAtoMCSV templates.InstallationInstall with pip fromPyPi:pip install atomdateparserUsageUse theEventDateParserclass to parse dates. When possible, the Event date parser will try to construct a start and an end date for the given date, as opposed to parsing a single date for the specified date, as most date parsers do.fromatomdateparser.parserimportEventDateParserparser=EventDateParser(unknown_date='Date Unknown',unknown_start_date='2000-01-01',unknown_end_date='2010-01-01',timid=True,dateparser_kwargs={'languages':['en','fr'],'settings':{'PREFER_DAY_OF_MONTH':'first','PREFER_DATES_FROM':'past',}},)parsed=parser.parse_event_dates('Circa 2001')''' Returns:{'eventDates': '2001','eventStartDates': '2001-01-01','eventEndDates': '2001-12-31',}'''EventDateParser Optionsunknown_date: The text to return for eventDates when the date is not knownunknown_start_date: The date to return for eventStartDates when the date is not knownunknown_end_date: The date to return for eventEndDates when the date is not knowntimid:Trueif an exception should be thrown if theentiredate cannot be parsed, orFalseif no date could be found, and no year could be found from the date being parsed. Note that if timid isFalse, some date information may be lost.dateparser_kwargs: Thedateparserlibrary is used as a fallback method to parse the input date in the event that none of the other date parsing handlers are able to parse the date. Controlling dateparser is done using this keyword argument. Keyword arguments are passed todateparser.parse(). For more information, visitdateparser on GitHubor visit thedateparser settings docs.
Package: atomgrad
atomgradAtomgrad is a simple autograd engine that aims to be betweenmicrogradandtinygradthat performs autodiff on vector-valued and scalar-valued tensors (atoms) coupled with a neural network api library.FeaturesSupports Pytorch-like vector-valued and scalar-valued tensors.Supports basic unary ops, binary ops, reduce ops and movement ops i.e (activn funcs,sum,exp,reshape,randint,uniform, etc).Supports activation functions such asrelu,sigmoid,tanh, etc.Supportsbinary_cross_entropy&binary_accuracy.Supports Graph Visualizations.InstallationYou can install atomgrad using pip:pipinstallatomgrad==0.3.0UsageHere is a simple example of using atomgrad to compute the gradient of a function:fromatomgrad.atomimportAtomfromatomgrad.graphimportdraw_dot# create two tensors with gradients enabledx=Atom(2.0,requires_grad=True)y=Atom(3.0,requires_grad=True)# define a functionz=x*y+x**2# compute the backward passz.backward()# print the gradientsprint(x.grad)# 7.0print(y.grad)# 2.0draw_dot(z)Here is a simple example of using atomgrad to train a one 16-node hidden layer neural network for binary classification.importnumpyasnpfromatomgrad.atomimportAtomfromatomgrad.nnimportAtomNet,Layerfromatomgrad.optimimportSGDfromatomgrad.metricsimportbinary_cross_entropy,binary_accuracy# create a modelmodel=AtomNet(Layer(2,16),Layer(16,16),Layer(16,1))# create an optimizeroptim=SGD(model.parameters(),lr=0.01)# load some datax=[[2.0,3.0,-1.0],[3.0,-1.0,0.5],[0.5,1.0,1.0],[1.0,1.0,-1.0],[0.0,4.0,0.5],[3.0,-1.0,0.5]]y=[1,1,0,1,0,1]x=Atom(x)y=Atom(y)model.fit(x,y,optim,binary_cross_entropy,binary_accuracy,epochs=100)#output'''...epoch: 30 | loss: 0.14601783454418182  | accuracy: 100.0%epoch: 35 | loss: 0.11600304394960403  | accuracy: 100.0%epoch: 40 | loss: 0.09604986757040024  | accuracy: 100.0%epoch: 45 | loss: 0.0816292017698288  | accuracy: 100.0%'''DemosAn example of simple autodiff and four binary classifiers includingmake_moonsdataset and MNIST digits dataset is in theexamples/demos.ipynbnotebook.Note: Althoughatom.nnincludessoftmaxactivation andcat_cross_entropy, model results are quite dissapointing and are likely due to some bug (plz lmk if you find it!). As a result theAtomNetmodel is best suited for binary classification neural net tasks.
Package: atomic6ghg
atomic6ghgThe Atomic6 GHG package is a library to help Python developers speed development of tools
for calculating estimates of CO2 equivalent greenhouse gas emissions.Install it from PyPI:pip install atomic6ghgDocsRead the Docs on GitHubThedocsbranch of this repository hosts content for and tools supporting creating the static web-site hosted on GitHub.io Pages. Contributions for the documentation web-site must be PR'd against thedocsbranch.Example ApplicationCheckout theonline calculator. It uses all the features ofatomic6ghg.HistoryGlasmor/atomic6ghgis a hard fork ofatomic6-org/ghgthe host of 1.0.1 and 1.0.2 releases.atomic6-org/ghgis managed by staff at GE but is not being maintained.