Saravanan666/pypi-org huggingface dataset:
Package: parler-api
Parler API interface for PythonThisUNOFFICIALlibrary designed to programatically fetch data from parler.comIMPORTANT ANNOUNCEMENT:This library supports the new (as of 2022-02-06) Parleropen-api/ logged-in endpoints. Both logged in and guest modes are supported.Show is back on!Now this library supports theeven newer(as of 2022-10-21) Parler/v0/and/v0/publicendpoints. Same caveats, both logged in and guest modes are supportedTo do list:Implement unfinished authed functionsRework experimentsHave a github action (several!) to archive posts, run analysises, etc..Testing, testingPublish to pypiAuthentication:There are two modes of using the API.AuthenticatedandGuest.Authentication is done by initializing theParlerclass, importingParler.with_authand initializing anAuthSessionwith your credentials.fromParlerimportwith_authasauthedau=authed.AuthSession(debug=False)au.is_logged_in# ==> Falseau.login(identifier=os.getenv("email"),password=os.getenv("password"))au.is_logged_in# ==> TrueHere is a chart of how the functions are "loginwalled" or not.FunctionDescriptionAPI Type needed.profile()Get information from a specified usernameGuest.discover_feed()Get discovery feed from initial page (kinda like suggested posts for first time users)Guest.user_feed()Get Parleys and echoes from a specified usernameGuest.trending()Get trending posts (today / top)Guest.feed()Get feedAuthenticated.users()Search for usersAuthenticated.hashtags()Search for hashtagsAuthenticated.following()Get following profiles from specified usernameAuthenticated.comments()Get comments from a specified post IDAuthenticated.follow_user()Follow a specified usernameAuthenticatedInstallationFrom pypi:pip install parler-apiClone and run locally:If usingpipenv:pipenv install
pipenv shellIf usingpip:pip install -r requirements.txtExperiments:Collected the suggested hashtags for a 9 hour period,data hereOther experiments available as well.Contributing:Feel free to improve the code, submit your experiments and sample code or fix bugs. Before submitting a PR, runpep8linter on your code.Donate:If you found this package useful,consider donating.Disclaimer:I am in now way affiliated with Parler, it's subsidiaries or any entity related to the company. I am not responsible for what you do with this Python package.2009/24/EC Art 5:The person having a right to use a copy of a computer program shall be entitled, without the authorisation of the rightholder, to observe, study or test the functioning of the program in order to determine the ideas and principles which underlie any element of the program if he does so while performing any of the acts of loading, displaying, running, transmitting or storing the program which he is entitled to do.
Package: parley
PARLEY is a library for writing Python programs that implement theActor modelof
distributed systems, in which lightweight concurrent processes
communicate through asynchronous message-passing. Actor systems
typically are easier to write and debug than traditional concurrent
programs that use locks and shared memory.PARLEY can run using either traditional native threads,greenlets(lightweight threads),
orStackless Python’s tasklets. A program
written using PARLEY can choose between these models by changing a
single line of code.
Package: parliament-functions
ParliamentParliament is a framework for invoking functions over HTTP. It
handles routing, liveness and readiness endpoints, and CloudEvent
extraction.Function developers write functions that take a dictionary as the
single parameter. There is arequestobject in the dictionary
that is the Flaskrequestobject. If the incoming request is a POST of a CloudEvent, the event will be extracted and provided as acloud_event` object in the dictionary.
Package: parm
Author:Limodou <limodou@gmail.com>About ParmParm can be used to convert markdown files to  html pages. It’ll use par module
to parse markdown.The features are:Topic content page supportBootstrap theme(2.1.1 css framework based)Semantic-UI themeRequirementparhttps://github.com/limodou/parInstallationpip install parmUsageparm --help
parm --version
parm init
parm make [-d directory]
parm rst2mdLicenseParm is released under BSD license.
Package: parma
Multivariate Hermite spline interpolationFree software: MIT licenseInstallationpip install parmaYou can also install the in-development version with:pip install https://github.com/dougmvieira/parma/archive/master.zipDocumentationhttps://parma.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2019-07-30)First release on PyPI.
Package: parmesan
🧀 PARMESANPythonAtmosphericResearch program forMEteorologicalScientificANalysisWhat canPARMESANdo?PARMESAN is targeted at meteorologists/scientists doing atmospheric measurements who want to analyse their obtained time series, calculate typical temperature, wind, humidity, atmospheric stability and turbulence parameters.
PARMESAN provides basic building blocks for typical meteorological calculations and can be easily expanded as equations are based on symbolic mathematics that can be recombined and repurposed.🔢 Physical Calculations📉 calculatingpower spectraof timeseries📉 calculatingstructure functionsof timeseries⏱ calculatingtemporal cycles(e.g. diurnal/daily cycles)🌫 calculating severalhumiditymeasures🌡 calculating severaltemperaturemeasures📜 handlingphysical unitsand checkingbounds🍃windcalculationscalculations💨turbulence parameters🔢 based on reusableSymPysymbolic mathematics❓ Why notmetpy?Whilemetpyprovides much functionality to handle spatial weather data, it is less focused on timeseries/turbulence analysis such as spectral analysis. Seeherefor a more detailed comparison.🛠️ Inner WorkingsPARMESAN uses...SymPyto do the math. PARMESAN derives meteorlogical equations with it and auto-generates Python functions and documentation based SymPy expressions.pintto handle physical units.pint-pandasto enable handle units inpandas-DataFrames.numpyandscipyfor the numericsrichfor pretty terminal output like progress barsmatplotlibfor plotting📦 InstallationTagged versions ofPARMESANare availableon PyPi.
You can install the latest tagged version ofPARMESANvia# make sure you have pip installed# Debian/Ubuntu:  sudo apt update && sudo apt install python3-pip# Manjaro/Arch:  sudo pacman -Syu python-pip# (optional) Then it's good practice to generate a virtual environment:python3-mvenvparmesan-venvsourceparmesan-venv/bin/activate# Then install PARMESANpython3-mpipinstall-UparmesanTo install the latest development version ofPARMESANdirectly from GitLab, run# make sure to have pip installed, see abovepython3-mpipinstall-Ugit+https://gitlab.com/tue-umphy/software/parmesanYou may also useour workgroup Arch/Manjaro repositoryand install thepython-parmesanpackage with your favourite software installer, for example withpacman:sudopacman-Syupython-parmesan📖 DocumentationDocumentation can be foundhere on GitLab.If you have a question or a problem with PARMESAN, you mayopen an issue on GitLab.➕ Contributing to PARMESANIf you'd like to contribute to PARMESAN, e.g. by adding new features or fixing bugs or just to run the test suite or generate the documentation locally, read theCONTRIBUTING.md-file.
Package: parmoo
ParMOO is a Python library for solving parallel multiobjective simulation
optimization problems.ParMOO uses response surface methodology (surrogate modeling) and is
flexible enough to allow users to specify their own search techniques,
surrogates, optimization solvers, and multiobjective acquisition functions.ParMOO also seeks to exploit structure in simulation optimization problems,
by modeling simulations separately from surrogates.ParMOO is distributed under a BSD 3-clause license.
Package: parole
paroleVery simply CLI password generator. This has probably been done a trillion times
already. However, here's the one I occasionally use.What it doesGenerates a password by invokingparoleand copies it to the clipboard (if
supported on your system).InstallationInstall via pypi:pipinstallparole--upgradeSimply install from Github itself via:pipinstall"git+ssh://git@github.com/merschformann/parole.git"--upgradeUsageGenerate and copy a password with default characteristics via:paroleGenerate, copyand displaya password (make sure you're the only reader):parole-sDisplay help:parole--helpGet a password of specific length and alphabet via:parole--alphabet"a!"--uppercase--digits--length10Resulting alphabet of this example isaABCDEFGHIJKLMNOPQERSTUVWXYZ1234567890!.
This is the result of combining the explicitly given symbols 'a' & '!', all
uppercase latin letters [A-Z] and all digits [0-9].Copy to clipboardThe generator usespyperclipfor copying the password to the clipboard. The
authors ofpyperclipdid great work of supporting multiple platforms. However,
if you run into problems, please consult the docs of the package:https://pypi.org/project/pyperclip/On Linux a package to support terminal copy to clipboard is needed. I usually
installxsel, e.g.:sudoaptinstallxselWhy?I use it for quickly generating a password while on the terminal (potentially
using a custom alphabet). Furthermore, for myself it was a similar effort as
googling a reliable and somewhat cryptographically secure solution. I am no
expert on the latter, but I trust the authors of thesecretsmodule (seehttps://docs.python.org/3/library/secrets.html#module-secrets).
Package: paropy
paropyWelcome! Here is my Python package to process data from PARODY-JA4.3 dynamo simulations with a stably-stratified F-layer at the base of the outer core.Getting StartedPrerequisitesPython3SHTnsChaosMagPyInstallingConda:conda install -c jnywong paropyPip:pip install paropyGit:Find the Git repohere.Warning: IPython issuePlease note that ipython may not be compatible with jedi release 0.18.0. Please revert to version 0.17.2 for auto-complete features to work (seehere).Package structureparopy/
  docs/
  paropy/
    __init__.py
    data_utils.py
    plot_utils.py
    routines.py
    scripts/
      convective_power.py
      diagnostics.py
      diagnostic_parameters.py
      filter_surface_field.py
      latitude_vs_Br.py
      latitude_vs_Br_with_CHAOS.py
      meridional_snapshot.py
      meridional_timeavg.py
      rotation_rate.py
      surface_snapshot.py
      surface_timeavg.py
    data/
      CHAOS-7.7.mat
  LICENSE.md
  MANIFEST.in
  README.md
  setup.pyExamplesDiagnosticsExample scripts can be found within the moduleparopy.Openparopy/scripts/diagnostics.pySet path to simulation data by settingrun_ID = <run_ID> # PARODY simulation tag
directory = <path_to_data>
saveDir = <path_to_savefigs>Runparopy/scripts/diagnostics.pyAdmire the output:Meridional snapshotsOpenparopy/scripts/meridional_snapshot.pySet path to simulation data and snapshot time by settingrun_ID, timestamp = 'c-200a', '16.84707134'
directory = <path_to_data>Runparopy/scripts/meridional_snapshot.pyAdmire the output:Surface snapshotsOpenparopy/scripts/surface_snapshot.pySet path to simulation data and snapshot time by settingrun_ID, timestamp = 'c-200a', '16.84707134'
directory = <path_to_data>Runparopy/scripts/surface_snapshot.pyAdmire the output:LinksPyPIAnaconda CloudDataCHAOS-7.7(Finlay et al. 2020)AuthorsJenny Wong-Institut de Physique du Globe de Paris - Institut des Sciences de la TerreLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgmentsDel Duca FoundationERC SEIC:tada:
Package: parpar
AboutParPar (Parallel Parser) is a light tool which makes it easy to distribute a function across a large file.ParPar is meant to work on serialized data where some values are highly repeated across records for a given field. e.g.a 1 1
a 1 2
a 2 3
a 2 4
a 3 5
a 3 6
b 1 7
b 1 8
b 2 9
b 2 10
b 3 11
b 3 12although we have 12 records, for column 1 there are only 2 unique values. Likewise, for column 2 there are only 3 unique values. We could break this file up into smaller files under a directory:<out-dir>/<col-1-value>/<col-2-value>or vis versa.How to use.Start by importing the ParPar class:fromparparimportParParInitialize an instance:ppf=ParPar()Shard a large file into sub-files:# shard by columnsppf.shard(<input-file>,<output-directory>,<columns>,<delim>,<newline>)# shard by linesppf.shard_by_lines(<input-file>,<output-directory>,<number_of_lines>,<delim>,<newline>)Check to make sure the number of records are the same:files=ppf.shard_files(<output-directory>)records=ppf.sharded_records(files)fromparpar.utilsimportfilelinesprint(records==filelines(<input-file>))Map an arbitrary function across eachlineof all shared files:deffoo(line,*args,**kwargs):passargs=[1,2,3]kwargs={'a':'x','b':'y'}ppf.shard_line_apply(<output-directory>,foo,args,kwargs,processes=<number-of-processes>)Map an arbitrary function across all shared files:defbar(file,*args,**kwargs):passargs=[1,2,3]kwargs={'a':'x','b':'y'}ppf.shard_file_apply(<output-directory>,bar,args,kwargs,processes=<number-of-processes>)
Package: parping
Simple parallel ipv4 ping library / cli utility.Cli accepts ip range input, e.g. 10.10.10.1-255, and returns 2 lists, responding and non-responding ipsThis originated from need to quick-check many IPs after disaster-recovery excercises.
intended to be moldable, and propably offers most of its value as an example of
using python lists in unusual ways :)Sample usage scanning 192.168.0.1/30:Python 3.9.6 (default, Nov 10 2023, 13:38:27) 
[Clang 15.0.0 (clang-1500.1.0.2.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import parping
>>> p = parping.Parping()
>>> p.parping_range('192.168.0.1','30')
parsing 192.168.0.1/30
prepinging 192.168.0.0
Darwin/MacOS detected..
Adding 192.168.0.0 to iplist..
prepinging 192.168.0.1
Darwin/MacOS detected..
Adding 192.168.0.1 to iplist..
prepinging 192.168.0.2
Darwin/MacOS detected..
Adding 192.168.0.2 to iplist..
prepinging 192.168.0.3
Darwin/MacOS detected..
Adding 192.168.0.3 to iplist..
192.168.0.1 active
192.168.0.0 returned error
192.168.0.3 returned error
192.168.0.2 returned error

Summary:
1 responding IPs.
3 non-responding IPs
(1, 3)
>>>
Package: parq
DescriptionThis package implements a queue that distributes jobs over multiple processes.LicenseThe code is distributed under the terms of theBSD 3-Clause license(seeLICENSE), and the documentation is distributed under the terms of theCreative Commons BY-SA 4.0 license.Usageimportparq# Define a job that prints its input argument.defmy_job(n):print(f'Running job #{n}')# Define the input argument for each job.job_inputs=[(i,)foriinrange(10)]# Run these 10 jobs using 4 processes.success=parq.run(my_job,job_inputs,n_proc=4)assertsuccessSee theonline documentationfor further details.InstallationTo install the latest release:pip install parqTo install the latest development version, clone this repository and run:pip install .
Package: parqet
parqet-pythonAn inoffical package to communicate with theParqetAPI.Key Features•How To Use•Download•Credits•Related•LicenseKey FeaturesThe parqet-python package will use theParqetAPI to gather information about public Portfolios. Available information includes:Portfolio namePortfolio valueGain gross / netTotal investedList of activities and holdingsand many more...How To UseInstallationInstall the package via pip. This will also install the dependency loguru for logging purposes.# Install the package$pipinstallparqetUsageCreate aPortfolioobject and get the name of the portfolio.# Import the packagefromparqetimportportfolio# Create a portfolio objectportfolio=Portfolio("YOUR_PORTFOLIO_ID")# Extract the portfolio name and print itprint(portfolio.get_name())NoteYour portfolio has to be set to public to access it via the API.Full list of functionsFunction NameDescriptionReturn TypeExampleget_name()Returns the name of the portfolio.strportfolio.get_name()returns"My Portfolio"get_value()Returns the current value of the portfolio.floatportfolio.get_value()returns6000.0get_total_gain_gross()Returns the total gross gain of the portfolio.floatportfolio.get_total_gain_gross()returns1000.0get_total_invested()Returns the total amount invested in the portfolio.floatportfolio.get_total_invested()returns5000.0get_total_gain_net()Returns the total net gain of the portfolio.floatportfolio.get_total_gain_net()returns800.0get_total_return_gross()Returns the total gross return of the portfolio.floatportfolio.get_total_return_gross()returns20.0get_total_return_net()Returns the total net return of the portfolio.floatportfolio.get_total_return_net()returns16.0get_fees()Returns the total fees paid for the portfolio.floatportfolio.get_fees()returns50.0get_created_at()Returns the date of the portfolio's creation.strportfolio.get_created_at()returns"2023-05-25T20:45:04.802Z"get_holdings()Returns a list of holdings in the portfolio.listportfolio.get_holdings()returns[{...}]get_activities()Returns a list of activities of the holdings in the portfolio.listportfolio.get_activities()returns[{...}]DownloadIf you don't want to install the package via pip, you can insteaddownloadthe latest release of the sourcecode.CreditsThis software usesLogurufor logging.LicenseGPLGitHub@JoghurtConnaisseur·
Package: parq-inspector
ParqInspectorParqInspector is a Parquet- and Deltatable viewer for your terminal, built withTextual.ParqInspector can open local or remote Parquet files and delta-tables and lets you view their contents in a table format.https://github.com/jkausti/parq-inspector/assets/19781820/7ef7657a-0598-4d3e-bab8-3faa8032ff70👉 InstallationParqInspector can be installed with pip (or pipx).$pipinstallparq-inspector👉 UsageYou start ParqInspector simply by runninginspectorfrom your terminal.Local FilesYou can also instantly open alocal fileby using the options--filepathand--row_limit, or their short versions-fand-rl.$inspector--filepath./data/my_data.parquet--row_limit500If row limit is not provided, it will get the default value of 200. Be careful, setting the
row limit to a very high value might make the app take a long time to start,
or it may not start at all depending on the size of your data.Remote filesCurrently, ParqInspector supports reading remote files from Azure Data Lake
Storage Gen2, Amazon S3 and Google Cloud Storage. In case your storage service
does not support anonymous access, you will need to set environment variables
in order to make ParqInspector able to authenticate to the service. Currently,
ParqInspector supports the following environment variables:Azure:AZURE_STORAGE_ACCOUNT_NAMEAZURE_STORAGE_SAS_KEYAZURE_STORAGE_ACCOUNT_KEYAZURE_STORAGE_CLIENT_IDAZURE_STORAGE_CLIENT_SECRETAZURE_STORAGE_TENANT_IDAWS:AWS_ACCESS_KEY_IDAWS_SECRET_ACCESS_KEYAWS_REGIONAWS_DEFAULT_REGIONGCP:GOOGLE_SERVICE_ACCOUNTGOOGLE_SERVICE_ACCOUNT_KEYDepending on your method of authentication, not all of the environment variables
need to be set.Remote files can only be opened through the Settings-pane in the UI.
Pick the correct cloud provider and in the Path-field, you simply put the URL to your file instead of a local path.
ParqInspector usespolarsunder the hood
to read Parquet files and Delta-tales from remote storage, and the supported protocols and
url-variants are determined by what polars supports. See morehere.👉 Roadmap[✓] - reading local single Parquet files[✓] - reading remote single Parquet files[] - Reading Parquet datasets[✓] - Reading Delta tablesIf you encounter any issues, bugs or feel there is a feature missing that would
be valuable, please create an issue in this repo!
Package: parquest
ParquestParquest is a project that aims to structure raw data into a structured format based on the Parquet file format. The name "Parquest" is a portmanteau of "Parquet" and "quest," symbolizing the journey of transforming raw data into a structured format.IntroductionIn today's data-driven world, dealing with large volumes of raw data can be challenging. The Parquest project provides a solution by leveraging the power of the Parquet file format to structure and organize raw data efficiently.FeaturesData Structuring: Parquest enables you to convert raw data into a structured format based on the Parquet file format.Efficient Storage: The Parquet file format is designed for efficient storage and retrieval of structured data, making it ideal for big data applications.Columnar Storage: Parquest stores data in a columnar format, which allows for faster query performance and better compression ratios.Schema Evolution: Parquest supports schema evolution, allowing you to easily modify the structure of your data over time without breaking compatibility.
Package: parquet
parquet-pythonparquet-python is a pure-python implementation (currently with only
read-support) of theparquet
format. It comes with a
script for reading parquet files and outputting the data to stdout as
JSON or TSV (without the overhead of JVM startup). Performance has not
yet been optimized, but it’s useful for debugging and quick viewing of
data in files.Not all parts of the parquet-format have been implemented yet or tested
e.g. nested data—see Todos below for a full list. With that said,
parquet-python is capable of reading all the data files from theparquet-compatabilityproject.requirementsparquet-python has been tested on python 2.7, 3.6, and 3.7. It depends
onpythrift2and optionally onpython-snappy(for snappy compressed
files, please also installparquet-python[snappy]).getting startedparquet-python is available via PyPi and can be installed usingpip install parquet. The package includes theparquetcommand for reading python files, e.g.parquet test.parquet.
Seeparquet –helpfor full usage.Exampleparquet-python currently has two programatic interfaces with similar
functionality to Python’s csv reader. First, it supports a DictReader
which returns a dictionary per row. Second, it has a reader which
returns a list of values for each row. Both function require a file-like
object and support an optionalcolumnsfield to only read the
specified columns.importparquetimportjson## assuming parquet file with two rows and three columns:## foo bar baz## 1   2   3## 4   5   6withopen("test.parquet")asfo:# prints:# {"foo": 1, "bar": 2}# {"foo": 4, "bar": 5}forrowinparquet.DictReader(fo,columns=['foo','bar']):print(json.dumps(row))withopen("test.parquet")asfo:# prints:# 1,2# 4,5forrowinparquet.reader(fo,columns=['foo','bar]):print(",".join([str(r)forrinrow]))TodosSupport the deprecated bitpackingFix handling of repetition-levels and definition-levelsTests for nested schemas, null dataSupport reading of data from HDFS via snakebite and/or webhdfs.Implement writingperformance evaluation and optimization (i.e. how does it compare to
the c++, java implementations)ContributingIs done via Pull Requests. Please include tests with your changes and
followpep8.To run the tests you must install and executetox(pip install tox) to
run for all supported versions. If you want to run just for your current
version, execute:pip install-rrequirements-development.txtand thennosetests.
Package: parquet2hive
# parquet2hive [![Build Status](https://travis-ci.org/mozilla/parquet2hive.svg?branch=master)](https://travis-ci.org/mozilla/parquet2hive)Hive import statement generator for Parquet datasets. Supports versioned datasets and schema evolution.## Installing from PypiTo install this package from Pypi, run:```bashpip install parquet2hive```## Updating the Package on PyPiTo upload the most recent version, run:```bashpython setup.py sdist upload```## Using the TestPypi ServersYou will need a separate account on https://testpypi.python.org.To upload the file to the pypi test servers, ensure your ```~/.pypirc``` contains the following:```bash[distutils]index-servers=pypipypitest[pypitest]repository = https://testpypi.python.org/pypiusername = testpypi_usernamepassword = testpypi_password[pypi]repository = https://pypi.python.org/pypiusername = pypi_usernamepassword = pypi_password```Upload the code using:```bashpython setup.py sdist upload -r https://testpypi.python.org/pypi```Finally, pull the most recent package from the test-repository on any machine using:```bashpip install parquet2hive -i https://testpypi.python.org/pypi```## Example usage```bashparquet2hive s3://telemetry-parquet/longitudinal | bash```To see the allowed command line interface arguments, run ```parquet2hive -h```