Saravanan666/pypi-org huggingface dataset:
Package: ptwit
Introductionptwitis a simple command-line-based Twitter client.ScreenshotsRequirementsA Twitter accountA Twitter application registered athttps://dev.twitter.com/appsInstallationTo installptwit, simply:pipinstallptwitAuthorizationFor the first time you runptwitcommand,ptwitwill ask for
your Twitter application information, which you can find athttps://dev.twitter.com/apps. If you don’t have one, register athttps://dev.twitter.com/apps/new.ptwitsupports multiple Twitter accounts. You can easily log into
a new account, or switch between accounts you’ve already authorized:ptwitloginACCOUNTUsageUsage: ptwit.py [OPTIONS] COMMAND [ARGS]...

Options:
  -a, --account TEXT  Use this account instead of the default one.
  --text              Print entries as human-readable text.
  --json              Print entires as JSON objects.
  --help              Show this message and exit.

Commands:
  timeline*   List timeline.
  accounts    List all accounts.
  faves       List favourite tweets of a user.
  follow      Follow users.
  followers   List your followers.
  followings  List who you are following.
  login       Log into an account.
  mentions    List mentions.
  messages    List messages.
  pop         Edit or delete the latest tweet.
  post        Post a tweet.
  replies     List replies.
  search      Search Twitter.
  send        Send a message to a user.
  tweets      List user's tweets.
  unfollow    Unfollow users.
  whois       Show user profiles.LICENSEptwitis under the MIT License. See LICENSE file for full license text.
Package: ptychography40
NoteThe Ptychography 4.0 repository and documentation are currently under construction.This repository collects implementations for ptychography that result from the work of thePtychography 4.0 project.InstallationThe short version:$virtualenv-ppython3.8~/ptychography-venv/$source~/ptychography-venv/bin/activate(ptychography-venv)$gitclonehttps://github.com/Ptychography-4-0/ptychography(ptychography-venv)$cdptychography(ptychography-venv)$python-mpipinstall-e.Please seeour documentationfor details!ApplicationsScalable, parallel implementation of the Single Side Band method that is suitable for live data processing.Please seethe algorithms sectionof our documentation
for details!Ptychography 4.0 is evolving rapidly and prioritizes features following user
demand and contributions. In the future we’d like to implement live acquisition,
and more analysis methods for all applications of pixelated STEM and other
large-scale detector data. If you like to influence the direction this project
is taking, or if you’d like tocontribute, please
contact us in theGitHub Issue tracker.LicensePtychography 4.0 is licensed under GPLv3.
Package: ptyme-track
Ptyme TrackThe obnoxiously hard to spell time tracking based on file modifications and signed time reporting. The P is silent like in PterodactylUsageInstallationpip install ptyme-trackServer / clientFor the server, generate a secret first withptyme-track --ensure-secretSimply run the server withptyme_track --serverFor the client, useptyme_track --clientRunning locallyRunptyme-track --ensure-secretto generate a secret and update the .gitignore file.Simply runptyme_track --standalonein the background.Setting directories to watchBy default, the current working directory is used and hidden directories are ignored. To manually set paths, use thePTYME_WATCHED_DIRSenvironment variable.Cementing workTo cement your time record, useptyme_track --cement <name>. It is recommended name is your github name. Note this is a filename so it needs to be filename safe (and unique from others). This will create a file.ptyme_track/<name>Getting a time summaryTo get a time summary enter the path to the file. For example,ptyme_track --time-blocks .ptyme_track/JamesHutchisonwill give you a summary of the time blocks for JamesHutchison....
{"start": "2023-05-30 19:00:34", "end": "2023-05-30 19:10:34", "duration": "0:10:00"}
{"start": "2023-05-31 04:02:31", "end": "2023-05-31 04:20:31", "duration": "0:18:00"}
{"start": "2023-05-31 04:20:31", "end": "2023-05-31 04:32:32", "duration": "0:12:01"}
{"start": "2023-05-31 04:30:32", "end": "2023-05-31 04:40:32", "duration": "0:10:00"}
{"start": "2023-05-31 04:56:33", "end": "2023-05-31 05:08:33", "duration": "0:12:00"}
{"start": "2023-05-31 05:03:51", "end": "2023-05-31 05:17:50", "duration": "0:13:59"}
Total duration:  11:47:22Adding to the CIAdd this workflow:name:Get logged timeon:pull_request:paths:-'.ptyme_track/*'jobs:track-time:uses:JamesHutchison/ptyme-track/.github/workflows/time_tracking.yaml@mainpermissions:pull-requests:writewith:base-branch:origin/${{ github.event.pull_request.base.ref }}pr-number:${{ github.event.pull_request.number }}
Package: ptyng
Fork ofptyaiming for enhancement of the fullstdlibPython API.As encountered in practice,pty.spawnrequiresKeyboardInterruptor else to break hanging fromselect.selectas inpty._copythen
raiseOSErrortopty.spawnand to return from the function.Thus,ptyngintroduced_is_zombieto check if the spawned child
process is already dead (or, a ‘zombie’), through whichpty.spawnwill automatically return from function call as normal/trivial scenerios
expected.DownloadStandalone releases are available on PyPI:http://pypi.python.org/pypi/ptyng/DevelopmentThe main development takes place in the Python standard library: see
thePython developer’s guide.
In particular, new features should be submitted to thePython bug tracker.DocumentationRefer to thestandard ptydocumentation.ptyng.spawnnow supportstimeoutargument. If the timeout
expires, the spawned child process will be killed and waited for.
Anotherenvargument can be used to set the runtime environment
variables for the spawned child process, default isos.environ.
Package: ptyp
ptypPackages that useptypDeveloper GuideSetup# create conda environment$mambaenvcreate-fenv.yml# update conda environment$mambaenvupdate-nptyp--fileenv.ymlInstallpipinstall-e.# install from pypipipinstallptypnbdev# activate conda environment$condaactivateptyp# make sure the ptyp package is installed in development mode$pipinstall-e.# make changes under nbs/ directory# ...# compile to have changes apply to the ptyp package$nbdev_preparePublishing# publish to pypi$nbdev_pypi# publish to conda$nbdev_conda--build_args'-c conda-forge'$nbdev_conda--mambabuild--build_args'-c conda-forge -c dsm-72'UsageInstallationInstall latest from the GitHubrepository:$pipinstallgit+https://github.com/dsm-72/ptyp.gitor fromconda$condainstall-cdsm-72ptypor frompypi$pipinstallptypDocumentationDocumentation can be found hosted on GitHubrepositorypages. Additionally you can find
package manager specific guidelines oncondaandpypirespectively.A = AliasC = ClassVarQ = OptionalE = (Over)-EngineeredZ = CustomR = RichP = PlotD = DataB = BioM = Machine Learning
Package: ptype
1IntroductionContents1Introduction1.1ptype1.2ptype-cat2Install requirements3UsageThis repository provides the source code of a Python package for ptype and its extension ptype-cat.1.1ptypeptype is a probabilistic approach totype inference, which is the task of identifying the data type (e.g. Boolean, date, integer or string) of a given column of data.Existing approaches often fail on type inference for messy datasets where data is missing or anomalous. Withptype, our goal is to develop a robust method that can deal with such data.Normal, missing and anomalous values are denoted by green, yellow and red, respectively in the right hand figure.ptype usesProbabilistic Finite-State Machines(PFSMs) to model known data types, missing and anomalous data. Given a column of data, we can infer a plausible column type, and also identify any values which (conditional on that type) are deemed missing or anomalous. In contrast to more familiar finite-state machines, such as regular expressions, that either accept or reject a given data value, PFSMs assign probabilities to different values. They therefore offer the advantage of generating weighted predictions when a column of messy data is consistent with more than one type assignment.If you use this package, please cite theptype paper, using the following BibTeX entry:@article{ceritli2020ptype,
  title={ptype: probabilistic type inference},
  author={Ceritli, Taha and Williams, Christopher K I and Geddes, James},
  journal={Data Mining and Knowledge Discovery},
  year={2020},
  volume = {34},
  number = {3},
  pages={870–-904},
  doi = {10.1007/s10618-020-00680-1},
}1.2ptype-catA weakness of ptype is that it does not handle well type inference for
categorical variables which are non-Boolean.  For example, most
existing methods including ptype treat the “Class Name” and “Rating”
columns in the example below as string and integer types respectively,
rather than categoricals. Therefore the user needs to manually
convert their assigned types.The data on the left-hand side are sampled froma dataset about clothing.To (semi-)automate this manual task, we introduce ptype-cat, which is
an extension of ptype to enable detection of the general categorical
type, including the non-Boolean categorical variables. ptype-cat
combines the output of ptype with additional features such as the
number of unique values in a column, and runs a Logistic Regression
classifier to determine whether a column denotes a categorical
variable or not when a column is labeled with the integer or string
type by ptype.Please see theptype-cat paperfor the details of ptype-cat, for which you can use
the following BibTeX entry to cite:@inproceedings{ptype-cat,
  title={ptype-cat: Inferring the Type and Values of Categorical Variables},
  author={Ceritli, Taha and Williams, Christopher K I},
  booktitle={21st ECML-PKDD Automating Data Science Workshop},
  year={2021},
}2Install requirementsYou can simply install ptype from PyPI:pipinstallptype3UsageSee demo notebooks innotebooksfolder. View them online viaBinder.
Package: ptypes
Theptypes(“persistent types”) package is a set of Python extension
modules written inCython.
It provides a persistency mechanism toPythonprograms based on memory mapped files.ptypesemphasises execution
speed. The persistent objects (persistent versions of ints, floats, strings,
structures, lists, sets, dicts plus any extension type supporting thebuffer interface) can be
accessed and manipulated directly, without serializing and de-serializing them.The package also implements data types for property graphs (nodes and
edges), as well as a basic query interface allowing the enumeration of
object-tuples matching a given pattern at (nearly) the speed of a C program.In its current shape,ptypesis experimental with regards to the stability
of its API and the completeness of its functionality. Making the updates to
the memory mapped filesatomicand
implementing garbage collection for the persistent objects are of prime
priorities.Installationptypesis tested on Linux (but should run on any Posix platform) using
CPython 2.7 (Python 3 support is on the agenda). It is distributed as a source
tarball, so you need to havegccto install it. The simplest way to do so
is:pip install ptypesIf you do not have internet access on the host where you need to install it,
then download it fromPyPIon a host
where you do have internet access, copy the tarball over to the target host
and:tar -xf ptypes-<version>.tgz
cd ptypes-<version>
python setup.py installIn thedocdirectory you should find abundant examples of how to use it.
Package: ptyprocess
Launch a subprocess in a pseudo terminal (pty), and interact with both the
process and its pty.Sometimes, piping stdin and stdout is not enough. There might be a password
prompt that doesn’t read from stdin, output that changes when it’s going to a
pipe rather than a terminal, or curses-style interfaces that rely on a terminal.
If you need to automate these things, running the process in a pseudo terminal
(pty) is the answer.Interface:p = PtyProcessUnicode.spawn(['python'])
p.read(20)
p.write('6+6\n')
p.read(20)
Package: ptysh
## PTYSHPTYSH is an abbreviation of 'Python Teletype Shell'.<br>It was made with reference to the 'zebra vtysh'.<br>Vtysh is an integrated shell for Quagga routing software.<br><br>Ptysh is not the only route shell, the shell is customizable, so you can normally use.<br>It made it possible to add commands to the module for availability.<br>## NoteYou can install ptysh through the pip.<br>However, you must manually install some libraries.<br>I'll update the library list soon.<br>## Usage### Start shellWhen you run the 'ptysh_main.py', the shell begins.<br>You can use the commands summarized below.<br>During PTYSH to use commands such as ctrl-c and ctrl-z does not work.<br>### Add custom moduleTo add a module, you will create a file with reference to the sample code in the "modules" directory.<br>You can create additional logic inherit the class ptysh_module.<br>## Command### disable mode1. enable* Enter the control shell* It required password. (default password is ptysh)2. exit* exit the shell.3. list* show command list.4. st* start-shell (default shell is bash)* It is hidden command.* It required password and it is same to enable password.### enable mode1. diable* exit the enable mode2. exit* exit the shell.3. list* show command list.4. configure terminal* It is control menu for other modules.### configure terminal mode1. exit* exit the shell.2. list* show command list.## Idea or IssueIf you have an idea or issue, feel free to open an issue or make pull request.
Package: ptyx
pTyXOverviewpTyX is a LaTeX precompilator, written in Python.
pTyX enables to generate LaTeX documents, using custom commands or plain python code.
One single pTyX file may generate many latex documents, with different values.
I developped and used pTyX to make several different versions of a same test in exams,
for my student, to discourage cheating.
Since it uses sympy library, pTyX has symbolic calculus abilities too.InstallationpTyX is only tested on GNU/Linux (Ubuntu), but should work on MacOs X too.Obviously, pTyX needs a working Python installation.
Python version 3.8 (at least) is required for pTyX to run.pTyX also needs a working LaTeX installation. Commandpdflatexmust be available in your terminal.The easiest way to install it is using pip.$ pip install ptyxYou may also download and install the latest version from Github:$ git clone https://github.com/wxgeo/ptyx.git
$ cd ptyx
$ pip install -e .UsageTo compile a pTyX file (see below), open a terminal, go to pTyX directory, and write:$ ptyx my_file.ptyxFor more options:$ ptyx --helppTyX file specificationA pTyX file is essentially a LaTeX file, with a .ptyx extension, (optionally) some custom commands, and embedded python code.To include python code in a pTyX file, use the #PYTHON and #END balise.
A specialwrite()command is available, to generate latex code on the flow from python.This a simple \emph{addition}:\quad
#PYTHON
from random import randint
a = randint(5, 9)
b = randint(2, 4)
write('%s + %s = %s\\' % (a, b, a + b))
#END
Now, some basic \emph{subtraction}:\quad
#PYTHON
write('%s - %s = %s\\' % (a, b, a - b))
#ENDTo access any python variable outside python code scope, simply add a hashtag before the variable name.Any valid python expression can also be evaluated this way, using syntax #{python_expr}.$#a\mul#b=#{a*b}$However, pTyX has also reserved tags, like conditionals statements #IF, #ELSE, #ENDIF...(More to come...)
Package: ptyx-mcq
pTyX MCQ ExtensionMCQ generation (PDF files) and automatic marking of scanned students answers.OverviewpTyX is a LaTeX precompiler, written in Python.
pTyX enables to generate LaTeX documents, using custom commands or plain python code.
One single pTyX file may generate many latex documents, with different values.
I developed and used pTyX to make several versions of a same test in exams,
for my student, to discourage cheating.
Since it uses sympy library, pTyX has symbolic calculus abilities too.ThepTyX MCQ extensionmakes it easy to use pTyX to generate Multiple Choice Questions
in the form of pdf documents.
The students MCQ can then be scanned and automatically corrected and marked.InstallationObviously, pTyX needs a working Python installation.
Python version 3.8 (at least) is required for pTyX MCQ to run.Currently, pTyX is only supported on GNU/Linux.The easiest way to install it is to use pip.$ pip install --user ptyx_mcqUsageTo generate a template, run:$ mcq new new_folderThis will generate anew_folderfolder with anew.ptyxfile inside,
which is the main configuration file.This will also create anew_folder/questions/folder, where you should put all the exercises,
as.txtfiles.A few text files are already included as examples.See the next section (MCQ file format) for more information about those files format.To compile the template, run:$ mcq makeFor more options:$ mcq make --helpTo automatically corrected the scanned students MCQs, but them as a pdf insidenew_folder/scan.Then run:$ mcq scanMCQ file formatWhen runningmcq new, a template folder will be generated, including anew.ptyxfile.(More to come...)
Package: puaa
puaaAn uaa test server in python.
The main purpose is to serve as an easily configurable mock oauth server.Attention: it's not a secured OAuth server and must never be used on production machines.InstallLike any python package:pip install puaaConfigureThe server is configured through a regular uaa.yml but uses only a small subset
of it, mainly "jwt" and "oauth" sections:issuer:
  uri: http://localhost:8000

oauth:
  clients:
    test:
      id: test
      secret: test
      authorized-grant-types: client_credentials
      scope: none
      authorities: uaa.admin,clients.admin,clients.read,clients.write,clients.secret

jwt:
 token:
   policy:
     accessTokenValiditySeconds: 3600
     activeKeyId: key-id-1
     keys:
       key-id-1:
         signingKey: |
           -----BEGIN RSA PRIVATE KEY-----
           ...
           -----END RSA PRIVATE KEY-----Run locallyNeeds few environment variables to start:export AUTHLIB_INSECURE_TRANSPORT=true
export UAA_CONFIG_FILE=<PATH>/uaa.yaml
gunicorn -k gevent puaa.app:appThen can retrieve a token with e.g.:curl -sS http://localhost:8000/oauth/token -u test:test -d 'grant_type=client_credentials'To list JWT keys:curl -sS http://localhost:8000/token_keysLimitationsSupports the "client_credentials" grant only so far.AlternativesThe full uaa serverhttps://github.com/cloudfoundry/uaa/But I gave up to configure it as I wish.LicenseMIT License
Package: puan
A combinatorial optimization python package.Installpip install puanUsageGiven a predefined matrix, you construct a polyhedron as you would with a numpy array. Reduce its rows by following>>>importpuan>>>polyhedron=puan.ge_polyhedron([[0,-2,1,1],[0,1,1,1]])>>>polyhedron.reduce(*polyhedron.reducable_rows_and_columns())ge_polytope([[0,-2,1,1]])
Package: puan-client-db
Puan Client DBA small tool for calling a runningpuan-server-dbhttp service.Installpipinstallpuan-client-dbQuickstartimportpuan.logic.plogaspgfrompuan_client_dbimportPropositionClient# create a clientclient=PropositionClient("http://localhost:8000")# we run a service on our local machine on port 8000# create a puan model (pip install puan)model=pg.All(pg.Xor(*"xyz"),pg.Imply(pg.Any(*"AB"),pg.All(*"ijk")))# store the model by commiting it into the service# This will commit to a new model with default branch name (usually "main" but depends on backend config)# (second parameter returned is an error)sha_first,_=client.commit(model)# ... and we later made some changesmodel=model.assume({"i":1})# this fixes `i` to always be set to 1/True# then made another commitclient.commit(model)# some time later we want to checkout the first commit# (second parameter returned is an error)model_first,_=client.checkout(sha_first)
Package: puan-pv-sdk-python
Puan PV SDK PythonAn SDK for connecting to a Puan PV backend.Examplefrompuan_pv_sdk_pythonimportPropKey,And,Or,Variable,evaluation_composerevaluate=evaluation_composer("http://localhost:8080")keys=evaluate(propositions=[And(variables=[Or(variables=[Variable(id='a'),Variable(id='b')]),Variable(id='c')]),And(variables=[Variable(id='a'),Variable(id='b')]),],interpretations=[{"a":1,"b":1,"c":1},{"a":1,"b":1,"c":0},{"a":1,"b":0,"c":1},],).data# >>> print(keys)# [(0, 0), (0, 2), (1, 0), (1, 1)]# Meaning,#   - 1st proposition and 1st interpretation returns true,#   - 1st proposition and 3rd interpretation returns true,#   - ...# and so on.
Package: puan-rspy
puan-rspyPuan's python and rust connection package.What is it?Puan is a collection of tools for discrete optimization modelling in various programming languages. Puan-rspy bindsPuan's Rust packageinto a Python package. Check the link for more information about the tools inside.InstallUsingpippackage manager justpipinstallpuan-rspyUsageHere we construct a problem using the propositional logic classes within puan-rspy.
We construct aTheoryPyusing a list of statements. Each statement has a variable and (optional) anAtLeast-proposition.As an example, we'll create a model with only boolean variables"A","B","C","a","b","x","y". Since aStatementPyonly takes an integer as id parameter, we imagine them all being 0, 1, 2, ..., 6, respectively. We want to say that if any of"a" or "b"is selected, then"x" and "y"must be selected. We do this by creating new statements connecting a new variable to these variables. First we createC = x + y -2(which is thepr.StatementPy(2, (0,1), pr.AtLeastPy([5,6],-2, pr.SignPy.Positive))). Then we remeber from logic class that an implication statement (B -> C) is equivilant to!B or C. So for theB = "a" or "b"statement, we negate it first intonot "a" and not "b"which then described asB = -a - b + 0. Last, we connec B and C into a final statementA = B + C.importpuan_rspyasprmodel=pr.TheoryPy([# This first statement has id=0, bounds=(0,1) and an AtLeast proposition# saying that the sum of value of variable "1" and variable "2" and -1 must# be greater or equal than zero. In other words, at least one of variable "1"# and variable "2" must be 1.pr.StatementPy(0,(0,1),pr.AtLeastPy([1,2],-1,pr.SignPy.Positive)),pr.StatementPy(1,(0,1),pr.AtLeastPy([3,4],1,pr.SignPy.Negative)),pr.StatementPy(2,(0,1),pr.AtLeastPy([5,6],-2,pr.SignPy.Positive)),# These are independent variable declarations, e.i. variables that are# not dependent on other variablespr.StatementPy(3,(0,1),None),pr.StatementPy(4,(0,1),None),pr.StatementPy(5,(0,1),None),pr.StatementPy(6,(0,1),None),])# Here we use puan-rust's internal solver for solving our model with these# five different objectives, and then print the result.forsolution,objective_value,status_codeintheory.solve([{3:1},{4:1},{5:1},{6:1},{3:1,4:1}],True):print(solution,objective_value,status_code)# Which prints:# {3: 1, 6: 0, 5: 0, 4: 0} 1 5# {3: 0, 4: 1, 5: 0, 6: 0} 1 5# {5: 1, 4: 0, 3: 0, 6: 0} 1 5# {5: 0, 6: 1, 4: 0, 3: 0} 1 5# {4: 1, 5: 1, 3: 1, 6: 1} 2 5
Package: pub2
pub2====Pub2 is a self-publishing framework... image:: https://img.shields.io/github/stars/iandennismiller/pub2.svg?style=social&label=GitHub:target: https://github.com/iandennismiller/pub2.. image:: https://img.shields.io/pypi/v/pub2.svg:target: https://pypi.python.org/pypi/pub2.. image:: https://readthedocs.org/projects/pub2/badge/?version=latest:target: http://pub2.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status.. image:: https://travis-ci.org/iandennismiller/pub2.svg?branch=master:target: https://travis-ci.org/iandennismiller/pub2.. image:: https://coveralls.io/repos/github/iandennismiller/pub2/badge.svg?branch=master:target: https://coveralls.io/github/iandennismiller/pub2?branch=masterOverview--------Pub2 is a self-publishing framework.  It integrates with Jekyll to provide LaTeX publishing.macOS Quick Start^^^^^^^^^^^^^^^^^The following commands install pub2 and its dependencies (TeX Live and ImageMagick).::brew cask install mactexbrew install https://raw.githubusercontent.com/iandennismiller/pub2/master/etc/pub2.rbTo demonstrate pub2, the following commands initialize the current directory and build a sample.  The results appear in the `pub2` folder.::pub2 initpub2 buildopen pub2/*.pdfInstallation^^^^^^^^^^^^pub2 can be installed using pip.  This works well with virtualenv.::pip install pub2See :doc:`installation` to install on macOS, Windows, and Linux (Debian/Ubuntu or Redhat/CentOS).Documentation^^^^^^^^^^^^^http://pub2.readthedocs.io