Saravanan666/pypi-org huggingface dataset:
Package: reader-yaojh
Real Python Feed ReaderThe Real Python Feed Reader is a basicweb feedreader that can download the latest Real Python tutorials from theReal Python feed.For more information see the tutorialHow to Publish an Open-Source Python Package to PyPIon Real Python.InstallationYou can install the Real Python Feed Reader fromPyPI:python -m pip install realpython-readerThe reader is supported on Python 3.7 and above. Older versions of Python, including Python 2.7, are supported by version 1.0.0 of the reader.How to useThe Real Python Feed Reader is a command line application, namedrealpython. To see a list of thelatest Real Python tutorials, call the program without any arguments:$ realpython
The latest tutorials from Real Python (https://realpython.com/)
 0 How to Publish an Open-Source Python Package to PyPI
 1 Python "while" Loops (Indefinite Iteration)
 2 Writing Comments in Python (Guide)
 3 Setting Up Python for Machine Learning on Windows
 4 Python Community Interview With Michael Kennedy
 5 Practical Text Classification With Python and Keras
 6 Getting Started With Testing in Python
 7 Python, Boto3, and AWS S3: Demystified
 8 Python's range() Function (Guide)
 9 Python Community Interview With Mike Grouchy
10 How to Round Numbers in Python
11 Building and Documenting Python REST APIs With Flask and Connexion – Part 2
12 Splitting, Concatenating, and Joining Strings in Python
13 Image Segmentation Using Color Spaces in OpenCV + Python
14 Python Community Interview With Mahdi Yusuf
15 Absolute vs Relative Imports in Python
16 Top 10 Must-Watch PyCon Talks
17 Logging in Python
18 The Best Python Books
19 Conditional Statements in PythonTo read one particular tutorial, call the program with the numerical ID of the tutorial as a parameter:$ realpython 0
# How to Publish an Open-Source Python Package to PyPI

Python is famous for coming with batteries included. Sophisticated
capabilities are available in the standard library. You can find modules for
working with sockets, parsing CSV, JSON, and XML files, and working with
files and file paths.

However great the packages included with Python are, there are many
fantastic projects available outside the standard library. These are most
often hosted at the Python Packaging Index (PyPI), historically known as the
Cheese Shop. At PyPI, you can find everything from Hello World to advanced
deep learning libraries.

[... The full text of the article ...]You can also call the Real Python Feed Reader in your own Python code, by importing from thereaderpackage:>>> from reader import feed
>>> feed.get_titles()
['How to Publish an Open-Source Python Package to PyPI', ...]
Package: readfcs
readfcs: Read FCS filesLightweight Python library to load data and metadata from Flow Cytometry Standard (FCS) files intoDataFrameandAnnDataobjects.Install:$pipinstallreadfcsGet started:importreadfcsreadfcs.read()# Read FCS files into `AnnData`readfcs.ReadFCS()# Debug possible integrity issues in your FCS filesRead thedocsor read theblog post.
Package: read-genbank
read_genbankA module to read and parse the features of a genbank fileTo output a tab separated file:$ read_genbank.py tests/phiX174.gbk
'phiX174'	'CDS'	(('100', '627'),)	{'gene': 'G'}
'phiX174'	'CDS'	(('636', '1622'),)	{'gene': 'H'}
'phiX174'	'CDS'	(('1659', '3227'),)	{'gene': 'A'}
'phiX174'	'CDS'	(('2780', '3142'),)	{'gene': 'B'}
'phiX174'	'CDS'	(('3142', '3312'),)	{'gene': 'K'}
'phiX174'	'CDS'	(('3224', '3484'),)	{'gene': 'C'}
'phiX174'	'CDS'	(('3481', '3939'),)	{'gene': 'D'}
'phiX174'	'CDS'	(('3659', '3934'),)	{'gene': 'E'}
'phiX174'	'CDS'	(('3939', '4055'),)	{'gene': 'J'}
'phiX174'	'CDS'	(('4092', '5375'),)	{'gene': 'F'}To output the amino-acid translations in fasta format$ read_genbank.py tests/phiX174.gbk -f faa
>phiX174[100..627]
MLQTFISRHNSNFFSDKLVLTSVTPASSAPVLQTPKATSSTLYFDSLTVNAGNGGFLHCIQMDTSVNAANQVVSVGADIAFDADPKFFACLVRFESSSVPTTLPTAYDVYPLNGRHDGGYYTVKDCVTIDVLPRTPGNNVYVGFMVWSNFTATKCRGLVSLNQVIKEIICLQPLK
>phiX174[636..1622]
MFGAIAGGIASALAGGAMSKLFGGGQKAASGGIQGDVLATDNNTVGMGDAGIKSAIQGSNVPNPDEAAPSFVSGAMAKAGKGLLEGTLQAGTSAVSDKLLDLVGLGGKSAADKGKDTRDYLAAAFPELNAWERAGADASSAGMVDAGFENQKELTKMQLDNQKEIAEMQNETQKEIAGIQSATSRQNTKDQVYAQNEMLAYQQKESTARVASIMENTNLSKQQQVSEIMRQMLTQAQTAGQYFTNDQIKEMTRKVSAEVDLVHQQTQNQRYGSSHIGATAKDISNVVTDAASGVVDIFHGIDKAVADTWNNFWKDGKADGIGSNLSRK
>phiX174[1659..3227]
MPPNLGGFFMVRSYYPSECHADYFDFERIEALKPAIEACGISTLSQSPMLGFHKQMDNRIKLLEEILSFRMQGVEFDNGDMYVDGHKAASDVRDEFVSVTEKLMDELAQCYNVLPQLDINNTIDHRPEGDEKWFLENEKTVTQFCRKLAAERPLKDIRDEYNYPKKKGIKDECSRLLEASTMKSRRGFAIQRLMNAMRQAHADGWFIVFDTLTLADDRLEAFYDNPNALRDYFRDIGRMVLAAEGRKANDSHADCYQYFCVPEYGTANGRLHFHAVHFMRTLPTGSVDPNFGRRVRNRRQLNSLQNTWPYGYSMPIAVRYTQDAFSRSGWLWPVDAKGEPLKATSYMAVGFYVAKYVNKKSDMDLAAKGLGAKEWNNSLKTKLSLLPKKLFRIRMSRNFGMKMLTMTNLSTECLIQLTKLGYDATPFNQILKQNAKREMRLRLGKVTVADVLAAQPVTTNLLKFMRASIKMIGVSNLQSFIASMTQKLTLSDISDESKNYLDKAGITTACLRIKSKWTAGGK
>phiX174[2780..3142]
MEQLTKNQAVATSQEAVQNQNEPQLRDENAHNDKSVHGVLNPTYQAGLRRDAVQPDIEAERKKRDEIEAGKSYCSRRFGGATCDDKSAQIYARFDKNDWRIQPAEFYRFHDAEVNTFGYF
>phiX174[3142..3312]
MSRKIILIKQELLLLVYELNRSGLLAENEKIRPILAQLEKLLLCDLSPSTNDSVKN
>phiX174[3224..3484]
MRKFDLSLRSSRSSYFATFRHQLTILSKTDALDEEKWLNMLGTFVKDWFRYESHFVHGRDSLVDILKERGLLSESDAVQPLIGKKS
>phiX174[3481..3939]
MSQVTEQSVRFQTALASIKLIQASAVLDLTEDDFDFLTSNKVWIATDRSRARRCVEACVYGTLDFVGYPRFPAPVEFIAAVIAYYVHPVNIQTACLIMEGAEFTENIINGVERPVKAAELFAFTLRVRAGNTDVLTDAEENVRQKLRAEGVM
>phiX174[3659..3934]
MVRWTLWDTLAFLLLLSLLLPSLLIMFIPSTFKRPVSSWKALNLRKTLLMASSVRLKPLNCSRLPCVYAQETLTFLLTQKKTCVKNYVRKE
>phiX174[3939..4055]
MSKGKKRSGARPGRPQPLRGTKGKRKGARLWYVGGQQF
>phiX174[4092..5375]
MSNIQTGAERMPHDLSHLGFLAGQIGRLITISTTPVIAGDSFEMDAVGALRLSPLRRGLAIDSTVDIFTFYVPHRHVYGEQWIKFMKDGVNATPLPTVNTTGYIDHAAFLGTINPDTNKIPKHLFQGYLNIYNNYFKAPWMPDRTEANPNELNQDDARYGFRCCHLKNIWTAPLPPETELSRQMTTSTTSIDIMGLQAAYANLHTDQERDYFMQRYHDVISSFGGKTSYDADNRPLLVMRSNLWASGYDVDGTDQTSLGQFSGRVQQTYKHSVPRFFVPEHGTMFTLALVRFPPTATKEIQYLNAKGALTYTDIAGDPVLYGNLPPREISMKDVFRSGDSSKKFKIAEGQWYRYAPSYVSPAYHLLEGFPFIQEPPSGDLQERVLIRHHDYDQCFQSVQLLQWNSQVKFNVTVYRNLPTTRDSIMTS
Package: readgv
ReadGVPython Script to read, edit, modify and visualize and file conversion for VASP and  Gaussian input and output!This is actively developing version. Current version is very first trial.Installationpip install -e git+git://github.com/MAJabed/ReadGV.gitWith pippip install -e ReadGV/[No available yet]Running VaspUtilspythonpython-mvasputils[-job][vasp2gaus/gaus2poscar/read_bands**][--fileinputfile][--foutoutputfile][--ftypexyz/gaus(gaussianinputfile)][--selectboolean][--directboolean]-joboption to select task to execute, currently available taskvasp2gaus: Convert poscar or Contcar file to xyz or gaussian input file formatgaus2poscar: Convert gaussian input file to VASP POSCAR file format. Periodic cell (Tv) should be given in the .com file.read_bands: Read selected or all bands from OUTCAR and write in a file, print or plot (follow--plot)get_geom: Write or print molecular dynamic trajectory from the OUTCAR filesabs_gaus: Read Gaussian TDDFT output file, Dress excited energies using Gaussian fucntion to plot absorption spectra--file: The input file name--fout: The output file name--ftype:  Output file format,xyzorgaus(gaussian input file)--select:Boolean, select coordinates in POSCAR file--direct:Boolean, direct or cartesian coordinates in POSCAR file format--bands: No of bands to read, default 100--frames: MD frames to read,  last framefinal, initial frameinitial, allall, last n frames-n, first n framen--nthkpoint: integar, read outcar data of nth Kpoints--coord: output coordinates in Cartesiancartor fractionalfrac--plot: Plot output of-job, special arguments:dos_allto plot DOS of all frames in waterfall graphs (This function may not produce the best figure in come cases)--shiftfermi: Band energies shift by Fermi energy--xlim: X-axis limit, input type: list -lower upper--sigma: float, linewidth for Gaussian dressing, default 0.1 eV--theta: Rotation of X-axis for 3D view of waterfall graph, degree unit.--gamma: Rotation of Z axis for 3D view of waterfall graph, degree unit.--alpha: Adjust the transparency of a matplotlib graph plot[0-1]--unit: Unit of a calculation, eg.eVornmin absorption spectra calculations--figsize: Matplotlib graph figure size, default(7,5)Disclaimer:It is an incomplete package, still under development.License:ReadGV is freely available under anMITLicense
Package: read-hnd
# Module read_hndFor interacting with HND file typesTo set it up, you just install it as any other module:pip install –user read_hndThis should fix any dependency issues and hopefully work without too much issue.### Module use:
To run the code there are a few options:Convert all the HND images in that folder and save then in a Processed subfolderpython -m read_hnd -f C:pathtofolderRead and display the imagepython -m read_hnd -i C:pathtoimage.hnd -p=1Save the imagepython -m read_hnd -i C:pathtoimage.hnd -o C:pathtosave.tiffAlso save the metadatapython -m read_hnd -i C:pathtoimage.hnd -o C:pathtosave.tiff -m C:pathtomeatadata.txt### Use in python code:`python from read_hnd import read_hnd                                   # Load module fp = read_hnd.HndReader(inputfile)                              # Create object to interact with file fp.headerData()                                                                 # Read the header fp.pixelData()                                                                  # Read pixel data (must read header first) matplotlib.plot.imshow(fp.uncompressedImage)    # Show the image using matplotlib plt.show() `This is very much still a work in progress, so there may be bugs. For example, the metadata doesn’t seem to read correctly (i.e., you get some non-sensical values)
Package: readi
readi CollectionsDead simple class registration.Often I find myself trying to implement generic class representations and then extending them to provide many different functional variants. I then want to be able to access those variants in a simple, automatic way, without having to write "switch-case" type class selection strategies.This allows you to register classes at instantiation time and have them accessible using a simple dict interface, with some nice helper methods :)InstallpipinstallreadiUsage# __init__.pyimportreadi# this is just a dictionary with some fancy bitscollection=readi.Collection(entrypoints='myentrypoint')# setup.py# this can allow other modules to register classes.setuptools.setup(...entry_points={'myentrypoint':['C = module.for.thisclass:SomeClass']})# myclasses.py# then just use it in your classfrom.importcollection@collection.registerclassA:passclassB:passclassB1(B):passclassB2(B):passcollection.register_subclasses(B,include=True)# they're all available in the collection dictionary.assertset(collection)=={'a','b','b1','b2','c'}classD(B1):# works for nested subclassespasscollection.refresh_subclasses()# can gather new subclassesassertset(collection)=={'a','b','b1','b2','c','d'}# __main__.py# now to see how they're used.from.importcollectiondefmain(**kw):processors=collection.gather(**kw)fordataindata_generator():forfuncinprocessors:# assuming we defined __call__func(data)main(fs=48000,channels=4,b1=False,b2=dict(nfft=2048))Doing this will result in a processor list that looks like this:processors=[A(fs=48000,channels=4),B(fs=48000,channels=4),# B1 is omitted since it was set as FalseB2(fs=48000,channels=4,nfft=2048),C(fs=48000,channels=4),D(fs=48000,channels=4),]This is used if you have a bank of processors that you want to run and you want them to be enabled/disabled using keyword arguments.Another use case is: you only need to select a single registered class. This is done very simply:# __main__.py# now to see how they're used.from.importcollectiondefmain(proc_type='b',**kw):processor=collection.getone(proc_type,**kw)fordataindata_generator():processor(data)main(fs=48000,channels=4,proc_type='b2')NotesThere is nothing stopping you from adding things that return non function values (i.e. lists).@collection.registerdefreds(saturation=92):c='#FF0000'return[c]+calculate_colors(c,saturation)@collection.registerdefblues(saturation=92):c='#0000FF'return[c]+calculate_colors(c,saturation)@collection.registerdefgreens(saturation=92):c='#00FF00'return[c]+calculate_colors(c,saturation)colors=collection.gather(saturation=120,greens=False)# colors = [#     ['#FF0000', ...], # reds#     ['#0000FF', ...], # blues# ]TODO
Package: readify
ReadifyConvert Integer to Human Readable formatDemoDemo onRepl.itInstall$ pip install readifyUsagefromreadifyimportreadifyprint(readify(1545451548515484))#=> 1545.5Tprint(readify(736572365,5))#=> 736.57236MAPIreadify(input)Type:numberreadify(input, fraction_point)Type:numberandnumberNumber to humanize.
Fraction PointLicenseMITYoginth
Package: readii
READIIRadiomicExtraction andAnalysis forDICOMImagesA package to extract radiomic features from DICOM CT images.Installation$pipinstallreadii(recommended) Create new conda virtual environmentconda create -n readii python=3.9
conda activate readii
pip install readiiUsagereadiiis a tool to perform radiomic feature extraction on DICOM CT images with region of interest (ROI) segmentations as either DICOM SEG or RTSTRUCT.$readii[INPUTDIRECTORY][OUTPUTDIRECTORY]\--roi_names[str]\--pyradiomics_setting[str]\--negative_controls[str:randomized_full,randomized_roi,randomized_non_roi,shuffled_full,shuffled_roi,shuffled_non_roi]\--parallel[flag]--update[flag]ContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licensereadiiwas created by Katy Scott. It is licensed under the terms of the MIT license.Creditsreadiiwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: readimc
readimcPython package for reading imaging mass cytometry (IMC) filesDocumentation is available athttps://bodenmillergroup.github.io/readimcCitationPlease cite the following paper when usingreadimcin your work:Windhager, J., Zanotelli, V.R.T., Schulz, D. et al. An end-to-end workflow for multiplexed image processing and analysis. Nat Protoc (2023).https://doi.org/10.1038/s41596-023-00881-0@article{Windhager2023,
    author = {Windhager, Jonas and Zanotelli, Vito R.T. and Schulz, Daniel and Meyer, Lasse and Daniel, Michelle and Bodenmiller, Bernd and Eling, Nils},
    title = {An end-to-end workflow for multiplexed image processing and analysis},
    year = {2023},
    doi = {10.1038/s41596-023-00881-0},
    URL = {https://www.nature.com/articles/s41596-023-00881-0},
    journal = {Nature Protocols}
}
Package: reading-parquet-file
READ PARQUET FILES FROM AZURE BLOB STORAGE/ AZURE DATALAKE GEN 2PARAMETERSaccount_name: name of the storage account
container: storage blob container name
fname: file name/ file path inside the container
credentials: Account key for the storage account. Can also use DefaultAzureCredential if identity is enabledOUTPUT:Returns a pandas dataframe with all the file contents
Package: readin-ucinet
readin_ucinetRead in UCINET text files as pandas DataFrameAvailable at:https://pypi.org/project/readin-ucinet/Prerequisites:Requires pandas installationhttps://pandas.pydata.org/pandas-docs/stable/getting_started/install.html?highlight=installExample Usage:import readin_ucinet as rusocial_graph = ru.read_ucinet("ENTER_FILEPATH_HERE")Returns: pandas DataFrame or TextParserA comma-separated values (csv) file is returned as two-dimensional data structure with labeled axes.
Package: readit
Readit - Command Line ToolIntroductionReadit is command line bookmark manager. It is a command line utility to add, delete, update and display the bookmarks. It is a powerful bookmark manager written in Python. It uses SQLite3 database to store the bookmarks.FeaturesBookmark multiple URLs at a timeBookmark URL with respective TagsSearch and display Bookmarks by TAG and URL’s substringDisplay all Bookmarks in table formatRemove a Bookmarked URLRemove all Bookmarked URLsUpdate a Bookmarked URL with a specific IDURL validationOpen URL in the browserExport bookmarks into the CSV fileShow all Tags available in the databaseBookmark URLs either online or offlineDependenciesFeaturesDependancyScripting LanguagePython 3.0+HTTP(S)requestsCommand-LineOption and argument parsingclickDatabase UsedSQLite3Display Bookmarks in TablebeautifultableInstallationreadit is available on PyPI and can be installed with pip3:pip3install--userreaditCommand line optionsUsage:readit[OPTIONS][INSERT]...Readit-Command-linebookmarkmanagertool.Options:-a,--addTEXT...AddURLswithspace-separated-t,--tagTEXT...AddTagwithspace-separatedURL-d,--deleteTEXTRemoveaURLofparticularID-c,--clearTEXT...Clearbookmarks-u,--updateTEXT...UpdateaURLforspecificID-s,--searchTEXTSearchallbookmarksbyTagandURL's substring
-v, --view TEXT...      Show bookmarks
-o, --openurl TEXT      Open URL in Browser using id, tag or URL'ssubstring-V,--versionChecklatestversion-e,--exportTEXT...ExportURLsincsvfile-tl,--taglistTEXT...ShowallTags--helpShowthismessageandexit.ExamplesBookmarkmultiple URLs:$readiturl1url2...or$readit--addurl1url2...or$readit-aurl1url2...Viewall available bookmarks:$readit-vor$readit--viewUpdatea bookmark using its ID:$readit-uurl_idurlor$readit--updateurl_idurlDeletea bookmarked URL using its ID:$readit-durl_idor$readit--deleteurl_idClearall the bookmarks:$readit-cor$readit--clearBookmarkURL along with TAG:$readit-ttag_nameurlor$readit--tagtag_nameurlSearchandDisplayall bookmarks using the TAG or URL’s substring:$readit-stag_nameor$readit--searchtag_nameor$readit-surl_substringOpen URL in the Browser using specific ID, TAG or URL’s substring:$readit-ourlidor$readit--openurlurlidor$readit-ourl_substringor$readit-otagExportbookmarks into the CSV file:$readit--exportor$readit-eShow all Tags available in the database$readit-tlor$readit--taglistHow to install source code for developmentClone project from github:$gitclonehttps://github.com/projectreadit/readit.gitWe recommend to create and activate a virtualenv first:$cdreadit/$python3-mvenvenv$sourceenv/bin/activate(env)$To install using setup.py file:(env)$pythonsetup.pyinstallTo make a build of the project:(env)$pythonsetup.pybuildLicenceReadit - Command line tool is licensed underGNU General Public License v3.0.
Package: readkeys
readkeysPython library to read from stdin a single char, keypress (with escape sequences) or line.Originally a fork ofmagmax/python-readchar, it was rewritten to fix some bugs and better support UNIX and Windows systems.Usageimportreadkeysch=readkeys.getch()# get a single characterkey=readkeys.getkey()# get a single keypressline=readkeys.getline()# get a line of textline2=readkeys.getline(raw=False)# Get a line of text and print out characters as they are typed, similar to built-in input.flush=readkeys.flush()# flush stdinFunctionsgetchThegetchfunction reads a single character byte from stdin. The buffer is not flushed after read.The function has the following type signature:getch(NONBLOCK: bool = False, encoding: str = None, raw: bool = True) -> strNONBLOCK: booluse non-blocking mode when reading from stdin, defaults to False. The library may encounter unforeseen errors if set toTrue.encoding: strspecify an encoding (e.g. utf-8) to be used to decode bytes from the stdin buffer. If unspecified it assumes characters can be directly extracted from stdin.raw: boolput tty terminal in raw mode before reading, seetty.setraw. If set toFalsethe characters will still appear in the terminal as they are typed. Settings before changing to raw mode are saved and restored when the read operation is complete.The option is ignored on Windows systems as they use a completely different terminal environment and a different library is necessary to read character from stdin:msvcrt.getkeyThegetkeyfunction reads a single keypress from stdin, including escape sequences of function keys. For example arrow keys are returned with their full escape sequence, without leaving anything in the buffer (0x1b5b41,0x1b5b42,0x1b5b43or0x1b5b44).The function has the following type signature:getch(getch_fn: Callable[[], str] = None, encoding: str = "", raw: bool = True) -> strgetch_fn: Callable[[], str]if passed, use the this function instead of the built-ingetchto read the single bytes from stdin. The library may encounter unforeseen errors if this option is used.encoding: strspecify an encoding (e.g. utf-8) to be used to decode bytes from the stdin buffer. Seegetch.raw: boolput tty terminal in raw mode before reading. Seegetch.getlineThegetlinefunction reads a full line of characters from stdin, including non-standard keys (e.g. arrow keys). It defaults to raw mode, leaving characters unprinted on screen.The function has the following type signature:(getch_fn: Optional[Callable[[], str]] = None, encoding: str = None, raw: bool = True) -> strgetch_fn: Callable[[], str]if passed, use the this function instead of the built-ingetchto read the single bytes from stdin. The library may encounter unforeseen errors if this option is used.encoding: strspecify an encoding (e.g. utf-8) to be used to decode bytes from the stdin buffer. Seegetch.raw: boolput tty terminal in raw mode before reading. Seegetch.flushTheflushfunction removes any leftover byte from stdin and returns them as a string. It is useful to clear the buffer from any remaining bytes after doing a single read withgetch.The function has the following type signature:flush() -> str
Package: readlammpsdata
readlammpsdataA script for reading and modifying LAMMPS dataInstall# install from githubgitclonegit@github.com:eastsheng/readlammpsdata.gitcdreadlammpsdata
pipinstall.# install from pypipipinstallreadlammpsdataUsagesimportreadlammpsdataasrld# 0. read Atoms, Masses etc.Atoms=rld.read_data(lmp,data_sub_str="Atoms # full")Masses=rld.read_data(lmp,data_sub_str="Masses")PairCoeffs=rld.read_data(lmp,data_sub_str="Pair Coeffs")Bonds=rld.read_data(lmp,data_sub_str="Bonds")# 1. read box sizexyz=rld.read_box(lmp)Lx=xyz["xhi"]-xyz["xlo"]print(xyz)print(Lx)# 2. read atomic numberNatoms=rld.read_atom_info(lmp,"atoms")print("Number of atoms is%s"%Natoms)# 3. read chargescharges=rld.read_charges(lmp)print("Charges of atoms are%s"%charges)print(round(sum(charges),6))# 4. ......print(help(rld))# for read all functionsFixes2023-11-24Fixed bugs ofaddH2023-11-22Added thechange_lmp_axisfunctionAdded thecoord2zerofunctionAdded theaddHfunctionAdded thecut_lmp_atomsfunction2023-10-21Added theexchange_positionfunction2023-10-20Added  thechange_type_orderfunctionAdded thecombine_lmpfunctionAdded thecut_lmpfunction2023-10-17Added themove_boundaryfunction;Added thedensityfunction;2023-10-16Added themodify_methane_hydratefunction;Added  themodify_headerfunction;Added theadd_atomsfunction;Added thearray2strfunction;2023-10-12Added thesort_lmpfunction;Added  thelmp2xyzfunction;Added themsi2clayfffunction;Added thelmp2tip4pfunction;2023-10-08Added thepdb2xyzfunction;Added theread_formulafunction;Added themodify_posfunction;Added themodify_pore_sizefunction;2023-09-23Replaced theread_Natomsto theread_atom_infofunction;Added theread_volfunction;Added theread_xyzfunction;Added theread_pdbfunction;2023-09-22Added theread_termsfunction for reading complex LAMMPS data;2023-09-11Addedread_boxfunction;Addedread_Natomsfunction;Addedread_chargesfunction;
Package: readlargefile
Large text file reader.usage:from readlargefile.line_reader import LineReader

with LineReader(file_name, max_line, sep) as reader:
    # line is <class 'bytes'>
    for line in reader:
        if line:
            print(line)
        elif line == b'':
            print('empty line.')
        else:
            # line == None
            print('line is too long.')