Saravanan666/pypi-org huggingface dataset:
Package: pysnowball
pysnowball===============quick start>>>importpysnowballasball>>>ball.set_token('xq_a_token=651af***************031c96a315c;')'xq_a_token=651af***************031c96a315c;'>>>ball.cash_flow('SH600000'){'data':{'quote_name':'浦发银行','currency_name':'人民币','org_type':2,'last_report_name':'2018三季报','currency':'CNY','list':[{'report_date':1514649600000,'report_name':'2017年报','ncf_from_oa':[-140673000000.0,0.26730141203064695],'ncf_from_ia':[37800000000.0,1.590486604702023],'ncf_from_fa':[4820000000.0,-0.9794317706599756]},{'report_date':1483113600000,'report_name':'2016年报','ncf_from_oa':[-191993000000.0,-1.5350677219775932],'ncf_from_ia':[-64015000000.0,0.8794943714468582],'ncf_from_fa':[234342000000.0,-0.042650194867269654]},{'report_date':1451491200000,'report_name':'2015年报','ncf_from_oa':[358820000000.0,0.8770859707676373],'ncf_from_ia':[-531220000000.0,-0.5512111080287921],'ncf_from_fa':[244782000000.0,2.357915963619902]},{'report_date':1419955200000,'report_name':'2014年报','ncf_from_oa':[191158000000.0,-0.3801741859756295],'ncf_from_ia':[-342455000000.0,-0.08702069578466226],'ncf_from_fa':[72897000000.0,4.966967784066173]},{'report_date':1388419200000,'report_name':'2013年报','ncf_from_oa':[308406000000.0,2.3313098144267537],'ncf_from_ia':[-315040000000.0,-1.2059925355889953],'ncf_from_fa':[-18376000000.0,-1.6123496284447998]}]},'error_code':0,'error_description':''}
Package: pySnowRadar
pySnowRadarA Python3 package to process data from CRESIS SnowRadar systems.From-Source Installation (PyPI and conda-forge packages coming soon)Install and initialize conda:https://docs.conda.io/en/latest/miniconda.htmlClone this repository, create the conda environment and install pySnowRadar:(base) $ git clone https://github.com/kingjml/pySnowRadar.git
(base) $ cd ./pySnowRadar
(base) $ conda env create -f exact_dev_env.yml
(base) $ conda activate py3-pySnowRadar
(py3-pySnowRadar) $ pip install .UsageCheck out the Jupyter notebook examples for usage scenarios and code snippets:Batch-processing of multiple NSIDC L1b Deconvoluted SnowRadar productsLayer retrieval test of AWI SnowRadar productLayer retrievel test of OIB SnowRadar productpySnowRadar does not validate interface or snow depth estimates. It is highly recommended that users compare outputs with measurements or references to quantify errors. Users should consider uncertainties including but not limited to surface roughness, salinity, and sidelobes.For reference, the following papers (not an exhaustive list) describe uncertainties involved with the handling of SnowRadar data:Panzer et al. (2013),Newman et al. (2014),Webster et al. (2014),King et al. (2015),Kwok et al. (2017)Development and ContributingThe following instructions are suitable for users who have already cloned this repository and would like to modify the inner workings of pySnowRadar.From inside the local clone or fork, create a new branch where your modifications will reside:(py3-pySnowRadar) $ git checkout -b new_featureAfter you make your modifications, you can test your changes by reinstalling pySnowRadar by usingpipfrom within the local clone:# Make sure you're in the proper python environment!
(py3-pySnowRadar) $ pip install . --upgradeWhen you are satisfied with your changes, you may push your changes to github.com and open a pull request. For more information on pull requests, consultGithub's Documentation(Optional) Test-runningTest files are stored under thetestssubdirectory and require thepytestandcoveragepackages.Running tests(py3-pySnowRadar) $ pytestRunning tests and generating coverage reportsThese commands run the tests and generate a coverage report for any untested files where theMissingcolumns indicates line numbers that still require testing(py3-pySnowRadar) $ coverage run -m pytest
(py3-pySnowRadar) $ coverage report # to display the coverage report within a terminalSometimes it's nicer to see a html-ified coverage report, so use the following command:(py3-pySnowRadar) $ coverage htmlThis will generate ahtmlcovfolder containing the coverage report. Openhtmlcov/index.htmlin a browser to see what code needs test coverage.
Package: pySNPCall
ABOUT++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++Python implementation of Java SNP calling pipeline (https://github.com/DSGlab/SNPCallingPipeline).Usage is descriped below. For consistency the configuration file is exactly as described in the Java code.Descriptions of the various options in the Java code is given at https://github.com/DSGlab/SNPCallingPipeline.An example configuration file is included in this directory.USAGE+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++usage: pySNPCallingPipeline.py [-h] -c CONF_FILE [--aln_only] [--no_aln][--local] [--submit] [--subset SUBSET][--def_run]Run pySNPCallingPipelineoptional arguments:-h, --help            show this help message and exit-c CONF_FILE, --conf CONF_FILEA configuration file is required to runpySNPCallingPipeline.--aln_only            Alignment only, default is FALSE.--no_aln              Run all analysis using pre-run alignments, default isFALSE.--local               Is this a LOCAL run or should SLURM files be created?Default is True.--submit              If running a supercomputing cluster, should only slurmfiles be created or should the jobs be submitted aswell.--subset SUBSET       Provide a comma seperated list of a subset of"alignment, getHQSNPs, intraClonalSNPs, checkSNPs,filterSNPs"--def_run             Default: run entire calculation locally.
Package: pysnptools
PySnpToolsPySnpTools is a library for reading and manipulating genetic data.Main Features:SnpReader: Efficiently read genetic PLINK formats including *.bed/bim/fam files.
Also, efficiently read parts of files, read kernel data, and standardize data.
New features include multi-threaded BED reading, cluster-ready BED data, on-the-fly SNP generation,
and larger in-memory data.DistReader: Efficiently work with
unphased BGEN format and other diploid, biallelic distribution data.
Also, efficiently read parts of files. SeeDistribution IPython Notebook.util: In one line, intersect and re-order IIDs from snpreader and other sources.
Also, efficiently extract a submatrix from an ndarray.IntRangeSet: Efficiently manipulate ranges of integers - for example, genetic position - with set operators including union, intersection, and set difference.mapreduce1: Run loops locally, on multiple processors, or on any cluster.filecache:  Read and write files locally or from/to any remote storage.Installpip install pysnptoolsDocumentationMain Documentationwith examples. It includes links to tutorial slides, notebooks, and video.Project Home and Full Annotated BibliographyCodePyPiGitHubChange LogContactsEmail the developers atfastlmm-dev@python.org.Jointhe user discussion and announcement list (or useweb sign up).Open an issueon GitHub.
Package: pysoa
PySOAis a general-purpose library for writing fast Python (micro)services and their clients, based on an RPC
(remote procedure call) calling style. It provides both a client and a server, which can be used directly by themselves
or, as we do, extended with extra functionality (our authentication, database routing, and other code is written as
private middleware and runs on top of this library).PySOA uses the concept of pluggable “transports” to define a layer for sending requests and responses (messages)
between clients and servers. The default, production-ready included transport is aRedispub-sub
layer, which we use in combination with Redis Sentinel in clusters. A single Redis cluster is capable of handling tens
of thousands of PySOA messages per second with extremely efficient and desirable load-balancing properties. There is
also a local transport implementation primarily used for testing and demonstration but capable of being used in
production where appropriate.Basic TenetsServices and actions both have simple names, and are called from the client by name. You can call actions
individually, or bundle multiple action calls into a “job” to be run serially (either aborting or continuing on
error).Requests and responses are simply Python dictionaries, and PySOA uses our open source validation frameworkConformityin order to verify their schema on the way in and out.Message bodies are encoded usingMessagePackby default (however, you can define your own
serializer), with a few non-standard types encoded using MessagePack extensions, such as dates, times, date-times,
and amounts of currency (using our open sourcecurrintlibrary).Requests have acontext, which is sourced from the original client context (web request, API request, etc.) and
automatically chained down into subsequent client calls made inside the service. This is used for contextual request
information like correlation IDs, authentication tokens, locales, etc.We include “SOA Switches” as a first-party implementation of feature flags/toggles. Part of the context, they are
bundled along with every request and automatically chained, and are packed as integers to ensure they have minimal
overhead.This intro summarizes some of the key concepts of using PySOA. For more thorough documentation, see thePySOA Documentation.LicensePySOA is licensed under theApache License, version 2.0.InstallationPySOA is available in PyPi and can be installing directly via Pip or listed insetup.py,requirements.txt,
orPipfile:pipinstall'pysoa~=1.2'install_requires=[...'pysoa~=1.2',...]pysoa~=1.2pysoa = {version="~=1.2"}DocumentationThe complete PySOA documentation is available onRead the Docs!
Package: py-soap
python-soapSOAP Python Data Structure generated fromSOAP Envelope.xml file withgenerateDSInstallationpipinstallpy-soapfrompysoap.envelopeimportEnvelope,Header,BodyThis package is used by thePurplship Multi-carrier Shipping SDKLicenseThis project is licensed under the terms of theMITlicense.
Please seeLICENSE.mdfor licensing details.AuthorsDaniel K.|@DanHK91|danielk.xyzPurplship Team|hello@purplship.com|purplship.com
Package: pysoar
PySOARPySOAR is a Python (3.9+) package for data analysis of translocation events during nanopore sensing. The main features include:Baseline correction function.Splitting the current into bins and doing a Poisson fit on that data to help the user visually decide on what threshold should be used for this data.Finding peaks function based on the threshold chosen.Ability to extract features from the events using both CUSUM and ADEPT methods.Histogram plots of peak curretn and dwell time data.InstallationTo install with pip:
'''pip install --user pysoar'''PySOAR utilises the following external libraries:NumPySciPyrupturesmatplotlibAcknowledgementsDeveloped by Vladimir Ivanov as part of the MSci final year project while working with the Edel's group at Imperial College London
Package: pysochrone
OSM_graphQuickly generate isochrones for Python and Rust!This library provides a set of tools for generating isochrones and reverse isochrones from geographic coordinates. It leverages OpenStreetMap data to construct road networks and calculate areas accessible within specified time limits. The library is designed for both Rust and Python, offering high performance and easy integration into data science workflows.FeaturesGraph Construction: Parses OpenStreetMap data to construct a graph representing the road network.Isochrone Calculation: Generates isochrones, areas reachable within a given time frame from a start point, using Dijkstra's algorithm.Reverse Isochrone Calculation: Determines areas from which a point can be reached within a given time frame.Concave and Convex Hulls: Supports generating both concave and convex hulls around isochrones for more accurate or simplified geographical shapes.Caching: Implements caching mechanisms to store and retrieve pre-calculated graphs for faster access.
Python Integration: Offers Python bindings to use the library's functionalities directly in Python scripts, notebooks, and applications.Concurrency Support: Utilizes Rust's concurrency features for efficient isochrone calculation over large datasets.GeoJSON Output: Converts isochrones into GeoJSON format for easy visualization and integration with mapping tools.InstallationTo use the library in Rust, add it to your Cargo.toml:[dependencies]osm-graph="0.1.0"For Python,pipinstallpysochroneOr, ensure you have Rust and maturin installed, then build and install the Python package:maturindevelopUsageRustuseosm_graph::{calculate_isochrones_from_point,HullType};asyncfnmain(){letisochrone=isochrone::calculate_isochrones_from_point(48.123456,11.123456,10_000.0,vec![300.0,600.0,900.0,1_200.0,1_500.0,1_800.0],overpass::NetworkType::Drive,isochrone::HullType::Convex,).await.unwrap();}Pythonimportpysochroneisochrones=pysochrone.calc_isochrones(48.123456,11.123456,5000,[600,1200,1800],"Drive","Convex")Roadmap[ ] Testing and benchmarks.
[ ] Customizable Speed Limits: Allow users to specify custom speed limits for different road types.
[x] Support for Pedestrian and Bicycle Networks: Expand the graph construction to support pedestrian and bicycle network types.
[ ] Topological simplification of osm graphs for more efficient downstream analytics.
[ ] Additional Roadnetwork analytics.
[ ] Routing engine.
[ ] Advanced Caching Strategies: Implement more sophisticated caching mechanisms for dynamic query parameters.
[ ] Interactive Visualization Tools: Develop a set of tools for interactive visualization of isochrones in web applications.
[ ] API Integration: Provide integration options with third-party APIs for enhanced data accuracy and features.
[ ] Optimization and Parallel Computing: Further optimize the graph algorithms and explore parallel computing options for large-scale data.ContributingContributions are welcome! Please submit pull requests, open issues for discussion, and suggest new features or improvements.LicenseThis library is licensed under MIT License.
Package: pysocketcan
PySocketCANThepysocketcanmodule provides a class to quickly modify Linux SocketCAN parameters directly from Python.For example, to change the baudrate in Linux you need to run$sudoiplinksetcan0down
$sudoiplinksetcan0typecanbitrate250000$sudoiplinksetcan0upThepysocketcanequivalent is>>>can0.baud=250000InstallationUsepipto install$pipinstallpysocketcanUsageimportpysocketaspysc>>>pysc.view_available()# returns available interfaces'can0'>>>can0=pysc.Interface("can0")# instantiate interface object>>>can0.on()# set interface up>>>can0.off()# set interface down>>>can0.state# returns current state of interface'STOPPED'>>>can0.baud=250000# sets the baudrate>>>can0.baud# returns current baudrate'250000'>>>can0.status# returns currently active modes'LOOPBACK,LISTEN-ONLY,TRIPLE-SAMPLING'>>>can0.listen_only=False# turns mode off>>>can0.status'LOOPBACK,TRIPLE-SAMPLING'If can-utils is installed you can also use>>>can0.receive()# returns bus message>>>can0.send(100,12345678)# adds message to busNote:To function correctly Python needs root priveleges$sudopython3# or$sudovenv/bin/python3ContributingPull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.
Package: pysocketftp-eba
# iCog course development tools final project
## Socket file transfer program
> Author:Eba Alemayehu___
## IntroductionIn general this parogram is used to transfer file form the client to the server by using socket. The program uses both C and python programming languages. The c programm makes the socket connection and the python program wrap the c shared liberary and use the methods defined in the library to transfer file to the server.This paogram is packaged in wheele file and it is available in pip installer.
Package: pysocketftp-eba-alemayehu
# iCog course development tools final project
## Socket file transfer program
> Author:Eba Alemayehu___
## IntroductionIn general this parogram is used to transfer file form the client to the server by using socket. The program uses both C and python programming languages. The c programm makes the socket connection and the python program wrap the c shared liberary and use the methods defined in the library to transfer file to the server.This paogram is packaged in wheele file and it is available in pip installer.
Package: pysocketio
TheSocket.iocompatible server library for Python.VersioningWe try to follow theSocket.ioversions. This means thatpysocketioversion
developed to be compatible withSocket.io0.9.0will be versioned0.9.0.N. It does not mean that version0.9.1.0will be incompatible with
a0.9.0client - that depends entirely on theSocket.io.InstallationRight now the code is only avaible on github, so you can either clone
this repository and install usingsetup.py:git clone git://github.com/Smartupz/pysocketio.git
cd pysocketio
python setup.py installor usingpip:pip install git+https://github.com/Smartupz/gevent-socketio.gitPS. We also have asetup.cfg, so you can use distutils2/packaging if you want.LicenseThis software is licensed under Simplified BSD License. For complete text see
theLICENSEfile.UsageComing soon! For now, checkout theexamplesdirectory (which may be a little
out of date, sorry!).AuthorsOriginaly created by Jeffrey Gelenes asgevent-socketio. Currently maintaned
under new name by Łukasz Rekucki and Artur Wdowiarski fromSmartupz LLC.
Package: pysocketsio
sockets-communicationThis module provides a wrapper for the built-in socket module in python. The program provides server and.
client classes, with the communication methods.first of allcredits:writen and owned by:
Shahaf Frank-Shapirall the rights are saved for:
Shahaf Frank-Shapirprogramming language:
python 3.8.6 (100%)before we startdescription:This module provides a wrapper for the built-in socket module in python. The program provides server and.
client classes, with the communication methods.dependencies:opening:
As for this is a really complex program, which uses a lot of modules, there are required dependencies needed
in order to run the program. keep in mined the program was writen in python 3.8.6, so any python version lower
than 3.9.2 might not work properly. Moreover, built-in python modules are being used, so keep that in mind.run the apprun from windows command line (inside the project directory)run with python (3.6.0 or higher) by writing to the command line in the project directory:python server.py
python client.py
python test.py
Package: pysockmmsg
pysockmmsgPython wrappers for Linux'ssendmmsgandrecvmmsgsystem calls.When sending/receiving a large amount of packets, preparing the data to be
send/received using only a single system call can improve a lot the overal
performance by reducing kernel/userland context switching.Install it from PyPIpipinstallpysockmmsgUsageSending multiple messages at a timeimportsocketfrompysockmmsgimportsendmmsgdata_to_send={('10.10.1.20','5555'):[b"msg1",b"msg2",b"msg3"],('10.10.1.25','5555'):[b"msg4",b"msg5"],('10.10.1.26','5555'):[b"msg6",b"msg7",b"msg8",b"msg9"],}sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)sendmmsg(sock,data_to_send,total_packets=9)DevelopmentRead theCONTRIBUTING.mdfile.
Package: pysocks5server
PySocks5ServerSimple socks5 proxy server written in python (I was bored).InstallationRequirements:Python 3.10+pipinstallsocksserverUsageUsage:python-msocks5server[-h][--hostHOST][--portPORT][--no-auth][--users[USERS...]]options:-h,--helpshowthishelpmessageandexit--hostHOST--portPORT--no-authAllowconnectionswithoutauthentication.--users[USERS...]Listofusers.Example:"--users user1:password1 user2:password2"TODOTCP/IP port bindingUDP port associationSocks4/socks4a support?Code examplesRun server without authenticationfromasyncioimportget_event_loopfromsocks5serverimportSocksServerserver=SocksServer("0.0.0.0",1080,True)if__name__=='__main__':get_event_loop().run_until_complete(server.serve())Run server with callbacksfromasyncioimportget_event_loopfromsocks5serverimportSocksServer,Socks5Client,DataDirectionserver=SocksServer("0.0.0.0",1080,True)@server.on_client_connectedasyncdefclient_connected(client:Socks5Client):print(f"Client connected:{client}")@server.on_client_disconnectedasyncdefclient_disconnected(client:Socks5Client):print(f"Client disconnected:{client}")@server.on_dataasyncdefdata_received(client:Socks5Client,direction:DataDirection,data:bytes):print(f"{direction}|{data}")if__name__=='__main__':get_event_loop().run_until_complete(server.serve())Run server with password authenticationfromasyncioimportget_event_loopfromsocks5serverimportSocksServer,PasswordAuthenticationserver=SocksServer("0.0.0.0",1080)users={"test_login1":"test_password1","login":"password"}server.register_authentication(0x02,PasswordAuthentication(users))# 0x02 is password authentication typeif__name__=='__main__':get_event_loop().run_until_complete(server.serve())Run server with custom authenticationAll Authentication methodsimportasynciofromasyncioimportget_event_loopfromsocks5serverimportSocksServer,AuthenticationBaseclassChallengeHandshakeAuthentication(AuthenticationBase):asyncdefauthenticate(self,reader:asyncio.StreamReader,writer:asyncio.StreamWriter)->bool:...# Implement authentication processreturnTrueserver=SocksServer("0.0.0.0",1080)# 0x03 is type of Challenge–Handshake Authentication Protocolserver.register_authentication(0x03,ChallengeHandshakeAuthentication())if__name__=='__main__':get_event_loop().run_until_complete(server.serve())
Package: pysocksproto
PysocksprotoA library for creating your own programs on SOCKS protoExamplesOpen a simply socks serverimport pysocksproto
hs = pysocksproto.socksServer("0.0.0.0", 4545, pysocksproto.socksThread)
hs.serve()To support BIND command, you have to specify ipv4 or ipv6 bind adresseshs.set_bind_addresses("0.0.0.0", None)To support username/password authhs = pysocksproto.socksServer("0.0.0.0", 
                            4545,  
                            pysocksproto.socksThread,    
                            require_auth=True, 
                            valid_creds={"username":"passw0rd", "u2":"p2"})Or override verify_creds method in socksThread, for your own verification methodclass custom(pysocksproto.socksThread):
    def verify_creds(self, username:str, password:str):
        if random.randint(0, 2) == 1:
            return True
        return False

hs = pysocksproto.socksServer("0.0.0.0", 4545, custom, require_auth=True)
hs.serve()You can use methods stored in Tools class, methods that start with "server" - provide server functionality, with "client"  - client functionality.For example, use your own CONNECT method - allow connect only to specific adressesclass custom(pysocksproto.socksThread):
    def connect_request_handler(self, version:int, cmd:int, atype:int, target_address:str, target_port:int):
        allowed = ['12.34.56.78', '11.22.33.44']
        resolved = target_adress
        if atype == pysocksproto.ATYP_DOMAINNAME:
            resolved = socket.gethostbyname(resolved)
        if not resolved in allowed:
            pysocksproto.Tools.serverSendCmdResp(self.conn, 
                                    version, 
                                    pysocksproto.REPCODE_FORBIDDEN, 
                                    atype, 
                                    target_adress, 
                                    target_port)
            return
        super().connect_request_handler(version, cmd, atype, target_address, target_port)

hs = pysocksproto.socksServer("0.0.0.0", 4545, custom)
hs.serve()Bind a port on socks proxyclass socksBind - for creating BIND requests to socks servers.
Example:import ysocksproto

cl = pysocksproto.socksBind("132.232.14.30", 	33221)
_, address, port = cl.BindProxyPort()
print(f"Proxy bound a port {port} on {address}")
_, address2, port2 = cl.WaitProxyBindConnect()
print(f"Someone connected to proxy from {address2}:{port2}")
cl.conn.send(b"hello, baby\n")
print(cl.conn.recv(10))If you want to redirect connection to bound port on your system, usecl.CreateProxyRedirection("127.0.0.1", 4444)Program will connect to 127.0.0.1:4444, and then resend all data from proxy connection to 127.0.0.1 and back