Saravanan666/pypi-org huggingface dataset:
Package: atomify-lammps-logfile
LAMMPS logfile readerTool to read a logfile produced byLAMMPSinto a simple python data structure with aget()-function providing the log data.InstallationFrom pypi (preferred/stable)pip install lammps-logfileDepending on your python installation, you may have to usepip3instead ofpip. This is usualy the case if you need to runpython3rather thanpythonto run python version 3.Install using pip directly from github to get the latest (possibly unstable) version:pip install git+https://github.com/henriasv/lammps-logfile.gitOr by cloning the repository:git clone https://github.com/henriasv/lammps-logfile.git
cd lammps-logfile
pip3 install .Basic usageimport lammps_logfile

log = lammps_logfile.File("path/to/logfile")

x = log.get("Time")
y = log.get("Temp")

import matplotlib.pyplot as plt
plt.plot(x, y)
plt.show()This will give the concatenated log entries of all the runs where the style of the thermo output didn't change with respect to the last run. I.e. if the entries in thethermo_stylewas not changed between runs it will contain the log data for all the timesteps. If thethermo_stylewaschanged,xandywill contain the data from all the timesteps after thethermo_stylewas changed for the last time.Multiple runs in the same log fileIf multiple run statements have been made in a simulation, these can be retrieved bu supplying therun_numkeyword to theget()-functionimport lammps_logfile

log = lammps_logfile.File("path/to/logfile")

x = log.get("Time", run_num=N)
y = log.get("Temp", run_num=N)

import matplotlib.pyplot as plt
plt.plot(x, y)
plt.show()In this case,xandywill contain the log data from theN'thruncommand in LAMMPS, counting from 0.Any invalid call to theget()-function will result in the function returningNone. This happes if the user asks for a thermo propery that does not exist in the log file, or if the user asks for arun_numlarger than the number of runs in the logfile.
Package: atomik
🚀 AtomikAtomik provides you a python-friendly way to manage writing new file and folders in an atomic way.
The main way to use the library is with to use thefileandfoldercontext manager. They will provide
an easy interface to make surethe destination file/folderremain consistent.This means you can be sure that you will not leave a file half written or
a folder with half the files you wanted to write into in case of failure.
When overwriting you can be sure that the data will be either the previous or the next version.📚 ExampleFileThis will ensure either all the data is correctly written to file or none of itwith atomik.file("./result.json") as f:
    print(stream, file=f)Folderwith atomik.folder("./result_folder") as dir:
    with open(Path(dir, "result_1.json") as f:
        print(result_1, file=f)
    with open(Path(dir, "result_2.json") as f:
        print(result_2, file=f)🔐 Safe defaultBy default, atomik will not overwrite files/folders (but it's configurable)🤓 How ?Atomik uses the newrenameat2syscall to allow to rename file in an atomic way.
The syscall doesn't allow to overwrite a non-empty folder when renaming.
This is achieved using theexchangeflag to swap the two folder and then the source
folder is cleaned. This may leave thesrcfolder in case of interruption/issue when deleting
but the destination folder will still be written in an atomic way.AcknowledgementThis library's main goal is to provide a simple interface to rename file in a safe and simple way,
without having to dive deep into OS specific documentation and limitations behind it. If you want
to use the syscall directly I recommend these two libraries which helped the development of Atomik a lot:https://github.com/nickovs/atomicswaphttps://github.com/jordemort/python-renameat2
Package: atomlib
atomlib: A modern, extensible library for creating atomic structuresatomlibis a package for creating, modifying, and controlling atomic structures. It draws heavy inspiration from previous tools likeAtomskandASE, but attempts to provide a cleaner, more consistent interface that can be used from Python or a command line.atomlibhas minimal dependencies:numpy,scipy, andpolarsare required for core atom structure manipulation, andclickis required for command line functionality.Atomic representation & supported propertiesAtomic structures are stored aspolarsDataFrames, providing a clean, immutable interface that maximizes expressiveness and minimizes errors.
For formats that allow arbitrary properties, these properties can be passed through transparently.atomlibhas first-class support for fractional occupancy, Debye-Waller factors, atomic forces, and labels.Translational symmetry is stored inCellobjects, which represent a fully generic cell. Atoms can be modified in any coordinate system that makes sense (global, local real-space, cell fraction, box fraction, etc.). Support for non-translational symmetry operations is limited at this point.For more information, check out the example notebooks and the API documentation.Currently supported file formatsFile format support is still a work in progress. Where possible, parsers are implemented from scratch in-repo.
Most formats are implemented in two steps: Parsing to an intermediate representation which preserves all format-specific information, and then conversion to the genericAtoms&AtomCelltypes for manipulation & display.
This means you can write your own code to utilize advanced format features even if they're not supported out of the box.FormatExt.ReadWriteNotesCIF.cif:white_check_mark::x:CIF1 & CIF2. Isotropic B-factor onlyXCrysDen.xsf:white_check_mark::white_check_mark:AtomEye CFG.cfg:white_check_mark::white_check_mark:Currently basic format onlyBasic XYZ.xyz:white_check_mark::white_check_mark:Ext. XYZ.exyz:white_check_mark::white_check_mark:Arbitrary properties not implementedSpecial XYZ.sxyz:x::x:To be implementedLAMMPS Data.lmp:x::white_check_mark:Quantum Espresso.qe:x::white_check_mark:pw.x formatpyMultislicer.mslice:x::white_check_mark:
Package: atomlite
Author:Lukas TurcaniDocs:https://atomlite.readthedocs.ioAtomLiteAtomLite is a Python library for simple molecular database on top ofSQLite.For an alternative to AtomLite, which provides stronger integration with RDKit, and a
greater focus on cheminformatics, seechemicalite.InstallationpipinstallatomliteQuickstartYou can see a lot more examples in ourdocsbut here is a taste of using
AtomLite:importatomliteimportrdkit.Chemasrdkit# Create a database.db=atomlite.Database("molecules.db")# Create database entries.entry1=atomlite.Entry.from_rdkit("first",rdkit.MolFromSmiles("C"),{"prop1":"hi","prop2":100})entry2=atomlite.Entry.from_rdkit("second",rdkit.MolFromSmiles("CN"),{"prop1":"thing","prop2":203})# Add entries to database.db.add_entries([entry1,entry2])# Retrieve entries from database.forentryindb.get_entries(["first","second"]):molecule=atomlite.json_to_rdkit(entry.molecule)print(entry.properties){'prop1': 'hi', 'prop2': 100}
{'prop1': 'thing', 'prop2': 203}db.get_property_df(["$.prop1","$.prop2"])shape: (2, 3)
┌────────┬─────────┬─────────┐
│ key    ┆ $.prop1 ┆ $.prop2 │
│ ---    ┆ ---     ┆ ---     │
│ str    ┆ str     ┆ i64     │
╞════════╪═════════╪═════════╡
│ first  ┆ hi      ┆ 100     │
│ second ┆ thing   ┆ 203     │
└────────┴─────────┴─────────┘
Package: atom-metric-reporter
metric-reporter-pythonmetric-reporter-python is SDK for Python to send reports for applications monitoring like:Datadog,Appopticsetc.DocumentationInstallationUsageChange LogExampleInstallationInstallation using npm$pipinstallatom_metric_reporterUsageCreate metric reporter for specific driver (datadog or appoptics)frommetric_reporter.metric_reporterimportMetricReportermetric_reporter=MetricReporter("appoptics",{"token":"<token>"},1,10,"g8y3e")Send reportmetric_reporter.send("test_metric",<num>,{"test":"test"})Save shutdown reporter:metric_reporter.stop()ExampleYou can use ourexamplefor sending reports.LicenseMIT
Package: atompack
atompackA flexible Python library for atomic structure generation.InstallationDownload fromPyPIThis is the best method for end users.$pipinstallatompackBuild from sourceThis is the best method for contributors or anyone who is interested in modifying the code.1. Clone the source code withgit:$gitclonehttps://github.com/seatonullberg/atompack.git
$cdatompack2. Download the dependencies and install as editable:This step can be done with eitherpipenvorpip. I recommend usingpipenv. If you're not familiar with the benefits of usingpipenv, find out more about it here:https://pipenv-fork.readthedocs.io/en/latest/.Forpipenvusers:$pipenvinstall
$pipenvinstall--devForpipusers:$pipinstall-rrequirements.txt
$pipinstall-e.[dev]DevelopmentThe project'sMakefileadds a few targets to help out with common development tasks.make bench- Run the benchmark suite.make build- Generate distribution files in./dist.make clean- Remove auto-generated files.make document- Build the documentation in./docs.make format- Enforce preferred code style.make lint- Run static analysis checks.make publish- Upload distribution files to PyPI.make test- Run the unit test suite.
Package: atomphys
atomphysA Python package to help with atomic physics calculations.Documentation:mgrau.github.io/atomphys/Source Code:github.com/mgrau/atomphysatomphys is meant to be a good starting off point for your atomic physics calculations. It can automate much of the frustrating process of searching for and compiling physical data and simple pyhsical relations, and help you more quickly get to the good stuff.It's designed with a natural interface and is easy to use.Example>>>fromatomphysimportAtom>>>Rb=Atom('Rb')>>>print(Rb('S1/2').to('P1/2').λ.to('nm'))795nm>>>print(Rb('P1/2').τ.to('ns'))27.7nsInstallationTo install atomphys, simply use pip:$pipinstallatomphysFeaturesIntegration withPintfor robust handling of unitsAutomatically fetch energy level and transition data from theNIST Atomic Spectra DatabaseUse transition data to calculation state lifetimes, polarizabilities, transition dipole moments, cross sections, and saturation intensitiesRequirementsPython 3.6+atomphys makes extensive use of the excellent packagePintto handle units.
Package: atomquant
Atom QuantAtom QuantAKA:aqis a easy quantization lib supports most decent and fashion quantization method throughtorch.fx. Unlike original pytorch fx quantization support, we add a fully deploy chain from PTQ and QAT quantization to exporting onnx and then shiping to target inference framework.atomquant can be easily use to quant any model without a specific dataloader or evaluator, you can even evaluator quantization performance without any GT.We also support different quantization from vendor package, such asonnxruntime,pytorch_quantization, make it more easy to use and with fully examples.There are 3 main components in atomquant:onnx: directly quantize on onnx model (via onnxruntime);atom: Our built-in quantization method;tensorrt: Quantization specific for convert to TensorRT engine usage;Installatomquant can be installed via:pip install atomquantModel ZooHere, we provide some models quantized for coco, it devided into CPU use, or TensorRT use. Related training code also available:ExamplesQuant ClassificationQuant GPT3Quant VITSQuant AlphaPoseQuant YOLOv7
Package: atom-runtime
atom-python-runtimeA Python implementation operator  runtimeSupported Python version：Python 3.7Installationpipinstallflaskpython-sdk-nacosboto3tensorflow
pipinstallatom-runtimestart-upconfigexample| operator            |  path             |
| train                     |train_example.py|
| reasoning          |reasoning_example.py|
| data                     |data_example.py|frameconnect团队成员|  name  |   role         |   email |    githubId  |
| 老胡      |          创始人 and 开发               |2372554140@qq.com|  githublaohu |
| 星良      | 产品体验官 and  算法负责人 |linxingliang@163.com|   || 俊峰      | 产品负责人 and  技术负责人 |905715760@qq.com|   || 樊阳      | 前端负责人 and  测试负责人     |fanyangdq@163.com|   |
Package: atomshields
What is AtomShields?Security testing framework for repositories and source code.This system has different modules that detect different vulnerabilities or files that may
expose a risk, and the results obtained can be obtained or sent thanks to the reporting modules.For developers: There is also the possibility to develop your own vulnerability detection
(called checkers) or reporting modules. This tool offers certain facilities for those who
want to implement their own modules, publish them and integrate them into the official ElevenPaths tool.InstallationpipinstallatomshieldsBasic usageimportatomshieldsatoms=atomshields.AtomShieldsScanner('./MyRepo/')atoms.project="MyRepoName"issues=atoms.run()# Executes all checkers and all reportsRun tests# If you are in AtomShields directorypipinstall-rrequirements-dev.txtpy.testtests/Generate docs# If you are in AtomShields directorypipinstall-rrequirements-dev.txtcddocsmakehtml
Package: atomshieldscli
AtomShields Cli===============AtomShields Cli is a Command-Line Interface to use the software `AtomShields <https://github.com/ElevenPaths/AtomShields>`_.. raw:: html<a href="https://asciinema.org/a/l87EfxU2e3eNpwQ9F8Sbhpk3q?autoplay=1" target="_blank"><img src="https://asciinema.org/a/l87EfxU2e3eNpwQ9F8Sbhpk3q.png" width="835"/></a>Installation------------.. code-block:: shellpip install atomshieldscliBasic usage-----------.. code-block:: shellascli <action> <context> --target <path> --name <project_name>The allowed *action* values are:- **install**: To install a checker or a report, depending the context setted.- **uninstall**: To uninstall a checker or a report, depending the context setted.- **run**: To run the scan.- **show**: To show a checker list or a report list, depending the context setted.- **help**: Show the helpThe allowed *context* values are:- **checkers**: Operate with checkers- **reports**: Operate with reportsThe *target* option set the path to scan, or the plugin (checker/report) to install/uninstall.Show all checkers-----------------.. code-block:: shellascli show checkers------------------------------------------------------------------------------------------Show all reports----------------.. code-block:: shellascli show reports------------------------------------------------------------------------------------------Install checker---------------.. code-block:: shellascli install checkers --target path/to/file.py------------------------------------------------------------------------------------------Install report--------------.. code-block:: shellascli install reports --target path/to/file.py------------------------------------------------------------------------------------------Uninstall checker-----------------.. code-block:: shellascli uninstall checkers --target path/to/file.pyor.. code-block:: shellascli uninstall checkers --target checker_name------------------------------------------------------------------------------------------Uninstall report----------------.. code-block:: shellascli uninstall reports --target path/to/file.pyor.. code-block:: shellascli uninstall reports --target checker_name------------------------------------------------------------------------------------------Run the scan------------.. code-block:: shellascli run --target path/to/file.py --name repo_name
Package: atomstorage
This module defines a simple API for storing and retrieving Atom
entries in different storage backends. Entries are defined using a
JSON-like syntax:>>> import datetime
>>> entry = {'id'     : 'http://example.com/1',
...          'title'  : 'My first entry',
...          'updated': datetime.datetime.utcnow(),
...         }The module comes with a shelve backend:>>> from atomstorage import EntryManager
>>> em = EntryManager('shelve://file.db')
>>> em.create_entry(entry)
{'updated': datetime.datetime(2006, 8, 15, 16, 27, 7, 960677),
 'id': 'http://example.com/1',
 'title': 'My first entry'}New backends can be easily added by creating a module and setting
anatomstorage.backendentry point. A SQLite backend is currently
being developed.The API defines a few methods the entry manager should have. To
retrieve all entries, sorted by time (last to first):>>> entries = em.get_entries()The last 10 entries:>>> entries = em.get_entries(10)Retrieve the entry with id “1”:>>> entry = em.get_entry("1")Delete the same entry:>>> em.delete_entry("1")Get all entries from August 2006:>>> entries = em.get_entries_by_date(2006, 8)Or from the “tech” category:>>> entries = em.get_entries_by_category("tech")To search for entries mentioning “Python”:>>> entries = em.search("Python")The API is by no means final. Comments, suggestions, patches and
critics are welcome.
Package: atomtools
AtomToolsCollection of atom manupulation toolsnamerandStringget_atoms_nameunitunit module contains all unit transform function isncludingtrans_lengthtrans_abs_energytrans_energytrans_velocitygeogeo module contains all frequenctly used geometry functionsget_atoms_nameget_atoms_sizebasic measurementsget_distanceget_angleget_dihedralmatrix measurementsget_distance_matrixget_contact_matrixdist_change_matrixfreq_dist_change_matrixget_rotation_matrixcoordination transformationcartesian_to_zmatrixcartesian_to_sphericalspherical_to_cartesianinput_standard_pos_transformfilefile module process all file related with fileget_file_contentget_filenameget_extensionfiletypegaussian/gaussian-out/gaussian-fchk/gaussian-chkadf/adf-outPOSCAR/vasprun.xml/CONTCAR/INCAR/POTCARjsonsdfTODOS
Package: atom-torch
AtomAtom is a finetuned LLAMA to create better LLMS through Pytorch Data!InstallationYou can install the package using pipgitclonehttps://github.com/jquesnelle/yarncdAtompipinstall-e.TrainingTo train the models, runaccelerate configand enable DeepSpeed acceleration.deepspeed/zero3.jsonwas the configuration file used for training.# ./train.shThe tokenized training data is available onHugging Faceand was derived from thepg19dataset.EvaluationTo reproduce the evaluations, installlm-evaluation-harnesswithpip install git+https://github.com/EleutherAI/lm-evaluation-harnessand then run the two provided scripts.# ./eval.sh# ./eval-harness.shCitation@misc{peng2023yarn,
      title={YaRN: Efficient Context Window Extension of Large Language Models}, 
      author={Bowen Peng and Jeffrey Quesnelle and Honglu Fan and Enrico Shippole},
      year={2023},
      eprint={2309.00071},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
Package: atomvision
AtomvisionTable of ContentsIntroductionInstallationExamplesReferenceHow to contributeCorrespondenceFunding supportIntroductionAtomvision is a deep learning framework for atomistic image data.InstallationFirst create a conda environment:
Install miniconda environment fromhttps://conda.io/miniconda.htmlBased on your system requirements, you'll get a file something like 'Miniconda3-latest-XYZ'.Now,bash Miniconda3-latest-Linux-x86_64.sh (for linux)
bash Miniconda3-latest-MacOSX-x86_64.sh (for Mac)Download 32/64 bit python 3.6 miniconda exe and install (for windows)
Now, let's make a conda environment, say "version", choose other name as you like::conda create --name vision python=3.8
source activate visionNow, let's install the package:Method 1 (using setup.py):git clone https://github.com/usnistgov/atomvision.git
cd atomvision
python setup.py developMethod 2 (using pypi):As an alternate method, AtomVision can also be installed usingpipcommand as follows:pip install atomvisionExamplesGenerating STEM image with convolution approximation: graphene examplestem_conv.py --file_path atomvision/tests/POSCAR --output_path STEM.png2D-Bravais lattice classification exampleThis example shows how to classify 2D-lattice (5 Bravais classes) for 2D-materials STM/STEM images.We will use imagessample_datafolder. It was generated withgenerate_stem.pyscript. There are  two folderstrain_folder,test_folderwith sub-folders0,1,2,3,4,...for individual classes and they contain images for these classes.train_classifier_cnn.py --model densenet --train_folder atomvision/sample_data/test_folder --test_folder atomvision/sample_data/test_folder --epochs 5 --batch_size 16Generating a t-SNE  plottrain_tsne.py --data_dir atomvision/sample_data/test_folderGenerative Adversarial Networktrain_gan.py --dataset_path atomvision/sample_data/test_folder/0 --epochs 2Autoencodertrain_autoencoder.py --train_folder atomvision/sample_data/test_folder --test_folder atomvision/sample_data/test_folder --epochs 10ReferenceAtomVision: A machine vision library for atomistic imagesThe joint automated repository for various integrated simulations (JARVIS) for data-driven materials designComputational scanning tunneling microscope image databasePlease see detailed publications listhere.How to contributeFor detailed instructions, please seeContribution instructionsCorrespondencePlease report bugs as Github issues (https://github.com/usnistgov/atomvision/issues) or email tokamal.choudhary@nist.gov.Funding supportNIST-MGI (https://www.nist.gov/mgi).Code of conductPlease seeCode of conduct
Package: atomx
Interface for the atomx rest api.For more information read the fulldocumentation online,
report bugs ingithubor see theatomx wikiExample UsagefromatomximportAtomx# create atomx sessionatomx=Atomx('user@example.com','password')# get 10 creativescreatives=atomx.get('Creatives',limit=10)# the result is a list of `atomx.models.Creative` models# that you can easily inspect, manipulate and updateforcreativeincreatives:print('Creative ID:{c.id}, state:{c.state}, ''name:{c.name}, title:{c.title}'.format(c=creative))# update title for the first creative in listcreative=creatives[0]creative.title='shiny new title'# the session is inherited from `atomx` that made the get requestcreative.save()# create a new profilefromatomx.modelsimportProfileprofile=Profile(advertiser_id=23,name='test profile')# Note that you have to pass it a valid `Atomx` session for create# or use `atomx.create(profile)`profile.create(atomx)# now you could alter and update it like the creative aboveprofile.name='changed name'profile.save()# you can also get attributesprofiles=atomx.get('advertiser',88,'profiles')# equivalent is to pass the complete resource path as string instead of argumentsprofiles=atomx.get('advertiser/88/profiles')# same as above# profiles is now a list of `atomx.models.Profile` that you can# read, update, etc again.profiles[0].click_frequency_cap_per=86400profiles[0].save()# working with searchs=atomx.search('mini*')# s is now a dict with lists of search results for the different models# with the model id and namepublisher=s['publisher'][0]# get the first publisher..publisher.reload()# .. and load all the dataprint(publisher)# now all publisher data is therepublisher.history()# gets all changes made to this publisher# reporting example# get a report for a specific publisherreport=atomx.report(scope='publisher',groups=['hour'],metrics=['impressions','clicks'],where=[['publisher_id','==',42]],from_='2015-02-08 00:00:00',to='2015-02-09 00:00:00',timezone='America/Los_Angeles')# check if report is readyprint(report.is_ready)# if pandas is installed you can get the pandas dataframe with `report.pandas`# you can also get the report csv in `report.content` without pandasdf=report.pandas# A datetime index is automatically set when group by a hour/day/month.# calculate mean, median, std per hourmeans=df.resample('H',how=['mean','median','std'])# and plot impression and clicks per daymeans['impressions'].plot()means['clicks'].plot()InstallationTo install the python atomx api, simply:$pipinstallatomxor if you want to use ipython notebook and reporting functionality:$pipinstallatomx[report]
Package: atoolkitdpt
Midas modules for Ambrosinus-ToolkitThis is a Python package for the DPT component/s included in the Ambrosinus-Toolkit a Grasshopper Plugin.All credit to each author that developed these Midas scripts.I have packaged them and modified some strings of code in order to run them inside Grasshopper.Every file is under the MIT licence.More info on my GitHub page (see "Project Links") and onhttp://www.lucianoambrosini.it