Saravanan666/pypi-org huggingface dataset:
Package: protonne
protonnePython bindings for proton vpn's linux cli.InstallationInstall with:pip install protonneNOTE: This package requires that you have a Proton VPN account and that you've installed and set up theProton VPN Linux CLI.Usagefrom protonne import Proton
proton = Proton()
proton.connect_fastest()
proton.enable_permanent_killswitch()

# If you want to execute the commands "silently", you can set 'capture_output' to True in the class constructor or after creation through the 'capture_output' property
proton.capture_output = True
proton.capture_output = False
# Almost every function returns an 'Output' object that contains 3 fields: 'return_code', 'stdout', and 'stderr'.
# When 'capture_output' is True, 'stdout' and 'stderr' can be accessed through the 'Output' object, otherwise they are empty strings.
# The 'capturing_output()' context manager can also be used.
with proton.capturing_output():
    output = proton.connect_random()
    print(output.stdout)

# Once you're connected, info about the connection is available through the 'connection' property.
# Accessing this property invokes the cli's 'status' command and parses the output into a 'Connection' object.
# For performance, it's best to store this property in a local variable for repeated access until you need an updated 'Connection' object.
ip_history = []
connection = proton.connection
ip_history.append((connection.IP, connection.server.name))
proton.connect_random()
connection = proton.connection
ip_history.append((connection.IP, connection.server.name))
proton.connect(server=ip_history[0][1])

# Full 'Connection' annotation:
connection.IP: str
connection.killswitch.active: bool
connection.killswitch.on: bool
connection.killswitch.permanent: bool
connection.raw: str # The raw output string of the 'status' cli command
connection.server.name: str
connection.server.country: str
connection.server.protocol: str
connection.server.load: str
connection.server.plan: str
connection.server.features: str | None
connection.time: str
Package: protonup
IntroductionCLI program and API to automate the installation and update ofGloriousEggroll'sProton-GEInstallationInstall from Python Package Indexpip3 install protonupInstall from sourcegit clone https://github.com/AUNaseef/protonup && cd protonup
python3 setup.py install --userIf you get acommand not founderror, add the following to your~/.profile(if it's not already present) and runsource ~/.profileif [ -d "$HOME/.local/bin" ] ; then
    PATH="$HOME/.local/bin:$PATH"
fiUsageSet your installation directory before running the program with-d "your/compatibilitytools.d/directory"Example:protonup -d "~/.steam/root/compatibilitytools.d/"To update to the latest version, just runprotonupfrom a command lineExample:protonupList available versions with--releasesExample:protonup --releasesInstall a specific version with-t "version tag"Example:protonup -t 6.5-GE-2By default the downloads are stored in a temporary folder. Change it with-o "custom/download/directory"Example:protonup -o ~/DownloadsList existing installations with-lExample:protonup -lRemove existing installations with-r "version tagExample:protonup -r 6.5-GE-2Use--downloadto download  Proton-GE to the current working directory without installing it, you can override destination with-oExample:protonup --downloadUse-ytoggle to carry out actions without any logging or interactionExample:protonup --download -o ~/Downloads -yRestart Steam after making changes
Package: protonup-ng
IntroductionProtonUp-ng: CLI program and API to automate the installation and update ofGloriousEggroll'sProton-GENote: This is a fork of AUNaseef's awesome ProtonUp. I will maintain this fork until he pulls all needed changes for the new versioning scheme of GE-Proton into his codebase.InstallationInstall from Python Package Indexpip3 install protonup-ngInstall from sourcegit clone https://github.com/cloudishBenne/protonup-ng && cd protonup-ng
python3 setup.py install --userInstall a snapshot of the repopip3 install https://github.com/cloudishBenne/protonup-ng/archive/main.zip
# or any other branch, tag, commit
# pip3 install https://github.com/cloudishBenne/protonup-ng/archive/[branch, tag, commit-hash].zipIf you get acommand not founderror, add the following to your~/.profile(if it's not already present) and runsource ~/.profileif [ -d "$HOME/.local/bin" ] ; then
    PATH="$HOME/.local/bin:$PATH"
fiUsageNote: The package itself is now called protonup-ng, but usage on the terminal is still protonup to not breaking scripts.Set your installation directory before running the program with-d "your/compatibilitytools.d/directory"Example:protonup -d "~/.steam/root/compatibilitytools.d/"To update to the latest version, just runprotonupfrom a command lineExample:protonupList available versions with--releasesExample:protonup --releasesInstall a specific version with-t "version tag"Example:protonup -t 6.5-GE-2or with the new naming scheme:protonup -t GE-Proton7-10By default the downloads are stored in a temporary folder. Change it with-o "custom/download/directory"Example:protonup -o ~/DownloadsList existing installations with-lExample:protonup -lRemove existing installations with-r "version tagExample:protonup -r 6.5-GE-2or with the new naming scheme:protonup -r GE-Proton7-10Use--downloadto download  Proton-GE to the current working directory without installing it, you can override destination with-oExample:protonup --downloadUse-ytoggle to carry out actions without any logging or interactionExample:protonup --download -o ~/Downloads -yRestart Steam after making changes
Package: protonvpn-gtk
ProtonVPN-GTK❗️ In development ❗️ Seestatus.An unofficial GTK 3 client for ProtonVPN. It's just GTK+ frontend forProtonVPN/protonvpn-cli-ng.InstallationRequirementsPython 3.6+protonvpn-cli-ngInstallinginstallprotonvpn-cli-ngwith all dependencies.installPyGObjects.installProtonVPN-GTK:sudo python3 setup.py installUsageRunsudo protonvpn-gtk.StatusImplementation ToDO:Show connection status.Connect to server.Disconnect the current session.Change icon color on status change.Edit configuration.Add tests.Add logging.
Package: protool
protoolA tool for dealing with provisioning profiles.What can it do?Read profiles as XML or as a dictionaryRead the values from the profileDiff two profiles to see what has changedInstallationpip install protoolExamples:import protool
profile = protool.ProvisioningProfile("/path/to/profile")

# Get the diff of two profiles
diff = protool.diff("/path/to/first", "/path/to/second", tool_override="diff")

# Get the UUID of a profile
print profile.uuid

# Get the full XML of the profile
print profile.xml

# Get the parsed contents of the profile as a dictionary
print profile.contents()Alternatively, from the command line:# Get the diff
protool diff --profiles /path/to/profile1 /path/to/profile2 --tool diff

# Get the UUID of a profile
protool read --profile /path/to/profile --key UUID

# Get the raw XML (identical to using `security cms -D -i /path/to/profile`)
protool decode --profile /path/to/profileContributingThis project welcomes contributions and suggestions.  Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visithttps://cla.microsoft.com.When you submit a pull request, a CLA-bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.This project has adopted theMicrosoft Open Source Code of Conduct.
For more information see theCode of Conduct FAQor
contactopencode@microsoft.comwith any additional questions or comments.
Package: protools
protools一个实现了批量将protobuf数据自动识别为类json格式，批量将proto定义文件转为python类的命令行工具。适用于需要转换大量的protobuf数据或proto定义文件。暂时只在Windows 10 x64、Ubuntu 20.04 x64的中文环境下做过测试，其他系统或语言环境如有问题欢迎提交issue。installpipinstallprotoolsupdatepipinstall--upgradeprotoolsusepython-mprotools-f...-i...-o...
protools-f...-i...-o...其中-f可选参数有b2j[buf2json]、p2p[proto2python]。
其中-i是输入文件夹，-o是输出文件夹，其合法关系有一对一、多对一、多对多，当使用多对多关系时，应确保输入文件夹和输出文件夹一一对应（见demo2）。demo将data和net文件夹中所有文件当作protobuf数据批量自动识别为类json格式并写入到json文件夹。protools-fb2j-idata-inet-ojson将data和net文件夹中所有文件当作protobuf数据批量自动识别为类json格式并分别写入到data_json和net_json文件夹。protools-fb2j-idata-inet-odata_json-onet_json将proto文件夹中的所有文件当作proto定义文件批量转为python类并写入到python文件夹。protools-fp2p-iproto-opythonLicense
Package: proto-parser-ng
Protoparser-ngA package for parsing proto3 filesIntroductionThe purpose of this package is to parse the .proto file (version 3) into a
Python data structure. We use it for code generation or other operations where
analysing the structure of the schema is the goal. This project is a fork ofhttps://github.com/khadgarmage/protoparserby xiaochun.liu with the following
features/fixes:Parse oneof definitionsParse comments without crashingHow to Usepip install proto-parser-ngOutput format is as following:{"messages":{"MessageItem":{"comment":{"content":"","tags":{}},"name":"MessageItem","fields":[{"comment":{"content":"","tags":{}},"type":"string","key_type":"string","val_type":"string","name":"Title","number":1}],"messages":{},"enums":{}},"Player":{"comment":{"content":"//@entry\n//@schema\n","tags":{"entry":true,"schema":true}},"name":"Player","fields":[{"comment":{"content":"//@fmt=date\n//@desc=Player's birthday\n","tags":{"fmt":"date","desc":"Player's birthday"}},"type":"string","key_type":"string","val_type":"string","name":"Birthday","number":5},{"comment":{"content":"//@required\n","tags":{"required":true}},"type":"PlayerType","key_type":"PlayerType","val_type":"PlayerType","name":"Type","number":6},{"comment":{"content":"// @title App version history\n","tags":{}},"type":"repeated","key_type":"string","val_type":"string","name":"AppVerHistory","number":7},{"comment":{"content":"","tags":{}},"type":"repeated","key_type":"MessageItem","val_type":"MessageItem","name":"MessageBox","number":8},{"comment":{"content":"//@ title =Warehouse\n","tags":{"title":"Warehouse"}},"type":"map","key_type":"uint64","val_type":"StoreItem","name":"Storage","number":9},{"comment":{"content":"//@pattern=^(https?|ftp|file)://[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]$\n","tags":{"pattern":"^(https?|ftp|file)://[-A-Za-z0-9+&","#/%?":"~_|!:,.;]+[-A-Za-z0-9+&","#/%":"~_|]$"}},"type":"string","key_type":"string","val_type":"string","name":"HomePage","number":11}],"messages":{"StoreItem":{"comment":{"content":"","tags":{}},"name":"StoreItem","fields":[{"comment":{"content":"","tags":{}},"type":"uint32","key_type":"uint32","val_type":"uint32","name":"Num","number":1}],"messages":{},"enums":{}}},"enums":{"InnerType":{"comment":{"content":"","tags":{}},"name":"InnerType","fields":[{"comment":{"content":"","tags":{}},"type":"enum","key_type":"enum","val_type":"enum","name":"TEST","number":"0"}]}}}},"enums":{"PlayerType":{"comment":{"content":"","tags":{}},"name":"PlayerType","fields":[{"comment":{"content":"//normal player\n","tags":{}},"type":"enum","key_type":"enum","val_type":"enum","name":"NORMAL","number":"0"},{"comment":{"content":"//cheater\n","tags":{}},"type":"enum","key_type":"enum","val_type":"enum","name":"CHEATER","number":"1"}]}},"services":{"JobFileService":{"name":"JobFileService","functions":[{"name":"GDriveFileList","in_type":"msg.GDriveFileListReq","out_type":"msg.FileListRep","uri":"/api/files/gdrive"}]}}}
Package: protopia
Python Protopia AgentThis is a Python implementation of the Protopia Agent.Install via PypipipinstallprotopiaUsage via Pypiimportprotopiaclient=protopia.Agent()client.get_option()# returns will be# > PROTOPIA_CLOUD_URL is set to api.stage-01.stage.protopia.ai:443# > TOKEN_URL is set to https://protopia-cloud-stage-01.auth.us-east-1.amazoncognito.com/oauth2/token# > SCOPES is set to ['https://api.stage-01.protopia.ai/noise:read']# > OIDC_CLIENT_ID is set to None# > OIDC_CLIENT_SECRET is set to Noneclient.set_client(client_id,client_secret)# returns will be (See below to retrieve client_id and client_secret)# > OIDC_CLIENT_ID is set to client_id# > OIDC_CLIENT_SECRET is set to client_secretclient.connect()# returns will be# > successfully connected to staging cloud APIdist=client.get_noise_distribution(nnid)# returns will be encrypted noise distributionDevelopmentPrerequisitesInstall the following programs:Python version 3.8+Runpip3 install -r requirements.txtprotocIn MacOS this can be installed by runningbrew install protocPreconfigurationThe following environment variables must be exported prior to running the agent:OIDC_CLIENT_IDthe client ID of the agent issued by Cognito.OIDC_CLIENT_SECRETthe client secret of the agent issued by Cognito.You will get the predefined agent inAWS cognito consoleNew user creation is described in thecloud/example/nose_store/uploadInstallation for local packageOnce above is set then you can install the package by following commandpipinstall.Build the packageYou can execute the following line to build the packagepythonsetup.pybdist_wheelUpload the package to PypiYou'll need twine to upload the packagepipinstalltwineThen you'll need ID and Password for Pypi. contactalan@protopia.aito get it.twineuploaddist/{buildlocationfromabove}# ex twine upload dist/protopia-0.1.0-py3-none-any.whlGenerting Python From ProtocolBufferA script is provided to generate Python code from theProtocolBuffer defintion of the gRPC protocolexposed by Protopia Cloud. To re-generate Python code from the ProtocolBuffer definition, run:makeprotocThis will be executed in thecloud repoThen copycloud/protos/protopia-api/apiin cloud repo and paste topy-agent/protopia/api
Package: proto-pixplus-pb2
File with proto types for Pix+ services.In order to push changes to theproto_pixplus_pb2.py, be sure that:Theproto_pixplus.protofile contains the changes, which were compiledsuccessfully.New .py file is compiled and overwrittenproto_pixplus_pb2.pymodule with current using this commandprotoc -I=. --python_out=. ./proto_pixplus.protoPlease, import needed types with anptypealiasimportproto_pixplus_pb2asptypeDeploy new versionTo deploy new version, be sure you have the latest version of PyPA’s build installed:python3-mpipinstall--upgradebuildGo to the/proto_pypifolder and run next command:python3-mbuildThis command should output a lot of text and once completed should generate two folder in the directory:distandproto_pixplus_pb2.egg-infoTo upload new version of the package, also be sure to update theversionof the package. See the semantics of the versioning athttps://semver.org/Installtwine, to upload all the archives under dist:python3-mpipinstall--upgradetwineAfter, you can push new version of the package withpython3 -m twine upload --skip-existing dist/* --verbose. You will be prompted forusernameandpassword.Once uploaded, you can check your new version athttps://pypi.org/manage/project/proto-pixplus-pb2/releases/If any issues are met, look at the completetutorial.
Package: proto-plus-stubs
Type stubs for proto-plus-stubsThis package provides type stubs for theproto-pluspackage. It allows you to type check usage of the library with e.g.mypyand will also improve autocomplete in many editors.This is in no way affiliated with Google.The stubs were originally created bystubgen, but have seen some manual improvements since then. Further contributions are welcome.Installation$pipinstallproto-plus-stubsThe stubs should be automatically picked up by your editor or typechecker.
Package: proto-ros
proto_rosThis project provides utilities for the translation betweenProtocol Buffersmessage definitions (proto files) andROS messagedefinitions (msg files).proto2msgTheproto2msgscript translates Protobuf (proto) files into equivalent ROS Message (msg) files.Usage:proto2msg <proto_dir> <msg_dir> (--recursive)For each proto file in proto_dir equivalent msg files are created in msg_dir.To translate a single protofile use the following command:Usage: protoc --proto_path=<proto_dir> --msg_out=<msg_dir> <file.proto>Limitationsproto3 syntaxenums are translated to constantsNo support for 'oneof' and 'any' typesNo support for extensionsNo support for optionsNo support for serviceThe Protobuf Compiler (protoc) parses the proto file and provides it packed in a CodeGeneratorRequest to theprotoc_gen_msgplugin (via stdin). This plugin generates a set of ROS message definition (msg) files from the parsed proto file. It returns the generated msg files packed in a CodeGeneratorResponse (via stdout) to the compiler.msg2protoThemsg2protoscript translates ROS message (msg) files into Protobuf (proto) files.Usage:msg2proto <msg_dir> <proto_dir> (--package <packagename>)For each msg file in msg_dir an equivalent proto file is created in proto_dir.Limitations:proto3 syntaxno support for default values (defaults are skipped)constants are translated to commentsno support for string and array bounds (both treated as unbounded)We defined aParsing Expression Grammarfor ROS messages and useParsimoniousfor the actual parsing.InstallationInstallprotoc, the Protobuf compiler:sudo apt install protobuf-compilerInstall ourproto_rospackage from PyPi:pip install proto_rosOr install it from GitHub:pip install "git+https://github.com/dortmans/proto_ros.git"
Package: protosaurus
ProtosaurusParse and create ProtoBuffer messages at runtime. Deserialize Protobuf from Kafka usingkcatand a schema registry.InstallationpipinstallprotosaurusUsageDeserialize Protobuf from Kafka using a schema registryIf a schema registry is available, Protosaurus can deserialize Protobuf messages in Kafka automatically:kcat-C-e-F<kafka.config>-t<topic>-f"%o\\n%k\\n%R%s"|protosaurus---schema-registry<url>Usingpipx:kcat-C-e-F<kafka.config>-t<topic>-f"%o\\n%k\\n%R%s"|pipxrunprotosaurus---schema-registry<url>Parse Proto in PythonProtosaurus can parse.protodefinitions at runtime without usingprotoc. This allows Protobuf byte arrays to be converted to JSON and vice versa.importjsonfromprotosaurusimportContextfrombase64importb64decode# create a context which stores the proto schemasctx=Context()# add protos by specifying name and contentctx.add_proto('diet.proto',"""syntax = "proto3";enum Diet {carnivorous = 0;herbivorous = 1;}""")# the proto can be imported via the specified namectx.add_proto('animal.proto',"""syntax = "proto3";import "diet.proto";message Animal {string name = 1;Diet diet = 2;double length = 3;}""")# convert a message from base64 string...data=ctx.to_json('Animal',b64decode('CglJZ3Vhbm9kb24QARkAAAAAAAAkQA=='))# ...or hex stringdata=ctx.to_json('Animal',bytes.fromhex('0a09496775616e6f646f6e1001190000000000002440'))print(data)# >>> '{"name":"Iguanodon","diet":"herbivorous","length":10}'# convert json to protobufdata=ctx.from_json('Animal',json.dumps({"name":"Iguanodon","diet":"herbivorous","length":10}))print(data)# >>> b'\n\tIguanodon\x10\x01\x19\x00\x00\x00\x00\x00\x00$@'
Package: proto-schema-parser
Protobuf Schema ParserProtobuf Schema Parser is a pure-Python library that parses and writes Protobuf schemas to and from an abstract syntax tree (AST).The library usesproto_schema_parser.parser.Parserto parse theCST into an AST. Theproto_schema_parser.generator.Generatorclass converts the AST back into a CST (a Protobuf schema string).The lexer and parser are autogenerated fromBuf's ANTLRlexer and parsergrammar files.Features✅ proto2 and proto3 support✅ message, field, enum, optional, required, repeated✅ import, package, oneof, map, and option✅ group and extend (in proto2)✅ service, rpc, and stream✅ line and block comment preservationInstallationInstall the package via pip:pipinstallprotobuf-schema-parserUsageTo parse a protobuf schema, create aParserobject and call theparsemethod:fromproto_schema_parser.parserimportParsertext="""syntax = "proto3";message SearchRequest {string query = 1;int32 page_number = 2;int32 result_per_page = 3;}"""result=Parser().parse(text)This will return an AST object (ast.File) representing the parsed protobuf schema.File(syntax='proto3',
     file_elements=[Message(name='SearchRequest',
                            elements=[Field(name='query',
                                            number=1,
                                            type='string',
                                            cardinality=None,
                                            options=[]),
                                      Field(name='page_number',
                                            number=2,
                                            type='int32',
                                            cardinality=None,
                                            options=[]),
                                      Field(name='result_per_page',
                                            number=3,
                                            type='int32',
                                            cardinality=None,
                                            options=[])])])To write the AST back to a protobuf schema, create aGeneratorobject and call thegeneratemethod:fromproto_schema_parser.generatorimportGeneratorproto=Generator().generate(result)This will print:syntax="proto3";messageSearchRequest{stringquery=1;int32page_number=2;int32result_per_page=3;}ContributingI welcome contributions!Submit a PR and I'll review it as soon as I can.Open an issue if you find a bug or have a feature request.LicenseProtobuf Schema Parser is licensed under theMIT license.
Package: proto-schematics
Making Protobuf messages as cute as Python.MotivationProtobuf and gRPC are great when it comes to high performance schema aware APIs,
but when Google designed Protobuf, it didn’t tried to make the generated code
idiomatic in Python, which brings a problem when exporting messages outside
iterface modules.Schematics is a cute and pythonic schema library. Why not join both?InstallingUsing pip:pip install proto_schamaticsExamplesInspecting a module is as simple as:from proto_schematics import ProtobufModule

models = ProtobufModule('my_protobuf_lib').import_schema()
MySchamticsModel = models['ProtobufMessageName']You can also do it on a lazy lint unfriendly way:from proto_schematics import ProtobufModule
ProtobufModule('my_protobuf_lib').meta_import()

from protobuf_schematics import ProtobufMessageName as MySchematicsModelSupportsDatetimes as native PythonDuration as TimeDeltasWrappers as native nullable types
Package: protoserver
Really really simple python webserver for prototyping. Basically just wraps SimpleHTTPServer/SimpleHTTPRequestHandler. I made this for my own purposes, but you’re welcome to use it.Defaults to running on the port specified in the PORT environment variable, or 8080 if not defined.Installationpip install protoserverThe only functionprotoserver.serve(directory = ".")Exampleimport protoserver

protoserver.serve() # Serves from the current directoryAnother exampleimport protoserver

protoserver.serve("static")  # Serves from ./staticClone and rundemo/demo.pyif you need to see this in action.
Package: protostar-cairo-py
protostar_cairo_pyThis is an internal package used byProtostar.PROTOSTAR
          [Python]
             │
             ▼
      PROTOSTAR-CAIRO-PY
          [Python]
             │
             ▼
SOFTWARE-MANSION-LABS/CAIRO (fork)
           [Rust]
             │
             ▼
           CAIRO
           [Rust]Setting up the environmentInstall a Python version management tool such aspyenvorasdf.Install Python 3.9.14.Clone this repository.Verify that the active Python version is 3.9.14.Create a virtual environment:python -m venv .venv.Activate the environment:source .venv/bin/activate.Upgrade pip:pip install --upgrade pip.Install Poetry, which is the dependency manager used by this package.Install project dependencies:poetry install.Install Rust by following the instructions onrust-lang.org.Test if everything works by building a wheel:poe build.DeployingUpdate the git submodule:poe sync.Release a package:poe deploy.